使用openssl操作P12证书

最新推荐文章于 2023-04-12 15:17:25 发布
最新推荐文章于 2023-04-12 15:17:25 发布
阅读量5.3k 收藏
点赞数

以下代码并非完全原创，有所参考借鉴。

/* vi:set tw=0 ts=4 sw=4 noet: */

/************************************************************************/
/*!          \file:  p12op.cpp
 *          \brief:  
 *
 *        \version:  1.0
 *         \author:  f7zz , f7zz@yahoo.com
 *        \Company:  ZLab
 *           \date:  2005-6-30 14:32:41 中国标准时间
 *             
 *            \bug:   
 *        \warning:  
 *
 * CVS:  $Id$ 
 ************************************************************************/

/** 从DER、PEM、P12格式中读取公钥证书.
 *  由该函数导出的X509必须释放(X509_free)
 */
X509 * BaseLoadCert (BIO * Cert, int iFormat, char *strPwd)
{
    X509 *x = NULL;

    switch (iFormat)
    {
    case DER:
        x = d2i_X509_bio (Cert, NULL);
        break;
    case PEM:
        x = PEM_read_bio_X509 (Cert, NULL, NULL, NULL);    //PEM_read_bio_X509_AUX
        break;
    case P12:
        {
            PKCS12 *p12 = d2i_PKCS12_bio (Cert, NULL);

            PKCS12_parse (p12, strPwd, NULL, &x, NULL);
            PKCS12_free (p12);
            p12 = NULL;
            break;
        }
    default:
        break;
    }
    return x;
}

/** 载入证书.
 *  尝试使用DER/PEM格式两种格式
 * 由该函数导出的X509必须释放
 */
X509 * LoadCert (char *cert, int certlen)
{
    BIO *in = NULL;
    X509 *x509 = NULL;

    assert(cert);

    if (certlen == 0)            /// 输入为磁盘文件
    {
        if ((in = BIO_new_file (cert, "r")) == NULL)
        {
            return NULL;
        }
    }
    else                  // 输入为内存中文件
    {
        if ((in = BIO_new_mem_buf (cert, certlen)) == NULL) //只读类型
        {
            return NULL;
        }
    }

    if ((x509 = BaseLoadCert (in, DER, NULL)) == NULL)    //尝试DER
    {
        BIO_reset (in);
        x509 = BaseLoadCert (in, PEM, NULL);      //尝试PEM
    }

    BIO_free (in);
    in = NULL;
    in = 0;
    return x509;
}

/** 尝试从DER/PEM/P12格式导出密钥
 *  由该函数导出的EVP_PKEY必须释放
 */
EVP_PKEY * BaseLoadKey (BIO * bio, int iFormat, char *strPwd)
{
    EVP_PKEY *pkey = NULL;

    switch (iFormat)
    {
    case DER:
        pkey = d2i_PrivateKey_bio (bio, NULL);
        break;
    case PEM:
        pkey = PEM_read_bio_PrivateKey (bio, NULL, NULL, strPwd);
        break;
    case P12:
        {
            PKCS12 *p12 = d2i_PKCS12_bio (bio, NULL);

            PKCS12_parse (p12, strPwd, &pkey, NULL, NULL);
            PKCS12_free (p12);
            p12 = NULL;
            break;
        }
    default:
        break;
    }
    return pkey;
}


/** 载入私钥.
 *  尝试DER/PEM格式
 */

EVP_PKEY * LoadKey (char *key, int keylen, char *pass)
{
    EVP_PKEY *pkey = NULL;
    BIO *in = NULL;

    if (keylen == 0)            //输入为磁盘文件
    {
        if ((in = BIO_new_file (key, "r")) == NULL)
        {
            return NULL;
        }
    }
    else               //输入为内存中文件
    {
        if ((in = BIO_new_mem_buf (key, keylen)) == NULL)  //只读类型
        {
            return NULL;
        }
    }

    if ((pkey = BaseLoadKey (in, DER, pass)) == NULL)    //尝试DER
    {
        BIO_reset (in);
        pkey = BaseLoadKey (in, PEM, pass);       //尝试PEM
    }

    if (in != NULL)
        BIO_free (in);

    return pkey;
}

/** 载入p12.
 *
 */
