OpenSSL 常用函数——证书操作

淩亂°似流年 2022-04-10 05:45 939阅读 0赞

OpenSSL 常用函数——证书操作

现有的证书大多采用X. 509规范，主要由以下信息组成:版本号、证书序列号、有效期、所有者信息、发行者信息、其他扩展信息、所有者公钥、CA的上述信息签名。一种OpenSSL实现了对X. 509的所有数字证书操作。它包括发放数字证书、解析和验证证书等一种证书操作涉及的主要功能有证书验证(证书链、有效期、CRL)、证书解析(证书版本、序列号、发行人信息、主体信息、公钥、有效期等)。

主要功能  
1. DER编码转换为内部结构函数。  
X509 \* d2i\_X509 (X509 \*\* cert, unsigned char \*\* d, int len);  
函数:将der编码的证书数据转换为OpenSSL内部结构。  
参数:cert(出):X509结构。  
D:\[在\]DER编码的证书数据指针地址。  
Len \[IN\]证书数据长度;  
返回值:编码的X509结构化数据2，证书版本函数X509\_get\_version\_  
2.\#define x509\_get\_version (x)  ASN1\_INTEGER\_get((x)->cert\_info->version)

参数:x:\[在\]X509\*结构数据结构。  
返回值:证书版本，数据类型“LONG”获取证书序列号函数。  
3.ASN1\_INTEGER\* X509\_get\_serialNumber (X509\* x);  
返回值:证书序列号，数据类型“ASN1\_INTEGER”。

4. 证书颁发机构的信息功能  
X509\_NAME \* X509\_get\_issuer\_name(X509 \*);  
注意\*:X509\_NAME结构包括几个X509\_NAME\_ENTRY结构。  
X509\_NAME\_ENTRY存储发行者的信息，其中包括对象和值。  
对象类型包括国家、通用名称、单位、组织、地区、邮件等  
5、X509\_NAME \* X509\_get\_subject\_name(X509 \*);  
6、证书有效期的起始日期函数\_  
\#define X509\_get\_notBefore(x)   ((x)->cert\_info->validity->notBefore)

返回值:证书开始有效期、数据类型“ASN1\_TIME”

7、证书有效期终止日期函数  
\# define X509\_get\_notAfter(x) ((x)->cert\_info->validity->after)

8、获取证书公钥函数\_  
EVP\_PKEY\* X509\_get\_pubkey (X509\* x);  
9、创建和释放证书存储区域  
X509\_STORE \* X509\_STORE\_new(void);

void\_X509\_STORE\_free(X509\_STORE \* v);  
函数:创建和发布一个X509\_STORE结构，主要用于认证。  
10. 将证书添加到证书存储区域  
Int\_X509\_STORE\_add\_cert(X509\_STORE \* ctx X509 \* x);

函数:将信任的根证书添加到证书存储区。  
返回值:1成功，否则为0  
11. 将证书撤销列表添加到证书存储区域  
Int\_X509\_STORE\_add\_crl(X509\_STORE \* ctx X509\_CRL \* x);  
功能:将CRL添加到证书存储区。  
参数:x:\[在\]证书撤销列表中。  
\[在\]证书存储区。  
返回值:1成功，否则为0。  
12. 创建证书存储上下文环境函数  
X509\_STORE\_CTX \* X509\_STORE\_CTX\_new(void);  
\_return值:操作成功返回证书存储区的上下文环境指针，否则返回NULL。  
释放证书存储上下文环境  
void\_X509\_STORE\_CTX\_free (X509\_STORE\_CTX \* ctx);  
14. 初始化证书存储区域上下文环境函数\_  
int\_X509\_STORE\_CTX\_init (X509\_STORE\_CTX \* ctx, X509\_STORE \*store,X509 \* X509;, STACK\_OF (X509) \*chain);;\*  
功能:初始化证书存储的上下文环境，设置根证书，待验证证书，CA证书链。  
15. 检定证书功能  
Int\_X509\_verify\_cert (X509\_STORE\_CTX \* ctx);

### **代码demo：** ###

在之前的文章“通过OpenSSL解码X509证书文件”里，讲述了如何使用OpenSSL将证书文件解码，得到证书上下文结构体X509的方法。下面我们接着讲述如何通过证书上下文结构体X509，获得想要的证书项。本文先讲述如何获取证书的基本项，后面还有文章介绍如何获取证书的扩展项。

