signfile.cpp

Digital Signature key tool

	typedef BOOL (WINAPI *PFN_PFXIsPFXBlob)(CRYPT_DATA_BLOB* pPFX);
	PFN_PFXIsPFXBlob fnPFXIsPFXBlob;
	fnPFXIsPFXBlob = (PFN_PFXIsPFXBlob)
		GetProcAddress(GetModuleHandle(_T("crypt32.dll")), "PFXIsPFXBlob");
	if (fnPFXIsPFXBlob)
	{
		return fnPFXIsPFXBlob(pPFX);
	}
	return FALSE;
}

HCERTSTORE WINAPI MyPFXImportCertStore(
									 CRYPT_DATA_BLOB* pPFX,
									 LPCWSTR szPassword,
									 DWORD dwFlags
									 )
{
	typedef HCERTSTORE (WINAPI *PFN_PFXImportCertStore)(
								CRYPT_DATA_BLOB* pPFX,
								LPCWSTR szPassword,
								DWORD dwFlags
								);
	PFN_PFXImportCertStore fnPFXImportCertStore;
	fnPFXImportCertStore = (PFN_PFXImportCertStore)
		GetProcAddress(GetModuleHandle(_T("crypt32.dll")), "PFXImportCertStore");
	if (fnPFXImportCertStore)
	{
		return fnPFXImportCertStore(pPFX, szPassword, dwFlags);
	}
	return 0;
}


