通过openssl解析pfx私钥证书，qtc++实现

最新推荐文章于 2024-08-07 01:56:03 发布
最新推荐文章于 2024-08-07 01:56:03 发布
阅读量450 收藏 6
点赞数 4
文章标签： qt c++ 开发语言 ssl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31013099/article/details/139167364
版权

文章目录

前言

因为我对证书理解不深，仅仅为了完成需求，所以很可能会有错误，希望大家批评指正

本次代码所使用的openssl版本为1.1.1u。

网上的资料其实并不少，但似乎都是老版本的了，我所使用的openssl版本为1.1.1，结构体已经不暴露出来了，所以实现了部分方法，可以分享一下。

一、openssl

我是使用qt5.12.12编译的，理论上qt5就行。

二、使用步骤

1.引入库

代码如下，需要在pro文件中链接库（跟demo中不一样，只是说需要链接这两个库）：

LIBS += -lopenssl -lcrypto

2.使用

代码如下（示例）：

Adapts::UKey::SW_DigitalCertificate tmpParser;
tmpParser.VerifyCertificate(pfxFile, "password"); //这个密码需要改成自己证书的密码

注意哦，GetIssuerName获取的是乱码，又涉及到了字符串编码的问题，本人才疏学浅尚未解决，如果路过的大佬知道为啥麻烦告诉小弟一下，感激不尽


在这里插入图片描述

3.证书解析

主要依靠PKCS12_parse获取X509结构体，并对其进行解析，demo代码放在链接中：
demo代码git地址

bool SW_DigitalCertificate::VerifyCertificate(const QString &certificateName, const QString &password)
{
    QFile certificateFile(certificateName);
    if(!certificateFile.exists()) {
        qDebug() << "certificate file is not exists";
        return false;
    }
    
    certificateFile.open(QIODevice::ReadOnly);
    QByteArray fileArr = certificateFile.readAll();
    char * context = fileArr.data();
    certificateFile.close();

    BIO * bio = BIO_new(BIO_s_mem());
    int rv = BIO_write(bio, context, fileArr.size());

    if(!bio || 0 == rv) {
        qDebug() << "BIO_write||BIO_new error";
        return false;
    }

    PKCS12 *p12 = NULL;
	p12 = d2i_PKCS12_bio(bio, &p12);

	EVP_PKEY* pkey = NULL;
	X509* x509 = NULL;
	STACK_OF(X509)* ca = NULL;

    bool returnRes = false;
    if (!PKCS12_parse(p12, password.toUtf8(), &pkey, &x509, &ca)) {
        qDebug() << "PKCS12_parse error";
        returnRes = false;
    }else{
        d_ptr->m_certificateNamePwdMap.insert(certificateName, password);
        //打印数据
        ShowCertificateInfo(x509);

        returnRes = true;
    }

    X509_free(x509);		
    sk_X509_pop_free(ca, X509_free);
    ca = NULL;	
    PKCS12_free(p12);
    p12 = NULL;

    return returnRes;
}


#include "digitalcertificateprivate.h"

#include <openssl/x509v3.h>

