WinVerifyTrust prüfen, ob eine bestimmte Signatur?

Ich bin Implementierung einer Prozess-elevation helper für Windows. Es ist ein Programm, das ausgeführt wird, im erhöhten Modus, und starten Sie andere Programme mit administrator-Privilegien ohne weitere UAC-Eingabeaufforderungen. Aus Gründen der Sicherheit, ich möchte sicherstellen, dass nur binaries, die sind Digital signiert mit meiner Firma Authenticode-Schlüssel ausgeführt werden können.

Den WinVerifyTrust Funktion bekommt von mir auf halbem Weg dorthin, aber es bewirkt nur, dass ein binary ist unterzeichnet von einige Schlüssel, der Teil von Microsoft ' s chain-of-trust. Gibt es eine relativ einfache Weise führen Sie die Authenticode-überprüfung UND sicherzustellen, dass es ist signiert mit unserem privaten Schlüssel?

InformationsquelleAutor joshk0 | 2009-07-02
  1. 9

    Ich glaube was du suchst ist CryptQueryObject.

    Sie sollten in der Lage sein zu ziehen, der beteiligt Zertifikat aus einer PE, und zusätzliche Prüfungen, die Sie wollen.

    Beispielhaft, dies erhalten Sie zu einem HCRYPTMSG. Von dort aus können Sie CryptMsgGetParam zu ziehen, was Sie wollen. Ich hatte gehofft, etwas zu machen, mehr 'robuste', aber diese APIs sind ziemlich Behaart so, wie Sie erfordern eine Menge von Verzweigungen zu handhaben, alle Ihre Rückkehr zu Fällen.

    So, hier ist ein p/invoke-rific c# - Beispiel (ich begann in der C, aber das war im Grunde nicht mehr lesbar ist):

    static class Crypt32
{
    //Omitting flag constants; you can look these up in WinCrypt.h