下面的代码，都是假定已经通过解码证书文件、得到了证书上下文结构体X509。至于如何使用OpenSSL解码证书文件、得到证书上下文结构体X509，请阅读之前的文章。

首先，我们看看关于**证书结构体X509**定义：

struct x509\_st  
\{  
    X509\_CINF \*cert\_info;  
    X509\_ALGOR \*sig\_alg;  
    ASN1\_BIT\_STRING \*signature;  
    int valid;  
    int references;  
    char \*name;  
    CRYPTO\_EX\_DATA ex\_data;  
    /\* These contain copies of various extension values \*/  
    long ex\_pathlen;  
    long ex\_pcpathlen;  
    unsigned long ex\_flags;  
    unsigned long ex\_kusage;  
    unsigned long ex\_xkusage;  
    unsigned long ex\_nscert;  
    ASN1\_OCTET\_STRING \*skid;  
    AUTHORITY\_KEYID \*akid;  
    X509\_POLICY\_CACHE \*policy\_cache;  
    STACK\_OF(DIST\_POINT) \*crldp;  
    STACK\_OF(GENERAL\_NAME) \*altname;  
    NAME\_CONSTRAINTS \*nc;  
\#ifndef OPENSSL\_NO\_RFC3779  
    STACK\_OF(IPAddressFamily) \*rfc3779\_addr;  
    struct ASIdentifiers\_st \*rfc3779\_asid;  
\#endif  
\#ifndef OPENSSL\_NO\_SHA  
    unsigned char sha1\_hash\[SHA\_DIGEST\_LENGTH\];  
\#endif  
    X509\_CERT\_AUX \*aux;  
\} /\* X509 \*/;  
   
typedef struct x509\_cinf\_st  
\{  
    ASN1\_INTEGER \*version;        /\* \[ 0 \] default of v1 \*/  
    ASN1\_INTEGER \*serialNumber;  
    X509\_ALGOR \*signature;  
    X509\_NAME \*issuer;  
    X509\_VAL \*validity;  
    X509\_NAME \*subject;  
    X509\_PUBKEY \*key;  
    ASN1\_BIT\_STRING \*issuerUID;        /\* \[ 1 \] optional in v2 \*/  
    ASN1\_BIT\_STRING \*subjectUID;        /\* \[ 2 \] optional in v2 \*/  
    STACK\_OF(X509\_EXTENSION) \*extensions;    /\* \[ 3 \] optional in v3 \*/  
    ASN1\_ENCODING enc;  
\} X509\_CINF;  
      我们想要获取的证书基本项，有些就直接存在于这两个结构体中。  
**一、版本号**  
      通过解码证书文件，得到证书结构体m\_pX509之后，可以通过函数X509\_get\_version()获取证书的版本。具体代码如下：

int ver = X509\_get\_version(m\_pX509);  
switch(ver)        
\{  
    case 0:        //V1  
        //...  
    break;  
    case 1:        //V2  
        //...  
    break;  
    case 2:        //V3  
        //...  
    break;  
    default:  
        //Error!  
    break;  
\}  
需要注意的是，0代表V1；1代表V2；2代表V3。目前绝大多数证书都是V3版本。  
**二、序列号**

同样，有了m\_pX509之后，调用函数X509\_get\_serialNumber()即可获得证书的序列号。只是该函数返回的是ASN1\_INTEGER类型，需要转换后才能是我们平常看到的十六进制表示的序列号。具体实现函数如下：