#include <QDateTime>
#include <QDebug>

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetVersion(X509 *x509)
{
    if(!x509)
        return QString();

    int ver = X509_get_version(x509);
    switch(ver)
    {
    case 0:		//V1
        return QString("V1");
    case 1:		//V2
        return QString("V2");
    case 2:		//V3
        return QString("V3");
    default:    //Error!
        return QString();;
    }

    return QString();
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetSerialNumber(X509 *x509)
{
    if(!x509)
        return QString();

    ASN1_INTEGER *asn1_i = nullptr;
    BIGNUM *bignum = nullptr;
    char *serial = nullptr;

    asn1_i = X509_get_serialNumber(x509);
    bignum = ASN1_INTEGER_to_BN(asn1_i, NULL);

    if(!bignum)
        return QString();

    serial = BN_bn2hex(bignum);
    if (!serial)
        return QString();

    return QString(serial);
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetKeyType(X509 *x509)
{
    if(!x509)
        return QString();

    EVP_PKEY *pubKey = X509_get_pubkey(x509);
    int id = EVP_PKEY_base_id(pubKey);

    switch (id) {
    case EVP_PKEY_RSA:
        return QString("RSA");
    case EVP_PKEY_DSA:
        return QString("DSA");
    case EVP_PKEY_DH:
        return QString("DH");
    case EVP_PKEY_EC:
        return QString("SM2");
    default:
        break;
    }

    return QString();
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetSignType(X509 *x509)
{
    if(!x509)
        return QString();

    QString sigAlg;
    const X509_ALGOR *alg = X509_get0_tbs_sigalg(x509);
    if(alg->parameter) {
        int sig_nid = OBJ_obj2nid(alg->algorithm);
        if(sig_nid != NID_undef) {
            sigAlg = QString(OBJ_nid2ln(sig_nid));
        }
    }
    else {//SM2
        char test[32] = {0};
        int len = OBJ_obj2txt(test, 32, alg->algorithm, 0);
        std::string oid(test, len);
        if(oid == "1.2.156.10197.1.501") {
            sigAlg = "SM3";
        }
        else if(oid == "1.2.840.113549.1.1.5") {
            sigAlg = "sha1";
        }
        else if(oid == "1.2.840.113549.1.1.11") {
            sigAlg = "sha256";
        }
    }

    return sigAlg;
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetNotBefore(X509 *x509)
{
    if(!x509)
        return QString();

    ASN1_TIME *not_before = X509_get_notBefore(x509);
    unsigned char* not_before_str = not_before->data;
    QDateTime dateTime = QDateTime::fromString(QString((char *)not_before_str), "yyyyMMddHHmmssZ");

    return dateTime.toString("yyyy-MM-dd hh:mm:ss");
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetNotAfter(X509 *x509)
{
    if(!x509)
        return QString();

    ASN1_TIME *not_after = X509_get_notBefore(x509);
    unsigned char* not_after_str = not_after->data;
    QDateTime dateTime = QDateTime::fromString(QString((char *)not_after_str), "yyyyMMddHHmmssZ");

    return dateTime.toString("yyyy-MM-dd hh:mm:ss");
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetIssuer(X509 *x509)
{
    if(!x509)
        return QString();

    int nNameLen = 512;
    char csCommonName[512] = {0};
    nNameLen = X509_NAME_get_text_by_NID(X509_get_issuer_name(x509), NID_commonName, csCommonName, nNameLen);

    if(-1 == nNameLen)
        return QString();

    return QString(csCommonName).mid(0, nNameLen);
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetSubject(X509 *x509)
{
    if(!x509)
        return QString();

    int nNameLen = 512;
    char csSubName[512] = {0};
    nNameLen = X509_NAME_get_text_by_NID(X509_get_subject_name(x509), NID_countryName, csSubName, nNameLen);

    if(-1 == nNameLen)
        return QString();

    return QString(csSubName).mid(0, nNameLen);
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetPublicKey(X509 *x509)
{
    if(!x509)
        return QString();

    EVP_PKEY *pubKey = X509_get_pubkey(x509);
    if(!pubKey)
        return QString();

    // 获取公钥的 DER 编码
    unsigned char *pubKeyDER = nullptr;
    int pubKeyDERLen = i2d_PublicKey(pubKey, &pubKeyDER);
    if (pubKeyDERLen <= 0) {
        EVP_PKEY_free(pubKey);
        return QString();
    }
    EVP_PKEY_free(pubKey);

    QString resStr;
    for (int i = 0; i < pubKeyDERLen; i++) {
        resStr.append(QString::number(static_cast<unsigned char>(pubKeyDER[i]), 16).toUpper());
    }

    return resStr;

}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetPublicKeyType(X509 *x509)
{
    if(!x509)
        return QString();

    EVP_PKEY *pubKey = X509_get_pubkey(x509);
    if(!pubKey)
        return QString();

    QString publicKeyType;
    if (EVP_PKEY_id(pubKey) == EVP_PKEY_EC) {
        EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pubKey);
        if (ecKey) {
            const EC_GROUP *group = EC_KEY_get0_group(ecKey);
            if (group) {
                int nid = EC_GROUP_get_curve_name(group);
                if (nid != NID_undef) {
                    const ASN1_OBJECT *obj = OBJ_nid2obj(nid);
                    if (obj) {
                        char oidBuffer[128];
                        int len = OBJ_obj2txt(oidBuffer, sizeof(oidBuffer), obj, 1);
                        if (len > 0) {
                            oidBuffer[len] = '\0'; // 确保字符串以 null 结尾
                            publicKeyType = QString(oidBuffer);
                        } else {
                            qDebug() << "Failed to convert OID to string";
                        }
                    } else {
                        qDebug() << "Failed to get ASN1_OBJECT for NID";
                    }
                } else {
                    qDebug() << "Unknown curve or not a named curve";
                }
            }
        }
    } else {
        qDebug() << "Not an EC public key";
    }
    EVP_PKEY_free(pubKey);

    return QString(publicKeyType);
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetExtBasicConstraints(X509 *x509)
{
    if (!x509)
        return QString();

    int crit = 0;
    char value[512] = {0};
    BASIC_CONSTRAINTS *bcons = NULL;

    bcons = (BASIC_CONSTRAINTS*)X509_get_ext_d2i(x509, NID_basic_constraints, &crit, NULL);
    if (!bcons)
        return QString();

    if (!bcons->ca)
    {
        strcat_s(value, 512, "Subject Type=End Entity; ");
        strcat_s(value, 512, "Path Length Constraint=None");
    }
    else
    {
        char temp[128] = {0};
        sprintf_s(temp, 128, "Path Length Constraint=%d", bcons->pathlen);
        strcat_s(value, 512, "Subject Type=CA; ");
        strcat_s(value, 512, temp);
    }
    BASIC_CONSTRAINTS_free(bcons);

    return QString(value);

}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetAuthorizationKeyIdentifier(X509 *x509)
{
    X509_EXTENSION *ext = X509_get_ext(x509, X509_get_ext_by_NID(x509, NID_authority_key_identifier, -1));
    if (ext != NULL) {
        ASN1_OCTET_STRING *octetStr = X509_EXTENSION_get_data(ext);
        const unsigned char *ptr = octetStr->data;
        QString akidStr;

        // 解析授权密钥标识符
        AUTHORITY_KEYID *akid = d2i_AUTHORITY_KEYID(NULL, &ptr, octetStr->length);
        if (akid) {
            if (akid->keyid) {
                QByteArray keyIdBytes((const char*)akid->keyid->data, akid->keyid->length);
                akidStr = keyIdBytes.toHex();
            }
            AUTHORITY_KEYID_free(akid);
        }

        if(!akidStr.isEmpty())
            akidStr = QString("KeyID=%1").arg(akidStr.toUpper());
        return akidStr;
    }
    return QString();
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetCRL(X509 *x509)
{
    QString crlStr;
    // 获取证书的扩展属性
    X509_EXTENSION *ext = X509_get_ext(x509, X509_get_ext_by_NID(x509, NID_crl_distribution_points, -1));

    if (ext != NULL) {
        // 获取扩展属性的数据
        ASN1_OCTET_STRING *octetStr = X509_EXTENSION_get_data(ext);

        // 将数据解析为 CRL 分发点的结构
        STACK_OF(DIST_POINT) *distPoints = NULL;
        DIST_POINT_NAME *distPointName = NULL;
        distPointName = d2i_DIST_POINT_NAME(NULL, (const unsigned char **)&octetStr->data, octetStr->length);

        // 遍历 CRL 分发点列表
        for (int i = 0; i < sk_DIST_POINT_num(distPoints); ++i) {
            DIST_POINT *distPoint = sk_DIST_POINT_value(distPoints, i);
            // 处理每个 CRL 分发点，例如打印 URL
            GENERAL_NAMES *fullName = distPoint->distpoint->name.fullname;
            for (int j = 0; j < sk_GENERAL_NAME_num(fullName); ++j) {
                GENERAL_NAME *name = sk_GENERAL_NAME_value(fullName, j);
                if (name->type == GEN_URI) {
                    ASN1_IA5STRING *uri = name->d.uniformResourceIdentifier;
                    crlStr += QString((char *)uri->data );
                }
            }
        }
        // 释放资源
        sk_DIST_POINT_free(distPoints);
    }

    return crlStr;
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetIssuerName(X509 *x509)
{
    if(!x509)
        return QString();

    QString aiaExtension;
    const STACK_OF(X509_EXTENSION) *exts = X509_get0_extensions(x509);
    if (exts) {
        int nid = OBJ_txt2nid("authorityInfoAccess");
        for (int i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
            X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
            if (OBJ_obj2nid(X509_EXTENSION_get_object(ext)) == nid) {
                ASN1_OCTET_STRING *str = X509_EXTENSION_get_data(ext);

                aiaExtension = QString::fromUtf8((char *)str->data);
                break;
            }
        }
    }
    return aiaExtension;
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetExtSubjectIdentifier(X509 *x509)
{
    if(!x509)
        return QString();

    QString resStr;
    int crit = 0;
    ASN1_OCTET_STRING *skid = NULL;
    skid = (ASN1_OCTET_STRING*)X509_get_ext_d2i(x509, NID_subject_key_identifier, &crit, NULL);
    if(!skid)
        return QString();

    for (int i = 0; i < skid->length; i++)
    {
        resStr.append(QString::number(static_cast<unsigned char>(skid->data[i]), 16));
    }

    return resStr.toUpper();
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetExtKeyUsage(X509 *x509)
{
    if(!x509)
        return QString();

    QString resStr;
    ASN1_BIT_STRING* lASN1UsageStr;

    lASN1UsageStr = (ASN1_BIT_STRING *)X509_get_ext_d2i(x509, NID_key_usage, NULL, NULL);
    if (lASN1UsageStr)
    {
        char temp[32] = {0};
        unsigned short usage = lASN1UsageStr->data[0];
        if(lASN1UsageStr->length > 1)
        {
            usage |= lASN1UsageStr->data[1] << 8;
        }

        sprintf_s(temp, 32, "(%x)", usage);

        if (usage & KU_DIGITAL_SIGNATURE)
            resStr += QString("Digital Signature,");
        if (usage & KU_NON_REPUDIATION)
            resStr += QString("Non-Repudiation,");
        if (usage & KU_KEY_ENCIPHERMENT)
            resStr += QString("Key Encipherment,");
        if (usage & KU_DATA_ENCIPHERMENT)
            resStr += QString("Data  Encipherment,");
        if (usage & KU_KEY_AGREEMENT)
            resStr += QString("Key  Agreement,");
        if (usage & KU_KEY_CERT_SIGN)
            resStr += QString("Certificate Signature,");
        if (usage & KU_CRL_SIGN)
            resStr += QString("CRL Signature,");

        if(!resStr.isEmpty())
            resStr.chop(1);
    }

    return resStr;
}

QString Adapts::UKey::SW_DigitalCertificatePrivate::GetHash(X509 *x509)
{
    if(!x509)
        return QString();

    unsigned char fingerprint[EVP_MAX_MD_SIZE];
    unsigned int fingerprintLength = 0;
    const EVP_MD* md = EVP_sha1();  // 指纹算法类型，这里使用SHA-256

    if (X509_digest(x509, md, fingerprint, &fingerprintLength) != 1)
        return QString();

    QString resStr;
    for (int i = 0; i < fingerprintLength; i++)
    {
        resStr.append(QString::number(static_cast<unsigned char>(fingerprint[i]), 16));
    }

    return resStr.toUpper();
}

总结

因为使用的并不是自己编译的库文件，所以里面的dll需要拷贝到exe目录。
参考资料：
ParseX509-OpenSSL
通过OpenSSL解析X509证书基本项
通过OpenSSL获取X509证书的HASH(指纹)值
C++使用OpenSSL实现Rsa验证签名、验签----自测OK

海不迎
关注
使用openssl生成pfx数字证书（亲测实战好用）
thm0805的博客
11-02 5696
openssl生成pfx数字证书
证书体系： PFX 文件格式解析
Useless Programmer 的专栏
11-24 7273
章节目录 PFX 简介 PFX 格式解析 2.1 最外层结构 2.2 AuthenticatedSafe 结构 参考 https://tools.ietf.org/html/rfc7292. PFX 简介## 以下引用自维基百科 在密码学中，PKCS #12 定义了一种存档文件格式，用于实现存储许多加密对象在一个单独的文件中。通常用它来打包一个私钥及有关的 X.509 证书，或者打包信任...
为exe文件进行数字签名-制作pfx自签名证书文件
最新发布
2302_80197042的博客
08-07 1383
亲测有效, 小白过坑指南.
openssl 创建pfx证书
玖拾说架构
03-31 249
在存储证书时，为了不被泄露，一般证书的密钥不直接以文件形式（.key文件）存储，我们可以将证书文件和密钥文件合并生成pfx个人正式格式。 openssl pkcs12 -export -in my.cer -inkey my.key -out my.pfx
openssl 创建 pfx 证书
Man_In_The_Night的博客
09-01 792
环境： centos7.6, openssl 1.02k-fips 生成私钥 [root@ansible002 keyfile]# openssl genrsa -out server.key 1024 Generating RSA private key, 1024 bit long modulus ......++++++ ...++++++ e is 65537 (0x10001) 生成证书请求文件，需要填写信息，例如：cn/gd/zh/sourcecode/bdc/www.a.com [root@
pfx证书解析公钥私钥
weixin_45793178的博客
04-08 1151
openssl pkcs12 -intest.pfx-nodes -out server.pem 输入证书密码 提取公钥 X.509格式 openssl x509 -in server.pem -out public.cer RSA格式
通过openssl生成pfx证书
adminstate的博客
02-21 4613
使用openssl生成pfx文件，及在项目中的使用
Java如何基于command调用openssl生成私钥证书
08-18
通过使用Java调用openssl，我们可以在Java程序中生成私钥证书，从而实现数据加密、身份验证等功能。此外，使用Java调用openssl也可以简化私钥证书的生成过程，提高开发效率。 Java如何基于command调用openssl生成...
基于openssl 自行签发https 协议证书 openssl+nginx实现https自签有效加密实战记录
03-30
"基于openssl自行签发https协议证书openssl+nginx实现https自签有效加密实战记录" 本篇文章主要讲述了使用openssl自行签发https协议证书，并使用nginx实现https自签有效加密的实战记录。文章包含了证书签发、nginx...
openssl提取pfx私钥
05-16
在 OpenSSL 中，您可以使用以下命令将 PFX 文件中的私钥提取出来： ``` openssl pkcs12 -in filename.pfx -nocerts -out key.pem ``` 其中，`filename.pfx` 是您要提取私钥的 PFX 文件名，`key.pem` 是提取出的...
OpenSSL 解析P12格式证书文件
04-06
OpenSSL 是一个强大的安全套接层（SSL）和传输层安全（TLS）协议实现库，同时也包含了一系列加密算法、证书处理和其他相关工具。在IT领域，尤其是在网络安全和服务器配置中，OpenSSL扮演着至关重要的角色。本文将...
pfx证书工具
09-16
证书创建工具生成仅用于测试目的的 X.509 证书。它创建用于数字签名的公钥和私钥对，并将其存储在证书文件中。 此工具还将密钥对与指定发行者的名称相关联，并创建一个 X.509 证书，该证书将用户指定的名称绑定到密钥对的公共部分。 创建证书时会提示要求证书的私钥密码（Subject Key，两个密码输入框），并会在生成cer文件是再次要求输入密码（一个输入框）
pfx证书安装
08-14
Tomcat支持JKS格式证书，从Tomcat7开始也支持PFX格式证书，两种证书格式任选其
制作RSA非对称加密证书（pfx\der）openssl
10-23
制作RSA非对称加密证书（pfx\der） 内有openssl工具，直接运行
pfx证书生成 工具
09-28
开发技术使用RSA非对称加密，一键生成pfx证书工具，内附 文档说明。
pfx证书一键生成
11-17
pfx证书一键生成 压缩文档内有详细说明,利用批处理便捷的生成pfx证书.
openssl SM2 密钥解析出公钥和私钥
08-07
openssl 中把pem格式的SM2密钥，解析成EC_KEY格式的key，然后解析出key中公钥和私钥
OpenSSL 生成pfx
杨义权的博客
01-27 2287
OpenSSL 生成pfx Window需要安装OpenSSL（需要下载），Linux自带OpenSSL工具（无需安装） Window下载地址： 官网 我已经上传了一份到csdn Window 命令 # 生成私钥 "D:\Program Files\OpenSSL-Win64\bin\openssl.exe" genrsa -aes256 -passout "pass:123yIQuAn" -out "key.pem" 4096 # 生成公钥 "D:\Program Files\OpenSSL-Win64\
openssl 生成pfx
terrorist2008的专栏
06-29 191
openssl 生成pfx    1、生产RSA私钥             openssl genrsa -out openssl.key 1024   2、生成私钥对应证书          openssl  req -new -x509 -key openssl.key -out openssl.cer -days 3650 -subj /CN=yzl.website ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值