    [DllImport("CRYPT32.DLL", EntryPoint = "CryptQueryObject", CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool CryptQueryObject(
        int dwObjectType,
        IntPtr pvObject,
        int dwExpectedContentTypeFlags,
        int dwExpectedFormatTypeFlags,
        int dwFlags,
        out int pdwMsgAndCertEncodingType,
        out int pdwContentType,
        out int pdwFormatType,
        ref IntPtr phCertStore,
        ref IntPtr phMsg,
        ref IntPtr ppvContext);
}

class Program
{
    static void Main(string[] args)
    {
        //Path to executable here
        // I tested with MS-Office .exe's
        string path = "";

        int contentType;
        int formatType;
        int ignored;
        IntPtr context = IntPtr.Zero;
        IntPtr pIgnored = IntPtr.Zero;

        IntPtr cryptMsg = IntPtr.Zero;

        if (!Crypt32.CryptQueryObject(
            Crypt32.CERT_QUERY_OBJECT_FILE,
            Marshal.StringToHGlobalUni(path),
            Crypt32.CERT_QUERY_CONTENT_FLAG_ALL,
            Crypt32.CERT_QUERY_FORMAT_FLAG_ALL,
            0,
            out ignored,
            out contentType,
            out formatType,
            ref pIgnored,
            ref cryptMsg,
            ref context))
        {
            int error = Marshal.GetLastWin32Error();

            Console.WriteLine((new Win32Exception(error)).Message);

            return;
        }

        //expecting '10'; CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED
        Console.WriteLine("Context Type: " + contentType);

        //Which implies this is set
        Console.WriteLine("Crypt Msg: " + cryptMsg.ToInt32());

        return;
    }
    • Ich denke, ich werde versuchen und gin einige code, wie ich ein wenig Interesse, in Windows-Sicherheit.
    • +1 Großes, das ist das Zauberwort. Sie googeln für "CryptQueryObject" und "Authenticode" hab mir das: support.microsoft.com/kb/323809 - das ist genau das, was der Arzt bestellt. Ich lade Sie ein, noch ergänzen Sie Ihren code, aber 🙂
    • Gah, diese sind einige der übelsten APIs mit dem ich gearbeitet habe. Nicht einer meiner besten arbeiten mit allen Mitteln. Hoffentlich ein wenig hilfreich für diejenigen, die kommen auf diese Frage in der Zukunft.
    InformationsquelleAutor Kevin Montrose
  2. 9

    Zertifikat abrufen von Informationen von signiertem code verwenden:

    using System.Security.Cryptography.X509Certificates;
X509Certificate basicSigner = X509Certificate.CreateFromSignedFile(filename);
X509Certificate2 cert = new X509Certificate2(basicSigner);

    Dann kannst du den cert details wie dieses:

    Console.WriteLine(cert.IssuerName.Name);
Console.WriteLine(cert.SubjectName.Name);
//etc
    • Das ist schön und einfach, aber wenn eine Datei enthält mehrere Signaturen, es wird nur das erste Zertifikat
    InformationsquelleAutor
  3. 5

    diese sind einige der übelsten APIs mit dem ich gearbeitet habe

    Ein Wort der Warnung: es ist schlimmer als Sie schon dachte.

    Mindestens seit der Einführung von SHA-256 signieren (hat dies schon immer der Fall?), es ist möglich für Authenticode, um mehrere Unterschriften. Sie sind nicht codiert, wie mehrere Signaturen in PKCS-7 Signatur Nachricht; statt, Sie sind nicht authentifizierte Nachricht Attribute des Typs OID_NESTED_SIGNATURE, die jeweils eine komplette PKCS-7 Signatur Nachricht.

    WinVerifyTrust wird Ihnen sagen, die Datei ist gültig, wenn eine der Signaturen gültig sind, und kommen von einer vertrauenswürdigen Zertifikatkette. Aber es wird Ihnen nicht sagen, welches der Unterschrift gültig war. Wenn Sie dann CryptQueryObject Lesen Sie das vollständige PKCS-7-Nachricht, und nur einen Blick auf das Zertifikat für den primären Unterschrift (wie im code-Beispiele hier und auf der MSDN-Website), sind Sie nicht unbedingt auf der Suche auf ein geprüftes Zertifikat. Die zugehörige Signatur kann nicht mit der ausführbaren Datei, und/oder das Zertifikat möglicherweise nicht über eine trusted-CA-chain.

    Wenn Sie mit den Angaben der primär-Unterschrift zu bestätigen, dass das Zertifikat ist eine, die Ihre software vertraut, Sie sind anfällig für eine situation, in der WinVerifyTrust-ist Vertrauen eine sekundäre Signatur, aber dein code ist die überprüfung der primär-Signatur-Zertifikat ist das, was Sie erwartet, und Sie haben nicht bemerkt, dass die Unterschrift von der primär-Zertifikat ist Unsinn. Ein Angreifer kann mit Ihrem öffentlichen Zertifikat, ohne den Besitz des privaten Schlüssels, kombiniert mit einigen anderen code-Signatur-Zertifikat ausgestellt hat, um jemand anderes, zu umgehen Verleger überprüft werden.

    Von Win8 ab, WinVerifyTrust kann Optional Validierung der spezifischen Signaturen, so dass Sie sollten in der Lage sein zu Durchlaufen, die Signaturen zu finden, die gültig ist und eine, die Ihren Anforderungen genügt.

    Wenn man Win7-kompatibel, obwohl, so weit ich weiß, die besten, die Sie verwalten können, ist MsiGetFileSignatureInformation. Aus Experimenten (wie für alles andere hier, die tatsächlichen Unterlagen ist frustrierend wollig), scheint es Rückkehr des vertrauenswürdigen Zertifikats ist bei der WinVerifyTrust-trusts ein. Aber wenn es nicht eine Vertrauenswürdige Signatur, es gibt die primäre Signatur das Zertifikat trotzdem, so haben Sie immer noch zu verwenden WinVerifyTrust zu überprüfen, die erste.

    Natürlich gibt es auch viele mögliche time-of-check/time-of-use Probleme hier.

    InformationsquelleAutor bobince
  4. 1

    hier die Lösung gefunden:

    http://www.ucosoft.com/how-to-program-to-retrieve-the-authenticode-information.html

    hier ist es mit Einzug:

    #define _UNICODE 1
#define UNICODE 1

#include <windows.h>
#include <tchar.h>
#include <wincrypt.h>
#include <Softpub.h>
#include <stdio.h>
#include <stdlib.h>

#pragma comment (lib, "Crypt32")

//the Authenticode Signature is encode in PKCS7
#define ENCODING (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING)

//Information structure of authenticode sign
typedef struct 
{
    LPWSTR lpszProgramName; 
    LPWSTR lpszPublisherLink;
    LPWSTR lpszMoreInfoLink;

    DWORD cbSerialSize;
    LPBYTE lpSerialNumber;
    LPTSTR lpszIssuerName;
    LPTSTR lpszSubjectName;
} 
SPROG_SIGNATUREINFO, *PSPROG_SIGNATUREINFO;

VOID GetProgAndPublisherInfo(PCMSG_SIGNER_INFO pSignerInfo, PSPROG_SIGNATUREINFO pInfo);
VOID GetCertificateInfo(HCERTSTORE hStore, PCMSG_SIGNER_INFO pSignerInfo, PSPROG_SIGNATUREINFO pInfo);

BOOL GetAuthenticodeInformation(LPCTSTR lpszFileName, PSPROG_SIGNATUREINFO pInfo)
{
    HCERTSTORE hStore = NULL;
    HCRYPTMSG hMsg = NULL;
    PCMSG_SIGNER_INFO pSignerInfo = NULL;
    DWORD dwSignerInfo;

    BOOL bRet = FALSE;

    __try
    {
        //as CryptQueryObject() only accept WCHAR file name, convert first
        WCHAR wszFileName[MAX_PATH];
#ifdef UNICODE
        if ( !lstrcpynW( wszFileName, lpszFileName, MAX_PATH))
            __leave;
#else
        if ( mbstowcs( wszFileName, lpszFileName, MAX_PATH) == -1)
            __leave;
#endif
        //Retrieve the Message Handle and Store Handle
        DWORD dwEncoding, dwContentType, dwFormatType;
        if ( !CryptQueryObject( CERT_QUERY_OBJECT_FILE, wszFileName,
                                CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
                                CERT_QUERY_FORMAT_FLAG_BINARY, 0, &dwEncoding,
                                &dwContentType, &dwFormatType, &hStore,
                                &hMsg, NULL))
            __leave;

        //Get the length of SignerInfo
        if ( !CryptMsgGetParam( hMsg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &dwSignerInfo))
            __leave;

        //allocate the memory for SignerInfo
        if ( !(pSignerInfo = (PCMSG_SIGNER_INFO)LocalAlloc( LPTR, dwSignerInfo)))
            __leave;

        //get the SignerInfo
        if ( !CryptMsgGetParam( hMsg, CMSG_SIGNER_INFO_PARAM, 0, (PVOID)pSignerInfo, &dwSignerInfo))
            __leave;

        //get the Publisher from SignerInfo
        GetProgAndPublisherInfo( pSignerInfo, pInfo);

        //get the Certificate from SignerInfo
        GetCertificateInfo( hStore, pSignerInfo, pInfo);

        bRet = TRUE;
    }
    __finally
    {
        //release the memory
        if (pSignerInfo != NULL) LocalFree(pSignerInfo);
        if (hStore != NULL) CertCloseStore(hStore, 0);
        if (hMsg != NULL) CryptMsgClose(hMsg);
    }
    return bRet;
}


LPWSTR AllocateAndCopyWideString(LPCWSTR inputString)
{
    LPWSTR outputString = NULL;

    //allocate the memory
    outputString = (LPWSTR)VirtualAlloc(NULL, (wcslen(inputString) + 1) * sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE);

    //copy
    if (outputString != NULL)
    {
        lstrcpyW(outputString, inputString);
    }

    return outputString;
}


VOID GetProgAndPublisherInfo(PCMSG_SIGNER_INFO pSignerInfo, PSPROG_SIGNATUREINFO pInfo)
{
    PSPC_SP_OPUS_INFO OpusInfo = NULL;
    DWORD dwData;

    __try
    {
        //query SPC_SP_OPUS_INFO_OBJID OID in Authenticated Attributes
        for (DWORD n = 0; n < pSignerInfo->AuthAttrs.cAttr; n++)
        {
            if (lstrcmpA(SPC_SP_OPUS_INFO_OBJID, pSignerInfo->AuthAttrs.rgAttr[n].pszObjId) == 0)
            {
                //get the length of SPC_SP_OPUS_INFO
                if ( !CryptDecodeObject(ENCODING,
                                        SPC_SP_OPUS_INFO_OBJID,
                                        pSignerInfo->AuthAttrs.rgAttr[n].rgValue[0].pbData,
                                        pSignerInfo->AuthAttrs.rgAttr[n].rgValue[0].cbData,
                                        0,
                                        NULL,
                                        &dwData))
                    __leave;

                //allocate the memory for SPC_SP_OPUS_INFO
                if ( !(OpusInfo = (PSPC_SP_OPUS_INFO)LocalAlloc(LPTR, dwData)))
                    __leave;

                //get SPC_SP_OPUS_INFO structure
                if ( !CryptDecodeObject(ENCODING,
                                        SPC_SP_OPUS_INFO_OBJID,
                                        pSignerInfo->AuthAttrs.rgAttr[n].rgValue[0].pbData,
                                        pSignerInfo->AuthAttrs.rgAttr[n].rgValue[0].cbData,
                                        0,
                                        OpusInfo,
                                        &dwData))
                    __leave;

                //copy the Program Name of SPC_SP_OPUS_INFO to the return variable
                if (OpusInfo->pwszProgramName)
                {
                    pInfo->lpszProgramName = AllocateAndCopyWideString(OpusInfo->pwszProgramName);
                }
                else
                    pInfo->lpszProgramName = NULL;

                //copy the Publisher Info of SPC_SP_OPUS_INFO to the return variable
                if (OpusInfo->pPublisherInfo)
                {
                    switch (OpusInfo->pPublisherInfo->dwLinkChoice)
                    {
                        case SPC_URL_LINK_CHOICE:
                            pInfo->lpszPublisherLink = AllocateAndCopyWideString(OpusInfo->pPublisherInfo->pwszUrl);
                            break;

                        case SPC_FILE_LINK_CHOICE:
                            pInfo->lpszPublisherLink = AllocateAndCopyWideString(OpusInfo->pPublisherInfo->pwszFile);
                            break;

                        default:
                            pInfo->lpszPublisherLink = NULL;
                            break;
                    }
                }
                else
                {
                    pInfo->lpszPublisherLink = NULL;
                }

                //copy the More Info of SPC_SP_OPUS_INFO to the return variable
                if (OpusInfo->pMoreInfo)
                {
                    switch (OpusInfo->pMoreInfo->dwLinkChoice)
                    {
                        case SPC_URL_LINK_CHOICE:
                            pInfo->lpszMoreInfoLink = AllocateAndCopyWideString(OpusInfo->pMoreInfo->pwszUrl);
                            break;

                        case SPC_FILE_LINK_CHOICE:
                            pInfo->lpszMoreInfoLink = AllocateAndCopyWideString(OpusInfo->pMoreInfo->pwszFile);
                            break;

                        default:
                            pInfo->lpszMoreInfoLink = NULL;
                            break;
                    }
                }
                else
                {
                    pInfo->lpszMoreInfoLink = NULL;
                }

                break; //we have got the information, break
            }
        }
    }
    __finally
    {
        if (OpusInfo != NULL) LocalFree(OpusInfo);
    }
}


VOID GetCertificateInfo(HCERTSTORE hStore, PCMSG_SIGNER_INFO pSignerInfo, PSPROG_SIGNATUREINFO pInfo)
{
    PCCERT_CONTEXT pCertContext = NULL;

    __try
    {
        CERT_INFO CertInfo;
        DWORD dwData;

        //query Signer Certificate in Certificate Store
        CertInfo.Issuer = pSignerInfo->Issuer;
        CertInfo.SerialNumber = pSignerInfo->SerialNumber;

        if ( !(pCertContext = CertFindCertificateInStore(   hStore,
                                                            ENCODING, 0, CERT_FIND_SUBJECT_CERT,
                                                            (PVOID)&CertInfo, NULL)))
            __leave;

        dwData = pCertContext->pCertInfo->SerialNumber.cbData;

        //SPROG_SIGNATUREINFO.cbSerialSize
        pInfo->cbSerialSize = dwData;

        //SPROG_SIGNATUREINFO.lpSerialNumber
        pInfo->lpSerialNumber = (LPBYTE)VirtualAlloc(NULL, dwData, MEM_COMMIT, PAGE_READWRITE);
        memcpy( pInfo->lpSerialNumber, pCertContext->pCertInfo->SerialNumber.pbData, dwData);

        //SPROG_SIGNATUREINFO.lpszIssuerName
        __try
        {
            //get the length of Issuer Name
            if (!(dwData = CertGetNameString(   pCertContext,
                                                CERT_NAME_SIMPLE_DISPLAY_TYPE,
                                                CERT_NAME_ISSUER_FLAG, NULL, NULL, 0)))
                __leave;

            //allocate the memory
            if ( !(pInfo->lpszIssuerName = (LPTSTR)VirtualAlloc(NULL, dwData * sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE)))
                __leave;

            //get Issuer Name
            if (!(CertGetNameString(pCertContext,
                                    CERT_NAME_SIMPLE_DISPLAY_TYPE,
                                    CERT_NAME_ISSUER_FLAG, NULL, pInfo->
                                    lpszIssuerName, dwData)))
                __leave;
        }
        __finally
        {
        }

        //SPROG_SIGNATUREINFO.lpszSubjectName
        __try
        {
            //get the length of Subject Name
            if (!(dwData = CertGetNameString( pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL, NULL, 0)))
                __leave;

            //allocate the memory
            if ( !(pInfo->lpszSubjectName = (LPTSTR)VirtualAlloc(NULL, dwData * sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE)))
                __leave;

            //get Subject Name
            if (!(CertGetNameString( pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL, pInfo->lpszSubjectName, dwData)))
                __leave;
        }
        __finally
        {
        }
    }
    __finally
    {
        if (pCertContext != NULL)
            CertFreeCertificateContext(pCertContext);
    }
}


int _tmain(int argc, TCHAR *argv[])
{
    if (argc != 2)
    {
        _tprintf(_T("Usage: SignedFileInfo \n"));
        return 0;
    }
    else
    {
        SPROG_SIGNATUREINFO SignInfo;

        ZeroMemory(&SignInfo, sizeof(SignInfo));

        GetAuthenticodeInformation( argv[1], &SignInfo);

        wprintf(L"Program Name: %s\n", SignInfo.lpszProgramName);
        wprintf(L"Publisher Link: %s\n", SignInfo.lpszPublisherLink);
        wprintf(L"More Info Link: %s\n", SignInfo.lpszMoreInfoLink);

        {
            _tprintf(_T("Serial Number: "));
            DWORD dwData = SignInfo.cbSerialSize;
            for (DWORD n = 0; n < dwData; n++)
            {
                _tprintf(_T("%02x "),
                    SignInfo.lpSerialNumber[dwData - (n + 1)]);
            }
            _tprintf(_T("\n"));
        }
        _tprintf(_T("Issuer Name: %s\n"), SignInfo.lpszIssuerName);
        _tprintf(_T("Subject Name: %s\n"), SignInfo.lpszSubjectName);
        if ( SignInfo.lpszProgramName) VirtualFree(SignInfo.lpszProgramName, 0, MEM_RELEASE);
        if ( SignInfo.lpszPublisherLink) VirtualFree(SignInfo.lpszPublisherLink, 0, MEM_RELEASE);
        if ( SignInfo.lpszMoreInfoLink) VirtualFree(SignInfo.lpszMoreInfoLink, 0, MEM_RELEASE);
        if ( SignInfo.lpSerialNumber) VirtualFree(SignInfo.lpSerialNumber, 0, MEM_RELEASE);
        if ( SignInfo.lpszIssuerName) VirtualFree(SignInfo.lpszIssuerName, 0, MEM_RELEASE);
        if ( SignInfo.lpszSubjectName) VirtualFree(SignInfo.lpszSubjectName, 0, MEM_RELEASE);

        return 0;
    }
}
    InformationsquelleAutor nir
Schreibe einen Kommentar