创建证书

#include "stdafx.h"
#include <Windows.h>
#include <Wincrypt.h>
#include <iostream>
using namespace std;

#pragma comment(lib, "crypt32.lib")

const char*	g_szContainer = "cont_andylin";
const char* g_szIssuserName = "my name is andylin";
const char* g_szSubjectName = "test subject name";
const char* g_szCertFile = "d:/lin-x509.cer";

DWORD MakeCert();

int main()
{
	DWORD dwErr = MakeCert();

	if (dwErr != 0)
	{
		cout << "Make Cert Failed! Err Code = " << dwErr << endl;
	}
	else
	{
		cout << "Make Cert Succ!" << endl;
	}

	return 0;
}

DWORD MakeCert()
{
	HCRYPTPROV	hProv		= NULL;
	HCRYPTKEY	hKey		= NULL;
	BOOL		bRet		= FALSE;
	CERT_INFO	certInfo	= {0};

	BYTE abySerial[] = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"; 

	do 
	{

		bRet = CryptAcquireContext(&hProv, g_szContainer, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET);
		if (!bRet)
		{
			bRet = CryptAcquireContext(&hProv, g_szContainer, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
			bRet = CryptAcquireContext(&hProv, g_szContainer, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_NEWKEYSET);

			if (!bRet)
			{
				break;
			}
		}

		bRet = CryptGenKey(hProv, AT_SIGNATURE, CRYPT_EXPORTABLE, &hKey);

		if (!bRet)
		{
			break;
		}

		memset(&certInfo, 0, sizeof(certInfo));
		//1.version
		certInfo.dwVersion = 2;

		//2.SerialNumber
		certInfo.SerialNumber.cbData = sizeof(abySerial);
		certInfo.SerialNumber.pbData = abySerial;

		//3.algorithm
		certInfo.SignatureAlgorithm.pszObjId = szOID_RSA_SHA1RSA;
		certInfo.SignatureAlgorithm.Parameters.cbData = 0;

		//4.Issuer.Encode the Issuer name with ASN.1, reference MSDN source
		CERT_RDN_ATTR stRdnAttr = 
		{
			szOID_COMMON_NAME, //the OID
			CERT_RDN_PRINTABLE_STRING,
			(DWORD)strlen(g_szIssuserName) + 1, // string length including
			(LPBYTE)g_szIssuserName
		};

		CERT_RDN	stRdn[] = 
		{
			1, // number of elements in the CERT_RND's array
			&stRdnAttr
		};

		CERT_NAME_INFO stNameInfo = 
		{
			1,	//number of elements in the CERT_RND's array 
			stRdn
		};

		DWORD	dwEncode	= 0;
		LPBYTE	pbEncode	= NULL;

		bRet = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_NAME, &stNameInfo, 0, NULL, NULL, &dwEncode);

		if (!bRet)
		{
			break;
		}

		pbEncode = new BYTE[dwEncode];
		if (NULL == pbEncode)
		{
			break;
		}

		bRet = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_NAME, &stNameInfo, 0, NULL, NULL, &dwEncode);
		if (!bRet)
		{
			break;
		}

		certInfo.Issuer.cbData = dwEncode;
		certInfo.Issuer.pbData = pbEncode;

		//5.UTCTime .Process the Time of cert. SystemTimeToFileTime
		SYSTEMTIME tmSys;
		GetSystemTime(&tmSys);
		SystemTimeToFileTime(&tmSys, &certInfo.NotBefore);
		tmSys.wYear += 10;
		SystemTimeToFileTime(&tmSys, &certInfo.NotAfter);

		//6. subject
		stRdnAttr.pszObjId = szOID_COMMON_NAME;
		stRdnAttr.dwValueType = CERT_RDN_PRINTABLE_STRING;
		stRdnAttr.Value.cbData = (DWORD)strlen(g_szSubjectName) + 1;
		stRdnAttr.Value.pbData = (PBYTE)g_szSubjectName;

		bRet = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_NAME, &stNameInfo, 0, NULL, NULL, &dwEncode);

		if (!bRet)
		{
			break;
		}

		pbEncode = new BYTE[dwEncode];
		if (NULL == pbEncode)
		{
			break;
		}

		bRet = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_NAME, &stNameInfo, 0, NULL, NULL, &dwEncode);
		if (!bRet)
		{
			break;
		}

		certInfo.Issuer.cbData = dwEncode;
		certInfo.Issuer.pbData = pbEncode;

		//7.PublicKey
		DWORD dwPubKeyLen = 0;
		PCERT_PUBLIC_KEY_INFO	pstKeyInfo = NULL;//reference RACrypt.cpp .Don't know why
		bRet = CryptExportPublicKeyInfo(hProv, AT_SIGNATURE, X509_ASN_ENCODING, NULL, &dwPubKeyLen);

		if (!bRet)
		{
			break;
		}

		pstKeyInfo = (PCERT_PUBLIC_KEY_INFO)malloc(dwPubKeyLen);

		if (NULL == pstKeyInfo)
		{
			break;
		}

		bRet = CryptExportPublicKeyInfo(hProv, AT_SIGNATURE, X509_ASN_ENCODING, pstKeyInfo, &dwPubKeyLen);

		if (!bRet)
		{
			break;
		}

		certInfo.SubjectPublicKeyInfo = *pstKeyInfo;

		//extendsion 
        certInfo.cExtension = 0;
		certInfo.rgExtension = NULL;
		certInfo.IssuerUniqueId.cbData = 0;
		certInfo.SubjectUniqueId.cbData = 0;

		//Make Certificate
		CRYPT_ALGORITHM_IDENTIFIER algId;
		BYTE abyData[16] = {0};
		abyData[0] = 0x05;
		abyData[1] = 0x00;

		algId.pszObjId = szOID_RSA_SHA1RSA;
		algId.Parameters.cbData = 2;
		algId.Parameters.pbData = abyData;

		/*------------------------------------------------------------- 
		CryptSignAndEncodeCertificate 
		The CryptSignAndEncodeCertificate function encodes and signs a certificate, CRL, CTL or certificate request. 
		This function performs the following operations: 
		1-> Calls CryptEncodeObject using lpszStructType to encode the "to be signed" information. 
		2-> Calls CryptSignCertificate to sign this encoded information. 
		3-> Calls CryptEncodeObject again, with lpszStructType set to X509_CERT, 
		to further encode the resulting signed, encoded information. 
		-------------------------------------------------------------*/ 

		// Export As X.509 certificate
		PBYTE pbyCertOut = NULL;
		DWORD dwCertLen = 0;
		bRet = CryptSignAndEncodeCertificate(hProv, AT_SIGNATURE, X509_ASN_ENCODING, X509_CERT_TO_BE_SIGNED, (void*)&certInfo,
			&algId, NULL, NULL, &dwCertLen);

		if (!bRet)
		{
			break;
		}

		pbyCertOut = new BYTE[dwCertLen];
		if (NULL == pbyCertOut)
		{
			break;
		}

		bRet = CryptSignAndEncodeCertificate(hProv, AT_SIGNATURE, X509_ASN_ENCODING, X509_CERT_TO_BE_SIGNED, &certInfo, &algId,
			NULL, pbyCertOut, &dwCertLen);

		if (!bRet)
		{
			break;
		}

		DWORD dwLen = 0;
		HANDLE hFile = CreateFile(g_szCertFile, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
			CREATE_ALWAYS, NULL, NULL);

		if (INVALID_HANDLE_VALUE == hFile)
		{
			break;
		}

		bRet = WriteFile(hFile, pbyCertOut, dwCertLen, &dwLen, NULL);
		CloseHandle(hFile);

		if (!bRet)
		{
			break;
		}
		
	} while (0);

	if (!bRet)
	{
		return GetLastError();
	}

	return 0;
}