PKCS12 * LoadP12 (char *strP12File, char *strP12Pwd)
{
    FILE *fp = NULL;
    PKCS12 *p12 = NULL;

    assert(strP12File);
    assert(strP12Pwd);

    /// 读入P12
    if (!(fp = fopen (strP12File, "rb")))
        return NULL;
    p12 = d2i_PKCS12_fp (fp, NULL);
    fclose(fp);
    if (!p12)
        return NULL;

    return p12;
}


int p12_ChangePwd (char *strP12, char *strPwd, char *strNewPwd)
{
    FILE *fp = NULL;
    PKCS12 *p12 = NULL;
    int reval;

    assert(strP12);
    assert(strPwd);
    assert(strNewPwd);

    OpenSSL_add_all_algorithms ();

    /// 读入P12
    if (!(fp = fopen (strP12, "r+bc")))
    {
        /* deferr(ERR_P12CHGPWD_OPENFILE, "p12_ChangePwd(): Error Open p12 file.") */
        return ERR_P12CHGPWD_OPENFILE;
    }
    p12 = d2i_PKCS12_fp (fp, NULL);
    if (!p12)
    {
        fclose (fp);
        /* deferr(ERR_P12CHGPWD_READFILE, "p12_ChangePwd(): Error Read p12 file.") */
        return ERR_P12CHGPWD_READFILE;
    }

    reval = PKCS12_newpass (p12, strPwd, strNewPwd);
    if (!reval)
    {
        PKCS12_free (p12);
        p12 = NULL;
        fclose (fp);
        /* deferr(ERR_P12CHGPWD_UPDATE, "p12_ChangePwd(): Error Update Password.") */
        return ERR_P12CHGPWD_UPDATE;
    }

    /// i2d_PKCS12_fp的bug, 对于老文件，必须将文件指针移到文件头
    fseek (fp, 0, SEEK_SET);
    reval = i2d_PKCS12_fp (fp, p12);
    if (!reval)
    {
        PKCS12_free (p12);
        p12 = NULL;
        fclose (fp);
        /* deferr(ERR_P12CHGPWD_UPDATE, "p12_ChangePwd(): Error Update Password.") */
        return ERR_P12CHGPWD_UPDATE;
    }

    /// 释放
    PKCS12_free (p12);
    p12 = NULL;
    fclose (fp);
    return 1;
}

int p12_VerifyPwd (char *strP12, char *strPwd)
{
    int reval;

    assert(strP12);
    assert(strPwd);

    reval = p12_ChangePwd (strP12, strPwd, strPwd);
    if (reval != 1)
    {
        /* deferr(ERR_P12VERIFYPWD, "p12_ChangePwd(): Error Verify Password.") */
        return ERR_P12VERIFYPWD;
    }
    return 1;
}

int p12_ExpToNewP12 (char *strP12,      /*源p12文件 */
                 char *strPwd,          /*源p12密码 */
                 char *strPwd2,         /*新p12密码 */
                 char *strOutP12        /*新p12文件 */
                )
{
    int reval;

    FILE *fp = NULL;
    EVP_PKEY *key = NULL;
    X509 *cert = NULL;

    STACK_OF (X509) * ca = NULL;
    PKCS12 *p12 = NULL;
    int len = 0, wlen = 0;

    assert(strP12);
    assert(strPwd);
    assert(strPwd2);
    assert(strOutP12);

    OpenSSL_add_all_algorithms ();

    /// 读入P12，并分解
    if (!(fp = fopen (strP12, "rb")))
    {
        /* deferr(ERR_P12EXP_OPENFILE, "p12_ExpNewP12(): Error Open p12 file.") */
        return ERR_P12EXP_OPENFILE;
    }

    p12 = d2i_PKCS12_fp (fp, NULL);
    fclose (fp);
    if (!p12)
    {
        /* deferr(ERR_P12EXP_READFILE, "p12_ExpNewP12(): Error Read p12 file.") */
        return ERR_P12EXP_READFILE;
    }

    if (!PKCS12_parse (p12, strPwd, &key, &cert, &ca))
    {
        PKCS12_free(p12);
        p12 = NULL;
        /* deferr(ERR_P12EXP_PARSE, "p12_ExpNewP12(): Error Parse p12 file.") */
        return ERR_P12EXP_PARSE;
    }
    PKCS12_free (p12);
    p12 = NULL;

    /// 生成新P12
    p12 = PKCS12_create (strPwd2, "Duplicated", key, cert, ca, 0, 0, 0, 0, 0);
    if (!p12)
    {
        /* deferr(ERR_P12EXP_CREATESTRUCT, "p12_ExpNewP12(): Error Create p12 struct.") */
        reval = ERR_P12EXP_CREATESTRUCT;
        goto Cleanup;
    }

    /// 创建新p12文件，并保存
    if (!(fp = fopen (strOutP12, "wb")))
    {
        /* deferr(ERR_P12EXP_CREATEFILE, "p12_ExpNewP12(): Error Create p12 file.") */
        reval = ERR_P12EXP_CREATEFILE;
        goto Cleanup;
    }
    i2d_PKCS12_fp (fp, p12);

    reval = 1;

Cleanup:
    /// 释放
    if(p12 != NULL)
        PKCS12_free (p12);
    if (fp != NULL)
        fclose (fp);
    if (cert != NULL)
        X509_free (cert);
    if (key != NULL)
        EVP_PKEY_free (key);
    if (ca != NULL)
    {
        for(;;)
        {
            X509 *x5 = sk_X509_pop(ca);
            if (!x5)
                break;
            X509_free(x5);
        }
        sk_X509_free (ca);
    }

    return reval;
}