ULONG COpenSSLCertificate::get\_SN(LPSTR lptcSN, ULONG \*pulLen)  
\{  
    ULONG ulRet = CERT\_ERR\_OK;  
    ASN1\_INTEGER \*asn1\_i = NULL;  
    BIGNUM \*bignum = NULL;  
    char \*serial = NULL;  
   
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!pulLen)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
    asn1\_i = X509\_get\_serialNumber(m\_pX509);  
    bignum = ASN1\_INTEGER\_to\_BN(asn1\_i, NULL);  
    if (bignum == NULL)   
    \{  
        ulRet = CERT\_ERR\_FAILED;  
        goto FREE\_MEMORY;  
    \}  
    serial = BN\_bn2hex(bignum);  
    if (serial == NULL)   
    \{  
        ulRet = CERT\_ERR\_FAILED;  
        goto FREE\_MEMORY;  
    \}  
    BN\_free(bignum);  
    if (!lptcSN)  
    \{  
        \*pulLen = strlen(serial) + 1;  
        ulRet = CERT\_ERR\_OK;  
        goto FREE\_MEMORY;  
    \}  
    if (\*pulLen < strlen(serial) + 1)  
    \{  
        ulRet = CERT\_ERR\_BUFFER\_TOO\_SMALL;  
        goto FREE\_MEMORY;  
    \}  
    strcpy\_s(lptcSN, \*pulLen, serial);  
    \*pulLen = strlen(serial);  
FREE\_MEMORY:  
    OPENSSL\_free(serial);      
    return ulRet;  
\}  
**三、公钥算法（证书算法）**

要想获取证书公钥算法，需要先调用函数X509\_get\_pubkey()得到公钥属性结构体，然后通过type字段来判断公钥的算法类型。具体实现函数如下：

ULONG COpenSSLCertificate::get\_KeyType(ULONG\* pulType)  
\{  
    EVP\_PKEY \*pk = NULL;  
    stack\_st\_X509\* chain = NULL;  
    X509\_EXTENSION \*pex = NULL;  
      
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!pulType)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    pk = X509\_get\_pubkey(m\_pX509);  
    if (!pk)  
    \{  
        return CERT\_ERR\_FAILED;  
    \}  
   
    if (EVP\_PKEY\_RSA == pk->type)  
    \{  
        \*pulType = CERT\_KEY\_ALG\_RSA;  
    \}  
    else if (EVP\_PKEY\_EC == pk->type)  
    \{  
        \*pulType = CERT\_KEY\_ALG\_ECC;  
    \}  
    else if (EVP\_PKEY\_DSA == pk->type)  
    \{  
        \*pulType = CERT\_KEY\_ALG\_DSA;  
    \}  
    else if (EVP\_PKEY\_DH == pk->type)  
    \{  
        \*pulType = CERT\_KEY\_ALG\_DH;  
    \}  
    else  
    \{  
        return CERT\_KEY\_ALG\_UNKNOWN;  
    \}          
      
    return CERT\_ERR\_OK;  
\}  
目前常见的证书算法为RSA和ECC，ECC在国内又成为SM2。SM2是国家密码管理局基于椭圆算法(ECC)制定的国内非对称算法标准。  
**四、证书用途**

证书从用途来分，分为“签名证书”和“加密证书”两大类。“签名证书”的公钥用来验证签名，而“加密证书”的公钥则用来加密数据。我们可以通过调用X509中的ex\_kusage字段来判断证书的用途，具体函数实现如下：

ULONG COpenSSLCertificate::get\_KeyUsage(ULONG\* lpUsage)  
\{  
    ULONG lKeyUsage = 0;  
   
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!lpUsage)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    \*lpUsage = CERT\_USAGE\_UNKNOWN;  
      
    //X509\_check\_ca() MUST be called!  
    X509\_check\_ca(m\_pX509);  
    lKeyUsage = m\_pX509->ex\_kusage;  
    if ((lKeyUsage & KU\_DATA\_ENCIPHERMENT) == KU\_DATA\_ENCIPHERMENT)  
    \{  
        \*lpUsage = CERT\_USAGE\_EXCH;<span style="white-space:pre">    </span>//加密证书  
    \}  
    else if ((lKeyUsage & KU\_DIGITAL\_SIGNATURE) == KU\_DIGITAL\_SIGNATURE)  
    \{  
        \*lpUsage = CERT\_USAGE\_SIGN;<span style="white-space:pre">    </span>//签名证书  
    \}  
   
    return CERT\_ERR\_OK;  
\}  
**五、签名算法**

证书的签名算法，是指证书用来签名时使用的算法(包含HASH算法)。签名算法用结构体X509中sig\_alg字段来表示，可以通过sig\_alg的子字段algorithm返回签名算法对象，从而得到签名算法的Oid。首先，签名算法的Oid常见得定义如下：

