static LUA_FUNCTION(openssl_crl_new)
{
X509* x509 = lua_isnoneornil(L, 1) ? NULL : CHECK_OBJECT(1, X509, "openssl.x509");
time_t lastUpdate = luaL_optinteger(L, 3, (lua_Integer)time(&lastUpdate));
time_t nextUpdate = luaL_optinteger(L, 4, (lua_Integer)(lastUpdate + 7 * 24 * 3600));
long version = luaL_optint(L, 5, 1);
X509_CRL * crl = NULL;
ASN1_TIME *ltm, *ntm;
if (!lua_isnoneornil(L, 2))
luaL_checktype(L, 2, LUA_TTABLE);
crl = X509_CRL_new();
X509_CRL_set_version(crl, version);
if (x509)
X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509));
ltm = ASN1_TIME_new();
ntm = ASN1_TIME_new();
ASN1_TIME_set(ltm, lastUpdate);
ASN1_TIME_set(ntm, nextUpdate);
X509_CRL_set_lastUpdate(crl, ltm);
X509_CRL_set_nextUpdate(crl, ntm);
ASN1_TIME_free(ltm);
ASN1_TIME_free(ntm);
if (lua_istable(L, 2) && lua_objlen(L, 2) > 0)
{
int i;
int n = lua_objlen(L, 2);
for (i = 1; i <= n; i++)
{
lua_rawgeti(L, 2, i);
if (lua_istable(L, -1))
{
X509_REVOKED *revoked;
lua_getfield(L, -1, "reason");
lua_getfield(L, -2, "time");
lua_getfield(L, -3, "sn");
revoked = create_revoked(L, BN_get(L, -1), lua_tointeger(L, -2), reason_get(L, -3));
if (revoked)
{
X509_CRL_add0_revoked(crl, revoked);
}
lua_pop(L, 3);
}
lua_pop(L, 1);
}
}
PUSH_OBJECT(crl, "openssl.x509_crl");
return 1;
}
pki_crl::pki_crl(const QString name )
:pki_x509name(name)
{
issuer = NULL;
crl = X509_CRL_new();
class_name="pki_crl";
pki_openssl_error();
dataVersion=1;
pkiType=revokation;
}
VALUE
ossl_x509crl_new(X509_CRL *crl)
{
X509_CRL *tmp;
VALUE obj;
tmp = crl ? X509_CRL_dup(crl) : X509_CRL_new();
if(!tmp) ossl_raise(eX509CRLError, NULL);
WrapX509CRL(cX509CRL, obj, tmp);
return obj;
}
/*
* PRIVATE
*/
static VALUE
ossl_x509crl_alloc(VALUE klass)
{
X509_CRL *crl;
VALUE obj;
if (!(crl = X509_CRL_new())) {
ossl_raise(eX509CRLError, NULL);
}
WrapX509CRL(klass, obj, crl);
return obj;
}
DWORD
VMCACreateNewCRL(
PVMCA_X509_CA pCA,
X509_CRL **ppszCrlData
)
{
DWORD dwError = 0;
X509_CRL *pCrl = NULL;
ASN1_INTEGER *pSerial = NULL;
pCrl = X509_CRL_new();
if(pCrl == NULL) {
dwError = VMCA_OUT_MEMORY_ERR;
BAIL_ON_ERROR(dwError);
}
dwError = X509_CRL_set_issuer_name(pCrl,
X509_get_subject_name(pCA->pCertificate));
BAIL_ON_SSL_ERROR(dwError, VMCA_CERT_IO_FAILURE);
dwError = X509_CRL_set_version(pCrl, 1);
BAIL_ON_SSL_ERROR(dwError, VMCA_CRL_ERROR);
*ppszCrlData = pCrl;
cleanup :
if(pSerial != NULL){
ASN1_INTEGER_free(pSerial);
}
return dwError;
error :
if(pCrl != NULL) {
X509_CRL_free(pCrl);
}
goto cleanup;
}
void openssl_x509_crl()
{
RSA *r;
BIO *bp;
int len;
FILE *fp;
BIGNUM *bne;
X509_CRL *crl;
EVP_PKEY *pkey;
X509_NAME *issuer;
ASN1_INTEGER *serial;
X509_REVOKED *revoked;
ASN1_TIME *lastUpdate, *nextUpdate, *rvTime;
unsigned char *buf, *p, tmp[MAX1_LEN] = "crl cert";
printf("\nX509_CRL info:\n");
bne = BN_new();
BN_set_word(bne, RSA_3);
r = RSA_new();
RSA_generate_key_ex(r, MAX1_LEN, bne, NULL);
pkey = EVP_PKEY_new();
EVP_PKEY_assign_RSA(pkey, r);
crl = X509_CRL_new();
X509_CRL_set_version(crl, 3);
issuer = X509_NAME_new();
X509_NAME_add_entry_by_NID(issuer, NID_commonName,
V_ASN1_PRINTABLESTRING, tmp, 10, -1, 0);
X509_CRL_set_issuer_name(crl, issuer);
lastUpdate = ASN1_TIME_new();
ASN1_TIME_set(lastUpdate, time(NULL));
X509_CRL_set_lastUpdate(crl, lastUpdate);
nextUpdate = ASN1_TIME_new();
ASN1_TIME_set(nextUpdate, time(NULL) + 1280);
X509_CRL_set_nextUpdate(crl, nextUpdate);
revoked = X509_REVOKED_new();
serial = ASN1_INTEGER_new();
ASN1_INTEGER_set(serial, 1280);
X509_REVOKED_set_serialNumber(revoked, serial);
rvTime = ASN1_TIME_new();
ASN1_TIME_set(rvTime, time(NULL) + 2000);
X509_CRL_set_nextUpdate(crl, rvTime);
X509_REVOKED_set_revocationDate(revoked, rvTime);
X509_CRL_add0_revoked(crl, revoked);
X509_CRL_sort(crl);
X509_CRL_sign(crl, pkey, EVP_md5());
bp = BIO_new(BIO_s_file());
BIO_set_fp(bp, stdout, BIO_NOCLOSE);
X509_CRL_print(bp, crl);
len = i2d_X509_CRL(crl, NULL);
buf = (unsigned char *)malloc(len + 10);
p = buf;
len = i2d_X509_CRL(crl, &p);
fp = fopen("/tmp/crl.crl", "wb");
fwrite(buf, 1, len, fp);
fclose(fp);
free(buf);
BIO_free(bp);
X509_CRL_free(crl);
}
static LUA_FUNCTION(openssl_crl_new)
{
int i;
int n = lua_gettop(L);
X509_CRL * crl = X509_CRL_new();
int ret = X509_CRL_set_version(crl, 0);
X509* cacert = NULL;
EVP_PKEY* capkey = NULL;
const EVP_MD* md = NULL;
int step;
for (i = 1; ret == 1 && i <= n; i++)
{
if (i == 1)
{
luaL_argcheck(L, lua_istable(L, 1), 1, "must be table contains rovked entry table{reason,time,sn}");
if (lua_rawlen(L, i) > 0)
{
int j, m;
m = lua_rawlen(L, i);
for (j = 1; ret == 1 && j <= m; j++)
{
X509_REVOKED *revoked;
BIGNUM* sn;
lua_rawgeti(L, i, j);
luaL_checktable(L, -1);
lua_getfield(L, -1, "reason");
lua_getfield(L, -2, "time");
lua_getfield(L, -3, "sn");
sn = BN_get(L, -1);
revoked = create_revoked(sn, lua_tointeger(L, -2), reason_get(L, -3));
if (revoked)
{
ret = X509_CRL_add0_revoked(crl, revoked);
}
BN_free(sn);
lua_pop(L, 3);
lua_pop(L, 1);
};
}
};
if (i == 2)
{
cacert = CHECK_OBJECT(2, X509, "openssl.x509");
ret = X509_CRL_set_issuer_name(crl, X509_get_issuer_name(cacert));
}
if (i == 3)
{
capkey = CHECK_OBJECT(3, EVP_PKEY, "openssl.evp_pkey");
luaL_argcheck(L, openssl_pkey_is_private(capkey), 3, "must be private key");
luaL_argcheck(L, X509_check_private_key(cacert, capkey) == 1, 3, "evp_pkey not match with x509 in #2");
}
}
md = lua_isnoneornil(L, 4) ? EVP_get_digestbyname("sha1") : get_digest(L, 4);
step = lua_isnoneornil(L, 5) ? 7 * 24 * 3600 : luaL_checkint(L, 5);
if (ret == 1)
{
time_t lastUpdate;
time_t nextUpdate;
ASN1_TIME *ltm, *ntm;
time(&lastUpdate);
nextUpdate = lastUpdate + step;
ltm = ASN1_TIME_new();
ntm = ASN1_TIME_new();
ASN1_TIME_set(ltm, lastUpdate);
ASN1_TIME_set(ntm, nextUpdate);
ret = X509_CRL_set_lastUpdate(crl, ltm);
if (ret == 1)
ret = X509_CRL_set_nextUpdate(crl, ntm);
ASN1_TIME_free(ltm);
ASN1_TIME_free(ntm);
}
if (cacert && capkey && md)
{
ret = (X509_CRL_sign(crl, capkey, md) == EVP_PKEY_size(capkey));
}
if (ret == 1)
{
PUSH_OBJECT(crl, "openssl.x509_crl");
}
else
{
X509_CRL_free(crl);
return openssl_pushresult(L, ret);
};
return 1;
}
/**
*失効リストチェック関数
* @author University of Tsukuba
* @param *pInData 証明書データ
* @param lInLen 証明書データ長
* @param *data CRLファイルデータ
* @param len CRLファイルデータレングス
* @return long 0：未失効 1:失効中 -1：異常
* @since 2008.02
* @version 1.0
*/
long IDMan_CmCheckCRL(void *pInData, long lInLen, void * data,unsigned long int len )
{
long lRet=-1L;
/*FILE *fp;*/
X509 *x509=0x00;
X509_CRL *x509crl=0x00;
X509_NAME *x509crlissuer = 0x00;
int iRet=0;
int idx;
X509_REVOKED rtmp;
char *p,*p2;
char szErrBuff[1024];
BIO * BIOptr;
ERR_load_crypto_strings();
IDMan_StMemset(szErrBuff, 0x00, sizeof(szErrBuff));
/** 証明書データパラメータチェックを行う。 */
/** エラー発生した場合、 */
if (pInData == 0x00)
{
/** −処理を中断する。 */
return lRet;
}
/** 証明書長データパラメータチェックを行う。 */
/** エラー発生した場合、 */
if (lInLen == 0)
{
/** −処理を中断する。 */
return lRet;
}
/** 失効データパラメータチェックを行う。 */
/** 失効データが存在しない場合、 */
if (data==0x00 || len == 0)
{
/** −正常終了する。 */
lRet =0;
return lRet;
}
/** X509構造体の初期化を行う。 */
/** エラー発生した場合、 */
if((x509 = X509_new())== 0x00)
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
return lRet;
}
/** DERファイルから、X509構造体にデータを読み込む。 */
/** BIO構造の作成を行う。 */
BIOptr = BIO_new(BIO_s_mem());
/** BIO構造のリセットを行う。 */
iRet = BIO_reset(BIOptr);
/** エラー発生した場合、 */
if(iRet != 1)
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
BIO_free(BIOptr);
return lRet;
}
/** BIO構造へ公開鍵証明書データの設定を行う。 */
iRet = BIO_write(BIOptr,pInData,lInLen);
/** エラー発生した場合、 */
if( iRet != lInLen )
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
BIO_free(BIOptr);
return lRet;
}
/** X509構造体の作成を行う。 */
x509 =(X509 *) d2i_X509_bio(BIOptr,0x00);
/** エラー発生した場合、 */
if((x509 == 0x00))
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
if(x509 !=0x00) X509_free(x509);
BIO_free(BIOptr);
return lRet;
}
/** BIO構造の解放を行う。 */
BIO_free(BIOptr);
/** issuerDNの取得を行う。 */
X509_NAME *x509issuer = X509_get_issuer_name(x509);
p = X509_NAME_oneline(x509issuer, 0, 0);
/** CRL情報の取得を行う。 */
x509crl = X509_CRL_new();
/** BIO構造の作成を行う。 */
BIOptr = BIO_new(BIO_s_mem());
/** BIO構造のリセットを行う。 */
iRet = BIO_reset(BIOptr);
/** エラー発生した場合、 */
if(iRet != 1)
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
BIO_free(BIOptr);
return lRet;
}
/** BIO構造へ失効リストデータの設定を行う。 */
iRet = BIO_write(BIOptr,data,len);
/** エラー発生した場合、 */
if( iRet != (int)len )
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
BIO_free(BIOptr);
return lRet;
}
/** x509crl構造へ失効リストデータの設定を行う。 */
x509crl = (X509_CRL *) d2i_X509_CRL_bio(BIOptr,0x00);
/** エラー発生した場合、 */
if(x509crl==0x00)
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
if(x509 !=0x00) X509_free(x509);
if(x509crl !=0x00) X509_CRL_free(x509crl);
BIO_free(BIOptr);
return lRet;
}
/** BIO構造の解放を行う。 */
BIO_free(BIOptr);
/** シリアル番号の取得を行う。 */
rtmp.serialNumber = X509_get_serialNumber(x509);
/** CRLのissuerDNの取得を行う。 */
/** エラー発生した場合、 */
x509crlissuer = X509_CRL_get_issuer(x509crl);
if ( x509crlissuer == 0x00 )
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
if(x509 !=0x00) X509_free(x509);
if(x509crl !=0x00) X509_CRL_free(x509crl);
return lRet;
}
/** 証明書とCRLのissuerDNの比較を行う。 */
p2 = X509_NAME_oneline(x509crlissuer, 0, 0);
/** エラー発生した場合、 */
if( strcmp(p, p2) != 0)
{
/** −処理を中断する。 */
ERR_error_string(ERR_get_error(), szErrBuff);
if(x509 !=0x00) X509_free(x509);
if(x509crl !=0x00) X509_CRL_free(x509crl);
return lRet;
}
/** CRLのシリアル番号をソートする。 */
if (!sk_is_sorted(x509crl->crl->revoked))
{
sk_sort(x509crl->crl->revoked);
}
/** CRLのシリアル番号を検索する。 */
idx = sk_X509_REVOKED_find(x509crl->crl->revoked, &rtmp);
/** 該当シリアル番号が存在する場合、 */
if (idx >= 0)
{
/** −戻り値に１を設定する。 */
lRet =1;
}
/** 該当シリアル番号が存在しない場合、 */
else
{
/** −戻り値に０を設定する。 */
lRet =0;
}
/** X509の開放を行う。 */
if(x509 !=0x00) X509_free(x509);
/** X509CRLの開放を行う。 */
if(x509crl !=0x00) X509_CRL_free(x509crl);
return lRet;
}
int createEmptyCRL(char* pemSigningKey, char* pemCaCert, int crldays, int crlhours, char* result) {
int err = 0;
//convert to BIOs and then keys and x509 structures
BIO* bioCert = BIO_new_mem_buf(pemCaCert, -1);
if (!bioCert) {
BIO_free(bioCert);
return ERR_peek_error();
}
BIO* bioSigningKey = BIO_new_mem_buf(pemSigningKey, -1);
if (!bioSigningKey) {
BIO_free(bioCert);
BIO_free(bioSigningKey);
return ERR_peek_error();
}
X509* caCert = PEM_read_bio_X509(bioCert, NULL, NULL, NULL);
if (!caCert) {
BIO_free(bioCert);
BIO_free(bioSigningKey);
return ERR_peek_error();
}
EVP_PKEY* caKey = PEM_read_bio_PrivateKey(bioSigningKey, NULL, NULL, NULL);
if (!caKey) {
BIO_free(bioCert);
BIO_free(bioSigningKey);
return ERR_peek_error();
}
X509_CRL* crl = X509_CRL_new();
X509_CRL_set_issuer_name(crl, X509_get_subject_name(caCert));
//set update times (probably not essential, but why not.
ASN1_TIME* tmptm = ASN1_TIME_new();
X509_gmtime_adj(tmptm, long(0));
X509_CRL_set_lastUpdate(crl, tmptm);
X509_gmtime_adj(tmptm,(crldays*24+crlhours)*60*60);
X509_CRL_set_nextUpdate(crl, tmptm);
ASN1_TIME_free(tmptm);
X509_CRL_sort(crl);
//extensions would go here.
if (!(err = X509_CRL_sign(crl,caKey,EVP_sha1())))
{
BIO_free(bioCert);
BIO_free(bioSigningKey);
return err;
}
BIO *mem = BIO_new(BIO_s_mem());
PEM_write_bio_X509_CRL(mem,crl);
BUF_MEM *bptr;
BIO_get_mem_ptr(mem, &bptr);
BIO_read(mem, result, bptr->length);
BIO_free(bioCert);
BIO_free(bioSigningKey);
BIO_free(mem);
return 0;
}
/*
* Revoke one certificate at a time
* No check performed to see if certificate already revoked.
*/
void revoke_cert(char * ca_name, char * name)
{
char filename[FIELD_SZ+5];
FILE * f ;
X509_CRL * crl ;
X509 * cert ;
ASN1_INTEGER * r_serial ;
ASN1_INTEGER * crlnum ;
X509_REVOKED * rev ;
ASN1_TIME * tm ;
identity ca ;
BIO * out ;
BIGNUM * b_crlnum ;
/* Find requested certificate by name */
sprintf(filename, "%s.crt", name);
if ((f=fopen(filename, "r"))==NULL) {
fprintf(stderr, "Cannot find: %s\n", filename);
return ;
}
cert = PEM_read_X509(f, NULL, NULL, NULL);
fclose(f);
/* Get certificate serial number */
r_serial = X509_get_serialNumber(cert);
/* Find out if if was already revoked */
/* Make a revoked object with that serial */
rev = X509_REVOKED_new();
X509_REVOKED_set_serialNumber(rev, r_serial);
X509_free(cert);
/* Set reason to unspecified */
rev->reason = ASN1_ENUMERATED_get(CRL_REASON_UNSPECIFIED);
/* Load or create new CRL */
if ((crl = load_crl(ca_name))==NULL) {
crl = X509_CRL_new();
X509_CRL_set_version(crl, 1);
/* Set CRL number */
crlnum = ASN1_INTEGER_new();
ASN1_INTEGER_set(crlnum, 1);
X509_CRL_add1_ext_i2d(crl, NID_crl_number, crlnum, 0, 0);
ASN1_INTEGER_free(crlnum);
} else {
crlnum = X509_CRL_get_ext_d2i(crl, NID_crl_number, 0, 0);
b_crlnum = ASN1_INTEGER_to_BN(crlnum, NULL);
BN_add_word(b_crlnum, 1);
BN_to_ASN1_INTEGER(b_crlnum, crlnum);
BN_free(b_crlnum);
X509_CRL_add1_ext_i2d(crl, NID_crl_number, crlnum, 0, X509V3_ADD_REPLACE_EXISTING);
ASN1_INTEGER_free(crlnum);
}
/* What time is it? */
tm = ASN1_TIME_new();
X509_gmtime_adj(tm, 0);
X509_REVOKED_set_revocationDate(rev, tm);
X509_CRL_set_lastUpdate(crl, tm);
/* Set CRL next update to a year from now */
X509_gmtime_adj(tm, 365*24*60*60);
X509_CRL_set_nextUpdate(crl, tm);
ASN1_TIME_free(tm);
/* Add revoked to CRL */
X509_CRL_add0_revoked(crl, rev);
X509_CRL_sort(crl);
/* Load root key to sign CRL */
if (load_ca(ca_name, &ca)!=0) {
fprintf(stderr, "Cannot find CA key/crt\n");
return ;
}
X509_CRL_set_issuer_name(crl, X509_get_subject_name(ca.cert));
X509_free(ca.cert);
/* Sign CRL */
X509_CRL_sign(crl, ca.key, EVP_sha256());
EVP_PKEY_free(ca.key);
/* Dump CRL */
sprintf(filename, "%s.crl", ca_name);
if ((f = fopen(filename, "wb"))==NULL) {
fprintf(stderr, "Cannot write %s: aborting\n", filename);
X509_CRL_free(crl);
return ;
}
out = BIO_new(BIO_s_file());
BIO_set_fp(out, f, BIO_NOCLOSE);
PEM_write_bio_X509_CRL(out, crl);
BIO_free_all(out);
fclose(f);
X509_CRL_free(crl);
return ;
}