int p12_ExpToCertKey (char *strP12, char *strPwd, int iFormat, char *Cert, char *Key, char *Ca)
{
    int reval;
    EVP_PKEY *key = NULL;
    X509 *cert = NULL;

    STACK_OF (X509) * ca = NULL;
    BIO *bio = NULL, *bioCert = NULL, *bioKey = NULL, *bioCaCert = NULL;
    PKCS12 *p12 = NULL;
    int reval1 = 0, reval2 = 0, reval3 = 0;

    assert(strP12);
    assert(strPwd);
    assert(iFormat);
    assert(Cert);
    assert(Key);
    assert(Ca);

    OpenSSL_add_all_algorithms ();

    if (!(bio = BIO_new_file (strP12, "r")))
    {
        /* deferr(ERR_P12EXPCK_OPENFILE, "p12_ExpToCertKey(): Error Open p12 file.") */
        return ERR_P12EXPCK_OPENFILE;
    }

    p12 = d2i_PKCS12_bio (bio, NULL);
    BIO_free (bio);
    bio = NULL;
    if (!p12)
    {
        /* deferr(ERR_P12EXPCK_READFILE, "p12_ExpToCertKey(): Error Read p12 file.") */
        return ERR_P12EXPCK_READFILE;
    }

    if (!PKCS12_parse (p12, strPwd, &key, &cert, &ca))
    {
        /* deferr(ERR_P12EXPCK_PARSE, "p12_ExpToCertKey(): Error Parse p12 file.") */
        return ERR_P12EXPCK_PARSE;
    }
    PKCS12_free (p12);
    p12 = NULL;

    /// 输出文件
    if ((bioCert = BIO_new_file (Cert, "w")) == NULL)
    {
        /* deferr(ERR_P12EXPCK_CREATECERTFILE, "p12_ExpToCertKey(): Error Create Cert File.") */
        reval = ERR_P12EXPCK_CREATECERTFILE;
        goto Cleanup;
    }

    if ((bioKey = BIO_new_file (Key, "w")) == NULL)
    {
        /* deferr(ERR_P12EXPCK_CREATEKEYFILE, "p12_ExpToCertKey(): Error Create Key File.") */
        reval = ERR_P12EXPCK_CREATEKEYFILE;
        goto Cleanup;
    }
    if (iFormat == DER)
    {
        reval1 = i2d_X509_bio (bioCert, cert);
        reval2 = i2d_PrivateKey_bio (bioKey, key);
    }
    else if (iFormat == PEM)
    {
        reval1 = PEM_write_bio_X509 (bioCert, cert);
        reval2 = PEM_write_bio_PrivateKey (bioKey, key, NULL, NULL, 0, 0, NULL);
    }
    BIO_free (bioCert);
    bioCert = NULL;
    BIO_free (bioKey);
    bioKey = NULL;
    X509_free (cert);
    cert = NULL;
    EVP_PKEY_free (key);
    key = NULL;

    if (ca && sk_num (ca))
    {
        if ((bioCaCert = BIO_new_file (Ca, "w")) == NULL)
        {
            /* deferr(ERR_P12EXPCK_CREATEFILE, "p12_ExpToCertKey(): Error Create Cert or Key File.") */
            reval = ERR_P12EXPCK_CREATEFILE;
            goto Cleanup;
        }
        if (iFormat == DER)
        {
            /* deferr(ERR_P12EXPCK_NOTSURPORT, "p12_ExpToCertKey(): Not Surport _MCRT_EXPORT DER ca cert.") */
            reval = ERR_P12EXPCK_NOTSURPORT;
            goto Cleanup;
        }
        else if (iFormat == PEM)
        {
            int i;

            for (i = 0; i < sk_X509_num (ca); i++)
                reval3 = PEM_write_bio_X509_AUX (bioCaCert, sk_X509_value (ca, i));
        }
        BIO_free (bioCaCert);
        bioCaCert = NULL;
    }
    else
        reval3 = 1;


    if (reval1 == 0 || reval2 == 0 || reval3 == 0)
    {
        /* deferr(ERR_P12EXPCK_FAILED, "p12_ExpToCertKey(): Error _MCRT_EXPORT Cert or Key File.") */
        reval = ERR_P12EXPCK_FAILED;
        goto Cleanup;
    }
    reval = 1;

Cleanup:
    if (bio != NULL)
        BIO_free(bio);
    if (bioCert != NULL)
        BIO_free(bioCert);
    if (bioKey != NULL)
        BIO_free(bioKey);
    if (bioCaCert != NULL)
        BIO_free(bioCaCert);

    if (key != NULL)
        EVP_PKEY_free(key);
    if (cert != NULL)
        X509_free(cert);
    if (ca != NULL)
    {
        for(;;)
        {
            X509 *x5 = sk_X509_pop(ca);
            if (!x5)
                break;
            X509_free(x5);
        }
        sk_X509_free (ca);
    }

    return reval;
}