/\*    Certificate siganture alg \*/  
\#define CERT\_SIGNATURE\_ALG\_RSA\_RSA            "1.2.840.113549.1.1.1"  
\#define CERT\_SIGNATURE\_ALG\_MD2RSA            "1.2.840.113549.1.1.2"  
\#define CERT\_SIGNATURE\_ALG\_MD4RSA            "1.2.840.113549.1.1.3"  
\#define CERT\_SIGNATURE\_ALG\_MD5RSA            "1.2.840.113549.1.1.4"  
\#define CERT\_SIGNATURE\_ALG\_SHA1RSA            "1.2.840.113549.1.1.5"  
\#define CERT\_SIGNATURE\_ALG\_SM3SM2            "1.2.156.10197.1.501"  
      获取签名算法Oid的具体实现函数如下：

ULONG COpenSSLCertificate::get\_SignatureAlgOid(LPSTR lpscOid, ULONG \*pulLen)  
\{  
    char oid\[128\] = \{0\};  
    ASN1\_OBJECT\* salg  = NULL;  
   
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!pulLen)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    salg = m\_pX509->sig\_alg->algorithm;  
    OBJ\_obj2txt(oid, 128, salg, 1);  
    if (!lpscOid)  
    \{  
        \*pulLen = strlen(oid) + 1;  
        return CERT\_ERR\_OK;  
    \}  
    if (\*pulLen < strlen(oid) + 1)  
    \{  
        return CERT\_ERR\_BUFFER\_TOO\_SMALL;  
    \}  
   
    strcpy\_s(lpscOid, \*pulLen, oid);  
    \*pulLen = strlen(oid) + 1;  
    return CERT\_ERR\_OK;  
\}  
由于Windows对SM2/SM3算法还没有定义，所以对于ECC(SM2)证书，Windows直接显示签名算法的Oid：“1.2.156.10197.1.501”，如下图所示：

**六、颁发者**

关于颁发者，我们可以通过调用函数X509\_get\_issuer\_name()获取属性。不过该函数返回的是X509\_NAME类型，需要调用函数X509\_NAME\_get\_text\_by\_NID()将其转化为ASCII字符形式。具体通过下面函数实现：

ULONG COpenSSLCertificate::get\_Issuer(LPSTR lpValue, ULONG \*pulLen)  
\{  
    int nNameLen = 512;  
    CHAR csCommonName\[512\] = \{0\};  
    X509\_NAME \*pCommonName = NULL;  
   
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!pulLen)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    pCommonName = X509\_get\_issuer\_name(m\_pX509);  
    if (!pCommonName)  
    \{  
        return CERT\_ERR\_FAILED;  
    \}  
    nNameLen = X509\_NAME\_get\_text\_by\_NID(pCommonName, NID\_commonName, csCommonName, nNameLen);  
    if (-1 == nNameLen)  
    \{  
        return CERT\_ERR\_FAILED;  
    \};      
    if (!lpValue)  
    \{  
        \*pulLen = nNameLen + 1;  
        return CERT\_ERR\_OK;  
    \}  
    if (\*pulLen < (ULONG)nNameLen + 1)  
    \{  
        return CERT\_ERR\_BUFFER\_TOO\_SMALL;  
    \}  
   
    strcpy\_s(lpValue, \*pulLen, csCommonName);  
    \*pulLen = nNameLen;  
    return CERT\_ERR\_OK;  
\}  
**七、使用者**

关于证书使用者，我们可以通过调用函数X509\_get\_subject\_name)获取属性。同样，该函数返回的是X509\_NAME类型，需要调用函数X509\_NAME\_get\_text\_by\_NID()将其转化为ASCII字符形式。具体通过下面函数实现：