HCERTSTORE
PfxOpenStore(LPTSTR pszPfxFileName)
{
	HANDLE		hsection = NULL;
	void*		pfx = NULL;
	HANDLE		hfile = INVALID_HANDLE_VALUE;
	HCERTSTORE	pfxStore = NULL;
	CRYPT_DATA_BLOB blob;
	WCHAR		wszPassword[256];
	LPWSTR		pwszPassword = L"";
	
	hfile = CreateFile(pszPfxFileName, FILE_READ_DATA, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
	if (INVALID_HANDLE_VALUE == hfile) 
		goto Done;
	
	hsection = CreateFileMapping(hfile, 0, PAGE_READONLY, 0, 0, 0);
	if (!hsection) 
		goto Done;
	
	pfx = MapViewOfFile(hsection, FILE_MAP_READ, 0, 0, 0);
	
	if (!pfx) 
		goto Done;
	
	blob.cbData = GetFileSize(hfile, 0);
	blob.pbData = (BYTE*)pfx;
	if (!MyPFXIsPFXBlob(&blob))
		goto Done;
	
	if (pszPassword)
	{
#ifdef UNICODE
		pwszPassword = pszPassword;
#else
		MultiByteToWideChar(CP_ACP,
			0,
			pszPassword,
			-1,
			wszPassword,
			sizeof(wszPassword)/sizeof(wszPassword[0]));
		pwszPassword = wszPassword;
#endif
	}
	
	pfxStore = MyPFXImportCertStore(&blob, pwszPassword, CRYPT_MACHINE_KEYSET | CRYPT_EXPORTABLE);
	
Done:
	if (pfx) 
		UnmapViewOfFile(pfx);
	if (hsection)
		CloseHandle(hsection);
	if (INVALID_HANDLE_VALUE != hfile)
		CloseHandle(hfile);
	
	return pfxStore;
}

BOOL MyCryptAcquireCertificatePrivateKey(
										 PCCERT_CONTEXT pCert,
										 DWORD dwFlags,
										 void* pvReserved,
										 HCRYPTPROV* phCryptProv,
										 DWORD* pdwKeySpec,
										 BOOL* pfCallerFreeProv
										 )
{
	typedef BOOL (WINAPI *PFN_CryptAcquireCertificatePrivateKey)(
								PCCERT_CONTEXT pCert,
								DWORD dwFlags,
								void* pvReserved,
								HCRYPTPROV* phCryptProv,
								DWORD* pdwKeySpec,
								BOOL* pfCallerFreeProv
								);
	PFN_CryptAcquireCertificatePrivateKey fnCryptAcquireCertificatePrivateKey;
	fnCryptAcquireCertificatePrivateKey = (PFN_CryptAcquireCertificatePrivateKey)
		GetProcAddress(GetModuleHandle(_T("crypt32.dll")), "CryptAcquireCertificatePrivateKey");
	if (fnCryptAcquireCertificatePrivateKey)
	{
		return fnCryptAcquireCertificatePrivateKey(pCert, dwFlags, pvReserved, phCryptProv, pdwKeySpec, pfCallerFreeProv);
	}
	return FALSE;
}

BOOL
MyCryptAcquireContext(
					 HCRYPTPROV *phProv,
					 LPTSTR pszProviderName,
					 DWORD dwFlags)
{
	HCERTSTORE			hCertStore = NULL;
	PCCERT_CONTEXT		pCertContext = NULL;
	DWORD				dwKeySpec;
	
	*phProv = 0;

	if (dwFlags & PROVIDER_KEY_CONTAINER)
	{
		return CryptAcquireContext(phProv, pszProviderName, NULL, PROV_RSA_FULL, 0);
	}
	else if (dwFlags & PROVIDER_CERT_FILE)
	{
		hCertStore = CertOpenStore(
#ifdef UNICODE
							CERT_STORE_PROV_FILENAME_W,    // the store provider type
#else
							CERT_STORE_PROV_FILENAME_A,    // the store provider type
#endif
							ENCODING_TYPE,               // if needed, use the usual encoding types
							0,                        // use the default HCRYPTPROV
							0,                           // accept the default for all
							// dwFlags
							pszProviderName );          // the name of an existing file
	}
	else if (dwFlags & PROVIDER_PFX_FILE)
	{
		hCertStore = PfxOpenStore(pszProviderName);
	}
	else
		return FALSE;

	if (hCertStore)
	{
		pCertContext = CertEnumCertificatesInStore(hCertStore, NULL);
		if (pCertContext)
		{
			MyCryptAcquireCertificatePrivateKey(pCertContext, 0, NULL, phProv, &dwKeySpec, NULL);
			CertFreeCertificateContext(pCertContext);
		}
		CertCloseStore(hCertStore, 0);
	}
	
	return *phProv != 0;
}

BOOL CAPISign(HANDLE hFile, LPTSTR pszProviderName, DWORD dwFlags, BYTE **ppbSign, DWORD *pcbSign)
{
    BOOL fRet;
    HCRYPTPROV hProv = 0;
    HCRYPTHASH hHash = 0;
	
    PBYTE pbSignature = NULL;
	
    DWORD cbSize,cbSizeRead;
    static UCHAR buf[4096];
	
    // Get handle to the default provider.
    if(!MyCryptAcquireContext(&hProv, pszProviderName, dwFlags)) {
        _tprintf(TEXT("Error %x during CryptAcquireContext!\n"), GetLastError());
		goto error;
    }
    if (pszPublicKey)
    {
        DumpPublicKey(hProv, pszPublicKey);
    }
	// Create a hash object.
    if(!CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash)) {
		_tprintf(TEXT("Error %x during CryptCreateHash!\n"), GetLastError());
		goto error;
    }
    cbSize = GetFileSize(hFile,NULL);
	
    if (fAppendToPE)
    {
        fRet = ComputeHashPE(hFile, CryptDigestFunction, (DIGEST_HANDLE)hHash);
        if (!fRet)
            goto error;
    }
    else
		while (cbSize)
		{
			
			if (!ReadFile(hFile,buf, sizeof(buf), &cbSizeRead,NULL)
				|| cbSizeRead == 0)
			{
				return FALSE;
			}
			// Add data to hash object.
			if(!CryptHashData(hHash, buf, cbSizeRead, 0)) {
				_tprintf(TEXT("Error %x during CryptHashData!\n"), GetLastError());
				goto error;
			}
			cbSize -= cbSizeRead;
		}
		// hash attrib string, if present
		if (pbAttrib)
		{
			if(!CryptHashData(hHash, (LPBYTE)pbAttrib, cbAttrib, 0)) {
				_tprintf(TEXT("Error %x during CryptHashData!\n"), GetLastError());
				goto error;
			}
			
		}
		// Determine size of signature.
		if(!CryptSignHash(hHash, AT_SIGNATURE, NULL, 0, NULL, pcbSign)) {
			_tprintf(TEXT("Error %x during CryptSignHash 1!\n"), GetLastError());
			goto error;
		}
		
		// Allocate memory for 'pbSignature'.
		if((pbSignature = (LPBYTE)LocalAlloc(LPTR, *pcbSign)) == NULL) {
			_tprintf(TEXT("Out of memory 2!\n"));
			goto error;
		}
		
		// Sign hash object (with signature key).
		if(!CryptSignHash(hHash, AT_SIGNATURE, NULL, 0, pbSignature, pcbSign)) {
			printf("Error %x during CryptSignHash 2!\n", GetLastError());
			LocalFree(pbSignature);
			goto error;
		}
		*ppbSign = pbSignature;
		fRet = TRUE;
		
Exit:   
		// Destroy hash object.
		if (hHash)
			CryptDestroyHash(hHash);
		
		// Release provider handle.
		if (hProv)
			CryptReleaseContext(hProv, 0);
		return fRet;
error:
		
		fRet = FALSE;
		goto Exit;
}
/*****************************************************************************/