int p12_impfromCertKey (char *strP12, char *strPwd, int iFormat, char *strCert, char *strKey, char *strCa)
{
    int reval;

    FILE *fp = NULL;
    EVP_PKEY *key = NULL;
    X509 *cert = NULL, *ca0 = NULL;

    STACK_OF (X509) * ca = NULL;
    PKCS12 *p12 = NULL;
    int len = 0, wlen = 0;
 
 OpenSSL_add_all_algorithms ();

 // 加载cert,key,ca
 cert = LoadCert (strCert, 0);
    if (cert == NULL)
    {
  printf("p12_impfromCertKey(): LoadCert Error!\n");
        return ERR_CERTGETI_OPEN;
    }

 key = LoadKey (strKey, 0, NULL);   /// 默认密钥为明文
    if (key == NULL)
    {
  printf("p12_impfromCertKey(): LoadKey Error!\n");
        return -1;
    }

 ca0 = LoadCert (strCa, 0);
    if (ca0 == NULL)
    {
  printf("p12_impfromCertKey(): LoadCert CA Error!\n");
        return ERR_CERTGETI_OPEN;
    }
 
 ca = sk_X509_new_null();
    if (ca == NULL)
    {
  printf("p12_impfromCertKey(): sk_X509_new_null Error!\n");
        return -1;
    }

 printf("4\n");

 if (!sk_X509_push(ca, ca0))
 {
  printf("p12_impfromCertKey(): sk_X509_push Error!\n");
        return -1;
 }

 /// 生成新P12
    p12 = PKCS12_create (strPwd, "Duplicated", key, cert, ca, 0, 0, 0, 0, 0);
    if (!p12)
    {
        /* deferr(ERR_P12EXP_CREATESTRUCT, "p12_ExpNewP12(): Error Create p12 struct.") */
        reval = ERR_P12EXP_CREATESTRUCT;
        goto Cleanup;
    }

    /// 创建新p12文件，并保存
    if (!(fp = fopen (strP12, "wb")))
    {
        /* deferr(ERR_P12EXP_CREATEFILE, "p12_ExpNewP12(): Error Create p12 file.") */
        reval = ERR_P12EXP_CREATEFILE;
        goto Cleanup;
    }
    i2d_PKCS12_fp (fp, p12);

    reval = 1;

Cleanup:
    /// 释放
    if(p12 != NULL)
        PKCS12_free (p12);
    if (fp != NULL)
        fclose (fp);
    if (cert != NULL)
        X509_free (cert);
    if (key != NULL)
        EVP_PKEY_free (key);
    if (ca != NULL)
    {
        for(;;)
        {
            X509 *x5 = sk_X509_pop(ca);
            if (!x5)
                break;
            X509_free(x5);
        }
        sk_X509_free (ca);
    }

    return reval;
}

 在windows下使用vc编译的openssl的库是要分debug和release的，比如用release的程序去调debug的库，某些 函数可能会有错，比如以上用到的d2i_PKCS12_bio函数（在我用的0.9.7g，最新的版本未测试过）中，所以敬请注意。

