/*
* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Implementation of the CCertificateGenerator class
* INCLUDES
*
*/
#include "CertificateGenerator.h"
// ===========================================================================
// Construction/Destruction
// ===========================================================================
CCertificateGenerator::CCertificateGenerator()
{
m_KeyType = EDSACipher;
m_KeyLength = DEFAULT_KEY_LENGTH;
m_bPassword = FALSE;
m_bAsk = FALSE;
m_bVerbose = FALSE;
memset(m_certificateFile,0,MAXLEN);
memset(m_privateKeyFile, 0, MAXLEN);
memset(m_password, 0, MAXLEN);
memset(m_dname, 0, MAXLEN);
}
CCertificateGenerator::~CCertificateGenerator()
{
}
_TCHAR* CCertificateGenerator::GetDNamePtr()
{
return m_dname;
}
void CCertificateGenerator::SetDName(_TCHAR* aDntr)
{
if(aDntr)
{
_tcscpy(m_dname, aDntr);
}
}
void CCertificateGenerator::SetPrivKeyName(_TCHAR* aStr)
{
if(aStr)
_tcscpy(m_privateKeyFile, aStr);
}
void CCertificateGenerator::SetCertificateName(_TCHAR* aStr)
{
if(aStr)
{
_tcscpy(m_certificateFile, aStr);
}
}
void CCertificateGenerator::SetPassword(_TCHAR* aStr)
{
if(aStr)
{
_tcscpy(m_password, aStr);
}
}
void CCertificateGenerator::SetKeyType(TKeyType aKey)
{
m_KeyType = aKey;
}
void CCertificateGenerator::SetKeyLength(int aLen)
{
if(aLen >= 0)
{
m_KeyLength = aLen;
}
}
void CCertificateGenerator::SetPasswordRequirement(bool aPwReq)
{
m_bPassword = aPwReq;
}
void CCertificateGenerator::SetAskPassword(bool aAsk)
{
m_bAsk = aAsk;
}
void CCertificateGenerator::SetVerbose(bool aVerbose)
{
m_bVerbose = aVerbose;
}
void CCertificateGenerator::PrintErrorInfo(char* aMsg, TErrType aErrType, const char* aFileName, int aLineNum)
{
PrintError(aMsg, aErrType, m_bVerbose, aFileName, aLineNum);
}
BOOL CCertificateGenerator::Exists(const _TCHAR* aFile)
{
FILE *fp = NULL;
fp = _tfopen(aFile , _T("r"));
if(fp)
{
fclose(fp);
return TRUE;
}
else
{
return FALSE;
}
}
void CCertificateGenerator::View(const _TCHAR* aCertName)
{
HINSTANCE retVal = 0;
if(!aCertName)
{
PrintErrorInfo("Bad parameter error!",EGeneric, constparams);
return;
}
retVal = ShellExecute(NULL, _T("open"), aCertName, NULL, NULL, SW_SHOWNORMAL);
if((int)retVal <= 32)
{
PrintErrorInfo("Error showing certificate!", EMSCrypto, constparams);
}
}
int CCertificateGenerator::MakeSelfSigned(_TCHAR* aPassword, _TCHAR* aDname, _TCHAR* aPrivOut, _TCHAR* aPubOut, int aBits, int aSerial, int aDays)
//Create self-signed certificate and write into a file
{
FILE* fp = NULL;
EVP_PKEY* pKey = NULL;
X509* pCert = NULL;
X509_NAME* pSubj = NULL;
const EVP_MD* pDigest = NULL;
LPSTR pbPasswdUTF8 = NULL;
DWORD bytesWritten;
struct entry_pack* pEntPack = NULL;
int retFunc = FAIL;
int retVal = FAIL;
int expSecs = (60*60*24*aDays);
//Get command prompt handle
HANDLE hndl = 0;
hndl = GetStdHandle(STD_OUTPUT_HANDLE);
if(!Exists(aPrivOut))
{
//First create a key
if ( m_KeyType == EDSACipher)
{
m_KeyGen = new CDSAKeyGenerator;
}
else
{
m_KeyGen = new CRSAKeyGenerator;
}
if (!m_KeyGen)
{
return FAIL;
}
m_KeyGen->SetKeyLength(m_KeyLength);
m_KeyGen->SetPasswordRequirement(m_bPassword);
m_KeyGen->SetAskPassword(m_bAsk);
if(m_bPassword && m_password)
{
m_KeyGen->SetPassword(m_password);
}
if(m_privateKeyFile)
{
m_KeyGen->SetPrivateKeyFile(m_privateKeyFile);
}
m_KeyGen->SetVerbose(m_bVerbose);
retVal = m_KeyGen->Generate();
delete m_KeyGen;
}
else
{
_tprintf(_T("\nExisting private key will be used: "));
WriteConsole(hndl, m_privateKeyFile, _tcslen(m_privateKeyFile), &bytesWritten, 0);
retVal = SUCCESS;
//Since key generation class did not called, we should call these macros here
OPENSSL_add_all_algorithms_conf();
ERR_load_crypto_strings();
}
if(retVal != SUCCESS)
{
return retFunc;
}
//Generate certificate
try
{
//First read private key from key file
if(!(fp = _tfopen(m_privateKeyFile, _T("r"))))
{
PrintErrorInfo("Error reading key file!", EGeneric, constparams);
WriteConsole(hndl, m_privateKeyFile, wcslen(m_privateKeyFile), &bytesWritten, 0);
throw EGeneric;
}
DWORD len = 0;
if(m_password[0] != 0)
{
len = _tcslen(m_password);
pbPasswdUTF8 = MakeMBCSString(m_password, CP_UTF8, len);
pKey = PEM_read_PrivateKey(fp, NULL, NULL, pbPasswdUTF8);
delete pbPasswdUTF8;
}
else
{
pKey = PEM_read_PrivateKey(fp, NULL, NULL, NULL);
}
fclose(fp); fp = NULL;
if(!pKey)
{
PrintErrorInfo("Error reading private key in key file!", EOPENSSL, constparams);
throw EGeneric;
}
//Create a new certificate
if(!(pCert = X509_new()))
{
PrintErrorInfo("Error creating X509 object!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(X509_set_version(pCert, 2L) != 1)
{
PrintErrorInfo("Error setting certificate version!", EOPENSSL, constparams);
throw EOPENSSL;
}
long serial = 1;
ASN1_INTEGER_set(X509_get_serialNumber(pCert), serial++);
//Set issuer and subject name
//First create a name object
if(!(pSubj = X509_NAME_new()))
{
PrintErrorInfo("Error creating X509 name object!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Format DN string
DoFormatted(m_dname, &pEntPack);
if(pEntPack->num <= 0)
{
PrintErrorInfo("Error formatting Distinguished Name!", EGeneric, constparams);
throw EGeneric;
}
for (int i = 0; i < pEntPack->num; i++)
{
int nid = 0;
DWORD lent = 0;
X509_NAME_ENTRY *pEnt = NULL;
LPSTR pbMBSTRUTF8 = NULL;
if((pEntPack->entries[i].value == NULL) || (pEntPack->entries[i].key == NULL))
{
PrintErrorInfo("Error in Distinguished Name construction!", EGeneric, constparams);
throw EGeneric;
}
if((nid = OBJ_txt2nid(pEntPack->entries[i].key)) == NID_undef)
{
PrintErrorInfo("Error finding NID for a DN entry!", EOPENSSL, constparams);
throw EOPENSSL;
}
lent = _tcslen(pEntPack->entries[i].value);
pbMBSTRUTF8 = MakeMBCSString(pEntPack->entries[i].value, CP_UTF8, lent);
if(lent > 64) //OpenSSL does not accept a string longer than 64
{
if(!(pEnt = X509_NAME_ENTRY_create_by_NID(NULL, nid, MBSTRING_UTF8, (unsigned char *)"dummy", 5)))
{
PrintErrorInfo("Error creating name entry from NID!", EOPENSSL, constparams);
throw EOPENSSL;
}
pEnt->value->data = (unsigned char *)malloc(lent+1);
for(DWORD j=0; j<lent; j++ )
{
pEnt->value->data[j] = pbMBSTRUTF8[j];
}
pEnt->value->length = lent;
}
else if(!(pEnt = X509_NAME_ENTRY_create_by_NID(NULL, nid, MBSTRING_UTF8, (unsigned char *)pbMBSTRUTF8, lent)))
{
PrintErrorInfo("Error creating name entry from NID!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(X509_NAME_add_entry(pSubj, pEnt, -1, 0) != 1)
{
PrintErrorInfo("Error adding entry to X509 Name!", EOPENSSL, constparams);
throw EOPENSSL;
}
delete pbMBSTRUTF8;
}
SYMBIAN_FREE_MEM(pEntPack);
if(X509_set_subject_name(pCert, pSubj) != 1)
{
PrintErrorInfo("Error setting subject name of the certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(X509_set_issuer_name(pCert, pSubj) != 1)
{
PrintErrorInfo("Error setting issuer name of the certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(X509_set_pubkey(pCert, pKey) != 1)
{
PrintErrorInfo("Error setting public key of the certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(X509_gmtime_adj(X509_get_notBefore(pCert), 0)))
{
PrintErrorInfo("Error setting beginning time of the certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(X509_gmtime_adj(X509_get_notAfter(pCert), expSecs)))
{
PrintErrorInfo("Error setting ending time of the certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(EVP_PKEY_type(pKey->type) == EVP_PKEY_DSA)
{
pDigest = EVP_dss1();
}
else if(EVP_PKEY_type(pKey->type) == EVP_PKEY_RSA)
{
pDigest = EVP_sha1();
}
else
{
PrintErrorInfo("Error checking private key type!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(X509_sign(pCert, pKey, pDigest)))
{
PrintErrorInfo("Error signing certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
if(!(fp = _tfopen(m_certificateFile, _T("w"))))
{
PrintErrorInfo("Error writing to certificate file!",EGeneric,constparams);
throw EOPENSSL;
}
if(PEM_write_X509(fp, pCert) != 1)
{
PrintErrorInfo("Error while writing to certificate!", EOPENSSL, constparams);
throw EOPENSSL;
}
//Free variables
X509_free(pCert);
EVP_PKEY_free(pKey);
X509_NAME_free(pSubj);
fclose(fp);
_tprintf(_T("\nCreated certificate: "));
WriteConsole(hndl, m_certificateFile, wcslen(m_certificateFile), &bytesWritten, 0);
_tprintf(_T("\n"));
retFunc = SUCCESS;
} //try
catch (...)
{
if(pKey)
{
EVP_PKEY_free(pKey);
}
if(pCert)
{
X509_free(pCert);
}
if(pSubj)
{
X509_NAME_free(pSubj);
}
SYMBIAN_FREE_MEM(pEntPack);
}
return retFunc;
}