BOOL AppendSignToPE(HANDLE hFile,
					PBYTE pbSignedData, DWORD cbSignedData,
					PBYTE pbSign, DWORD cbSign)
{
    PKCS1_MODULE_SIGN  *pWinCert;
    DWORD index;
    DWORD cbWinCert = (DWORD) (&((PKCS1_MODULE_SIGN *)(0))->bSignedData)+ cbSignedData + cbSign;
    BOOL fRet;
    pWinCert = (PKCS1_MODULE_SIGN*)LocalAlloc(0, cbWinCert);
    if (!pWinCert)
        return FALSE;
    pWinCert->dwLength = cbWinCert;
    pWinCert->wRevision = WIN_CERT_REVISION_1_0;
    pWinCert->wCertificateType = WIN_CERT_TYPE_PKCS1_SIGN;
    pWinCert->cbSignedData = cbSignedData;
    if (cbSignedData)
        memcpy(pWinCert->bSignedData, pbSignedData, cbSignedData);
    memcpy(pWinCert->bSignedData + cbSignedData, pbSign, cbSign);
	
    fRet = ImageAddCertificate(hFile, (LPWIN_CERTIFICATE)pWinCert, &index);
    LocalFree(pWinCert);
    return fRet;
}

#ifdef DEBUG
/*****************************************************************************/
static void 
PrintHexDump(DWORD length, PBYTE buffer)
{
    DWORD i,count,index;
    TCHAR rgbDigits[]=TEXT("0123456789abcdef");
    TCHAR rgbLine[100];
    char cbLine;
	
    for(index = 0; length; length -= count, buffer += count, index += count) 
    {
        count = (length > 16) ? 16:length;
		
        wsprintf(rgbLine, TEXT("%4.4x  "),index);
        cbLine = 6;
		
        for(i=0;i<count;i++) 
        {
            rgbLine[cbLine++] = rgbDigits[buffer[i] >> 4];
            rgbLine[cbLine++] = rgbDigits[buffer[i] & 0x0f];
            if(i == 7) 
            {
                rgbLine[cbLine++] = ':';
            } 
            else 
            {
                rgbLine[cbLine++] = ' ';
            }
        }
        for(; i < 16; i++) 
        {
            rgbLine[cbLine++] = ' ';
            rgbLine[cbLine++] = ' ';
            rgbLine[cbLine++] = ' ';
        }
		
        rgbLine[cbLine++] = ' ';
		
        for(i = 0; i < count; i++) 
        {
            if(buffer[i] < 32 || buffer[i] > 126) 
            {
                rgbLine[cbLine++] = '.';
            } 
            else 
            {
                rgbLine[cbLine++] = buffer[i];
            }
        }
		
        rgbLine[cbLine++] = 0;
        _tprintf(TEXT("%s\n"), rgbLine);
    }
}
#endif //DEBUG

/*****************************************************************************/
static void
WriteDataToFile(
				PTSTR  pszFilename,
				PBYTE pbData,
				DWORD cbData)
{
    DWORD cbWritten;
    HANDLE hFile = 
		CreateFile(pszFilename, GENERIC_WRITE, 0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile == INVALID_HANDLE_VALUE)
    {
        _tprintf(TEXT("**** Error opening file '%s'\n"), pszFilename);
        return;
    }
	
    if(!WriteFile(hFile, pbData, cbData, &cbWritten, NULL) )
    {
        _tprintf(TEXT("**** Error writing to file\n"));
    }
    _tprintf(TEXT("Output:  File %s bytes %d\n"),pszFilename, cbWritten);
	
    CloseHandle(hFile);
}

void MyHandleError(char *s)
{
    fprintf(stderr,"An error occurred in running the program. \n");
    fprintf(stderr,"%s\n",s);
    fprintf(stderr, "Error number %x.\n", GetLastError());
    fprintf(stderr, "Program terminating. \n");
    exit(1);
} // End of MyHandleError.