如果你的windows下使用gcc编译程序和库，就不会由什么问题.


http://laokaddk.blog.51cto.com/368606/596124/


bytxl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用OpenSSL生成Kubernetes证书的介绍
01-10
kubernetes支持Base认证/Token认证/CA认证三种，这篇文章用于记录一下CA认证所需要的最简单程度的命令。 kubernetes构成 测试版本为1.10，但不限于此版本，为openssl证书较为通用的方式。 所需证书 所需要的证书相关文件的说明如下： CA证书 CA证书私钥 命令：openssl genrsa -out ca.key 2048 [root@host121 k8scert]# openssl genrsa -out ca.key 2048 Generating RSA private key, 2048 bit long modulus .......
使用openssl生成cer、p12证书
zwc609906的博客
06-27 1万+
这篇文件的资源也是参考了其他博主的文章，这里需要感谢这些博主。我这边只是做一个记录，方便日后查阅。谢谢！ 创建证书的时候使用的密码都是11111111，故命令语句中都是按照该密码输入的。 一、准备工作--生成根目录 1、创建根证私钥 openssl genrsa -out root-key.key 2048 2、创建根证书请求文件 openssl req -new -out root-req....
.p12 证书过期时间查询
weixin_39831786的博客
01-09 2135
证书过期时间
Windows安装使用Openssl
热门推荐
Edwin Lee的博客
06-09 4万+
更新更全更详细更便于阅览的新文章地址：Windows安装使用Openssl[新] https://blog.csdn.net/KiTok/article/details/90349671 什么是OpenSSL？ OpenSSL是用于安全通信的著名开源密码学工具包，包括主要的密码算法、常见密码和证书封装功能。 1. OpenSSL官网 官方下载地址： https://www.ope...
30.openssl编程——PCKS12
艾小小雨的博客
01-25 563
30.1 概述pkcs12（个人数字标准）用于存放用户证书、crl、用户私钥以及证书链，pkcs12中的私钥是加密存放的。30.2 openssl实现openssl的pkcs12实现在crypto/pkcs12目录，有如下源码：目录架构用途p12_add.c处理PCKS12_SAFEBAG, PKCS12_SAFEBAG用于存放正数和私钥相关的信息p12_attr.c属性处理p12_ct...
openssl将证书（公钥）和私钥合并成pfx格式文件（C语言版）
weixin_43432215的博客
04-12 1494
首先需要将证书和私钥加载到内存中。可以使用函数 PEM_read_bio_X509() 和 PEM_read_bio_PrivateKey() 分别读取证书和私钥的数据，存储到 X509 和 EVP_PKEY 结构体中。其中 cert_data 和 key_data 分别是证书和私钥的 BASE64 编码字符串，cert_data_len 和 key_data_len 分别是字符串的长度。使用函数 PKCS12_create() 创建 PKCS#12 对象，将证书和私钥绑定到该对象上。
openssl---p12生成证书及pem
去去的的博客
04-09 9508
打开终端，敲入命令即可转换 p12生成证书 openssl pkcs12 -clcerts -nokeys -out apple_cert.pem -in apple_cert.p12 p12导出key，这时需要输入p12的导出密码 openssl pkcs12 -nocerts -nodes -out apple.key -in apple_cert.p12 利用key导出公私钥（存在r...
OpenSSL 证书
u010249118的博客
10-11 5288
X.509 OpenSSL 证书
OpenSSL 解析P12格式证书文件
04-06
NULL 博文链接：https://jacky-dai.iteye.com/blog/1545241
java p12 ssl_OpenSSL 1.0.0生成p12、jks、crt等格式SSL数字证书的全过程合集
weixin_29516131的博客
02-16 509
在这里跟万维景盛的开发者伙伴们分享OpenSSL 1.0.0生成p12、jks、crt等格式SSL数字证书的全过程合集，此生成的证书可用于浏览器、java、tomcat、c++等。步骤如下：1.创建根证私钥命令：openssl genrsa -out root-key.key 10242.创建根证书请求文件命令：openssl req -new -out root-req.csr -key ro...
p12解析流程_OpenSSL 解析P12格式证书文件
weixin_39902107的博客
12-19 1212
1 解压openssl-0.9.8k_WIN32.zip 到 c:\根目录；解压文件夹如下；2 打开控制台，并切换到OpenSSL可执行文件所在目录；3 利用OpenSSL创建.p12测试文件(也就是证书制作过程)；详细创建步骤如下；3.1 生成ca私钥a) openssl dsaparam -out dsaparam 1024b) openssl gendsa -out dsakey dsapa...
openssl主要流程程序代码
zhulianhai0927的专栏
05-14 1255
   // CA.cpp : Defines the entry point for the DLL application.      //      #define sprintf_s sprintf       #include "stdafx.h"      #include       #include "ca.h"      #include       #incl