ULONG COpenSSLCertificate::get\_SubjectName(LPSTR lpValue, ULONG \*pulLen)  
\{  
    int iLen = 0;  
    int iSubNameLen = 0;  
    CHAR csSubName\[1024\] = \{0\};  
    CHAR csBuf\[256\] = \{0\};  
    X509\_NAME \*pSubName = NULL;  
      
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVILIDCALL;  
    \}  
    if (!pulLen)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    pSubName = X509\_get\_subject\_name(m\_pX509);  
    if (!pSubName)  
    \{  
        return CERT\_ERR\_FAILED;  
    \}  
      
    ZeroMemory(csBuf, 256);  
    iLen = X509\_NAME\_get\_text\_by\_NID(pSubName, NID\_countryName, csBuf, 256);  
    if (iLen > 0)  
    \{  
        strcat\_s(csSubName, 1024, "C=");  
        strcat\_s(csSubName, 1024, csBuf);  
        strcat\_s(csSubName, 1024, ", ");  
    \}  
      
    ZeroMemory(csBuf, 256);  
    iLen = X509\_NAME\_get\_text\_by\_NID(pSubName, NID\_organizationName, csBuf, 256);  
    if (iLen > 0)  
    \{  
        strcat\_s(csSubName, 1024, "O=");  
        strcat\_s(csSubName, 1024, csBuf);  
        strcat\_s(csSubName, 1024, ", ");  
    \}  
      
    ZeroMemory(csBuf, 256);  
    iLen = X509\_NAME\_get\_text\_by\_NID(pSubName, NID\_organizationalUnitName, csBuf, 256);  
    if (iLen > 0)  
    \{  
        strcat\_s(csSubName, 1024, "OU=");  
        strcat\_s(csSubName, 1024, csBuf);  
        strcat\_s(csSubName, 1024, ", ");  
    \}  
      
    ZeroMemory(csBuf, 256);  
    iLen = X509\_NAME\_get\_text\_by\_NID(pSubName, NID\_commonName, csBuf, 256);  
    if (iLen > 0)  
    \{  
        strcat\_s(csSubName, 1024, "CN=");  
        strcat\_s(csSubName, 1024, csBuf);  
    \}  
      
    if (!lpValue)  
    \{  
        \*pulLen = strlen(csSubName) + 1;  
        return CERT\_ERR\_OK;  
    \}  
    if (\*pulLen < strlen(csSubName) + 1)  
    \{  
        return CERT\_ERR\_BUFFER\_TOO\_SMALL;  
    \}  
      
    strcpy\_s(lpValue, \*pulLen, csSubName);  
    \*pulLen = strlen(csSubName);  
    return CERT\_ERR\_OK;  
\}  
**八、有效期限**

要获取证书的有效期属性，需要通过调用函数X509\_get\_notBefore()和X509\_get\_notAfter()来实现。而且这两个函数返回的时间是time\_t类型，需要转化为SYSTEMTIME类型。具体实现函数如下：

ULONG COpenSSLCertificate::get\_ValidDate(SYSTEMTIME \*ptmStart, SYSTEMTIME \*ptmEnd)  
\{  
    int err = 0;  
    ASN1\_TIME \*start = NULL;  
    ASN1\_TIME \*end = NULL;  
    time\_t ttStart = \{0\};  
    time\_t ttEnd = \{0\};  
    LONGLONG nLLStart = 0;  
    LONGLONG nLLEnd = 0;  
    FILETIME ftStart = \{0\};  
    FILETIME ftEnd = \{0\};  
   
    if (!m\_pX509)  
    \{  
        return CERT\_ERR\_INVALIDPARAM;  
    \}  
   
    start = X509\_get\_notBefore(m\_pX509);  
    end = X509\_get\_notAfter(m\_pX509);  
      
    ttStart = ASN1\_TIME\_get(start, &err);  
    ttEnd = ASN1\_TIME\_get(end, &err);      
    nLLStart = Int32x32To64(ttStart, 10000000) + 116444736000000000;  
    nLLEnd = Int32x32To64(ttEnd, 10000000) + 116444736000000000;  
   
    ftStart.dwLowDateTime = (DWORD)nLLStart;  
    ftStart.dwHighDateTime = (DWORD)(nLLStart >> 32);  
    ftEnd.dwLowDateTime = (DWORD)nLLEnd;  
    ftEnd.dwHighDateTime = (DWORD)(nLLEnd >> 32);  
   
    FileTimeToSystemTime(&ftStart, ptmStart);  
    FileTimeToSystemTime(&ftEnd, ptmEnd);  
   
    return 0;  
\}  
      至此，X509证书的基本项通过OpenSLL均已解析完毕！如需获取证书的扩展项或者公钥等数据，请关注后续博文。