所有常见证书处理函数的实现
zhulianhai0927的专栏
04-01 1243
// 转换私钥编码格式          BOOL ConvertKeyFormat(char *oldKey,int oldKeyLen,int oldFormat,      char *newKeyFile,int newFormat)     {      EVP_PKEY *key=NULL;      BIO *biout=NULL;      int ret;    
OpenSSL学习之使用个人信息数字证书(PFX)进行签名和验证
大伟的代码空间
04-21 5720
作者：俞伟   QQ：12400976 MSN：[email protected]最近需要用到数字签名的相关技术，但是网络上对这方面的文章说的含糊，所以自己把这段时间在学习OpenSSL过程中得到心得发表出来，供大家讨论，欢迎大家联系我，互相交流。以下是实现PFX证书的读取和应用证书进行数字签名与签名验证：环境：VC6 + WIN2003 + OPENSSL代码：#includ
09.openssl高级编程
艾小小雨的博客
01-07 200
10.1通用形式的堆栈操作函数STACK_OF(TYPE) *sk_TYPE_new_null(void);void sk_TYPE_free(STACK_OF(TYPE) *st)void sk_TYPE_pop_free(STACK_OF(TYPE) *st, void (*free_func)(TYPE))void sk_TYPE_zero(STACK_OF(TYPE) *st)...
openssl-p12证书
weixin_46089486的博客
01-14 559
p12证书导出pem格式证书 一、来由-决定思路 1、最近有个数据要用到SHA256withRSA算法进行签名，用的是openssl中的算法，使用的pem格式的证书；但是证书来源的格式为xxx.p12；是p12格式的。 2、因此就需要将p12格式的证书导出为pem格式的。 3、因为此p12证书有密码，因此需要传入密码。 二、导出命令 openssl pkcs12 -in bestpay.p12 -...
OpenSSL使用3（基本原理及生成过程）（转）
angou6476的博客
01-17 214
1. 基本原理 OpenSSL初接触的人恐怕最难的在于先理解各种概念 公钥/私钥/签名/验证签名/加密/解密/非对称加密 我们一般的加密是用一个密码加密文件,然后解密也用同样的密码.这很好理解,这个是对称加密.而有些加密时,加密用的一个密码,而解密用另外一组密码,这个叫非对称加密,意思就是加密解密的密码不一样.初次接触的人恐怕无论如何都理解不了.其实这是数学上的一个素数积求因子的原...
openssl生成证书链 p12
最新发布
08-01
要使用openssl生成证书链p12文件，可以按照以下步骤进行操作： 1. 首先，生成根CA证书并自签。可以使用openssl genrsa命令生成私钥，然后使用openssl req命令生成证书请求，最后使用openssl x509命令自签发证书。 2. 接下来，生成二级CA证书并使用根CA证书签发。同样，使用openssl genrsa命令生成私钥，使用openssl req命令生成证书请求，然后使用openssl ca命令使用根CA证书签发二级CA证书。 3. 然后，生成服务器证书并使用二级CA证书签发。使用openssl genrsa命令生成私钥，使用openssl req命令生成证书请求，最后使用openssl ca命令使用二级CA证书签发服务器证书。 4. 接下来，制作CA证书链。可以使用openssl命令将根CA证书和二级CA证书合并成一个文件。 5. 然后，将证书链打包为p12文件。使用openssl pkcs12命令将服务器证书和私钥合并成p12文件。 综上所述，可以使用openssl命令生成证书链p12文件。具体的命令和步骤可以参考引用[1]和引用[2]中提供的信息。请注意，使用openssl x509和openssl ca命令生成证书的差别在于配置文件的使用，具体选择哪种方式取决于需求和使用场景。参考引用[3]中的信息可以更好地理解这两种方式的差异。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值