openssl 编程。证书制作

最新推荐文章于 2023-07-16 00:26:53 发布

baidu_32526299

最新推荐文章于 2023-07-16 00:26:53 发布

阅读量896

点赞数

分类专栏： https

https 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

么刚的专栏

RSS订阅

原

openssl证书制作及编程

2010年07月29日 19:56:00

阅读数：5990

一、openssl证书制作：

1、创建目录./demoCA/ ./demoCA/newcerts/，创建文件 ./demoCA/index.txt ./demoCA/serial。

2、执行echo 01 > ./demoCA/serial

3、制作自己的CA证书

$openssl req -new -x509 -keyout ca.key -out ca.crt

4、生成服务端的私钥(key文件)及csr文件

$openssl genrsa -des3 -out server.key 1024

$openssl req -new -key server.key -out server.csr

5、生成客户端的私钥(key文件)及csr文件

$openssl genrsa -des3 -out client.key 1024

$openssl req -new -key client.key -out client.csr

6、用生成的CA的证书为刚才生成的server.csr,client.csr文件签名

$openssl ca -in server.csr -out server.crt -cert ca.crt -keyfile ca.key

$openssl ca -in client.csr -out client.crt -cert ca.crt -keyfile ca.key

7、生成pem格式证书

有时需要用到pem格式的证书，可以用以下方式合并证书文件（crt）和私钥文件（key）来生成

$cat client.crt client.key> client.pem

$cat server.crt server.key > server.pem

二、openssl编程

openssl的编程有两种风格：原生态的和层层封装的。

2.1原生态openssl编程

需要使用BSD socket和openssl中的较底层的API。原生态openssl有两个比较重要的结构SSL和SSL_CTX。

SSL_CTX数据结构是用与建立SSL/TSL连接的结构，可用于指定通讯协议（SSLv23/TSLv1）、证书、密钥等相关信息。

SSL数据结构是和具体会话相关联的结构。

常用函数：

SSL_library_init（）：初始化一个openssl库。

   SSL_CTX_new（const SSL_METHOD *method）：创建一个CTX结构。

   SSL_new（SSL_CTX *ctx）：创建一个SSL结构。

   SSL_set_fd（SSL *ssl, int fd）：把ssl结构和具体会话相关联。

   SSL_accept(SSL *ssl)、SSL_connect(SSL *ssl)：用于SSL会话握手。

   SSL_read（SSL *ssl, void *buf, int num）和SSL_write（SSL *ssl, void *buf, int num）用于SSL读写。

   SSL_shutdown（SSL *ssl）用于关闭一个SSL/TSL会话。

   使用这些函数就可以进行最基本的openssl编程了。Openssl编程框架如下。

   代码示例：HTTPS服务器和客户端

   服务器端:

 
       [cpp] 
       view plaincopy
#include <sys/types.h>  
#include <sys/socket.h>  
#include <sys/un.h>  
#include <unistd.h>  
#include <stdio.h>  
#include <arpa/inet.h>  
  
#include <openssl/bio.h>  
#include <openssl/ssl.h>  
#include <openssl/err.h>  
  
#define SERVER_PEM "../digitCert/server.pem"  
#define SERVER_KRY "../digitCert/server.key"  
  
int password_callback(char *buf, int size, int rwflag, void *userdata)  
{  
    /* For the purposes of this demonstration, the password is "ibmdw" */  
    printf("*** Callback function called/n");  
    strcpy(buf,"123456");  
    return strlen(buf);  
}  
  
int main()  
{  
    int serv_sock,cli_sock;  
    socklen_t client_len;  
    struct sockaddr_in server_address;  
    struct sockaddr_in client_address;  
    SSL_CTX * ctx;  
    SSL *ssl;  
  
    int (*callback)(char *, int, int, void *) = &password_callback;  
  
    printf("Serving it up in a secure manner/n/n");  
    SSL_library_init();  
    SSL_load_error_strings();  
    ERR_load_BIO_strings();  
    ERR_load_SSL_strings();  
    OpenSSL_add_all_algorithms();  
  
    printf("Attempting to create SSL context... ");  
    ctx = SSL_CTX_new(SSLv23_server_method());  
    if(ctx == NULL)  
    {  
        printf("Failed. Aborting./n");  
        return 0;  
    }  
  
    printf("/nLoading certificates.../n");  
    SSL_CTX_set_default_passwd_cb(ctx, callback);  
    if(!SSL_CTX_use_certificate_file(ctx, SERVER_PEM, SSL_FILETYPE_PEM))  
    {  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
    else printf("load server.csr successful!/n");  
    if((SSL_CTX_use_PrivateKey_file(ctx, SERVER_KRY, SSL_FILETYPE_PEM))<=0)  
    {  
        printf("use private key failed!/n/n");  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
  
    serv_sock = socket(AF_INET,SOCK_STREAM,0);  
    if(-1 == serv_sock){  
        perror("socket");  
    }  
    server_address.sin_family = AF_INET;  
    server_address.sin_port = htons(443);  
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);  
  
    int ret = bind(serv_sock,(struct sockaddr*)&server_address,sizeof(struct sockaddr));  
    if(-1 == ret){  
        perror("bind");  
    }  
    listen(serv_sock,5);  
    while(1){  
        cli_sock = accept(serv_sock,(struct sockaddr *)&client_address,(socklen_t *)&client_len);  
        ssl = SSL_new(ctx);  
        SSL_set_fd (ssl, cli_sock);  
          
        SSL_accept (ssl);  
  
        //读取  
         char line[4096];  
        SSL_read(ssl, line, sizeof (line));  
        //正常处理HTTP协议  
         //写入，返回报文。  
         SSL_write(ssl,"HTTP/1.0 200 OK/r/n/r/n",19);  
        SSL_write(ssl,"<html><header></header><body><p1>Hello World<p1></body></html>",62);  
        close(cli_sock);  
        SSL_shutdown(ssl);  
        SSL_free(ssl);        
    }  
    SSL_CTX_free (ctx);  
}  

   客户端：

 
       [cpp] 
       view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include <errno.h>  
#include <unistd.h>  
#include <netinet/in.h>  
#include <limits.h>  
#include <netdb.h>  
#include <arpa/inet.h>  
#include <ctype.h>  
#include <openssl/crypto.h>  
#include <openssl/ssl.h>  
#include <openssl/err.h>  
#include <openssl/rand.h>  
  
#define DEBUG 1  
  
/******************************************** 
功能：搜索字符串右边起的第一个匹配字符 
********************************************/  
char *Rstrchr(char *s, char x)  
{  
    int i = strlen(s);  
    if (!(*s))  
        return 0;  
    while (s[i - 1])  
        if (strchr(s + (i - 1), x))  
            return (s + (i - 1));  
        else  
            i--;  
    return 0;  
}  
  
/************************************************************** 
功能：从字符串src中分析出网站地址和端口，并得到用户要下载的文件 
***************************************************************/  
void GetHost(char *src, char *web, char *file, int *port)  
{  
    char *pA;  
    char *pB;  
    memset(web, 0, sizeof(web));  
    memset(file, 0, sizeof(file));  
    *port = 0;  
    if (!(*src))  
        return;  
    pA = src;  
    if (!strncmp(pA, "http://", strlen("http://")))  
        pA = src + strlen("http://");  
    else if (!strncmp(pA, "https://", strlen("https://")))  
        pA = src + strlen("https://");  
    pB = strchr(pA, '/');  
    if (pB) {  
        memcpy(web, pA, strlen(pA) - strlen(pB));  
        if (pB + 1) {  
            memcpy(file, pB + 1, strlen(pB) - 1);  
            file[strlen(pB) - 1] = 0;  
        }  
    } else  
        memcpy(web, pA, strlen(pA));  
    if (pB)  
        web[strlen(pA) - strlen(pB)] = 0;  
    else  
        web[strlen(pA)] = 0;  
    pA = strchr(web, ':');  
    if (pA)  
        *port = atoi(pA + 1);  
    else  
        *port = 443;  
}  
  
/************关于本文档******************************************** 
*filename: https-client.c 
*purpose: 演示HTTPS客户端编程方法 
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com) 
Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
*date time:2007-01-30 20:06 
*Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
* 但请遵循GPL 
*Thanks to:Google 
*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！ 
*********************************************************************/  
  
int main(int argc, char *argv[])  
{  
    int sockfd, ret;  
    char buffer[1024];  
    struct sockaddr_in server_addr;  
    struct hostent *host;  
    int portnumber, nbytes;  
    char host_addr[256];  
    char host_file[1024];  
    char local_file[256];  
    FILE *fp;  
    char request[1024];  
    int send, totalsend;  
    int i;  
    char *pt;  
    SSL *ssl;  
    SSL_CTX *ctx;  
  
    if (argc != 2) {  
        if (DEBUG)  
            fprintf(stderr, "Usage:%s webpage-address/a/n", argv[0]);  
        exit(1);  
    }  
    if (DEBUG)  
        printf("parameter.1 is: %s/n", argv[1]);  
  
    GetHost(argv[1], host_addr, host_file, &portnumber);        /*分析网址、端口、文件名等 */  
    if (DEBUG)  
        printf("webhost:%s/n", host_addr);  
    if (DEBUG)  
        printf("hostfile:%s/n", host_file);  
    if (DEBUG)  
        printf("portnumber:%d/n/n", portnumber);  
  
    if ((host = gethostbyname(host_addr)) == NULL) {        /*取得主机IP地址 */  
        if (DEBUG)  
            fprintf(stderr, "Gethostname error, %s/n", strerror(errno));  
        exit(1);  
    }  
  
    /* 客户程序开始建立 sockfd描述符 */  
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {        /*建立SOCKET连接 */  
        if (DEBUG)  
            fprintf(stderr, "Socket Error:%s/a/n", strerror(errno));  
        exit(1);  
    }  
  
    /* 客户程序填充服务端的资料 */  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_port = htons(portnumber);  
    server_addr.sin_addr = *((struct in_addr *) host->h_addr);  
  
    /* 客户程序发起连接请求 */  
    if (connect(sockfd, (struct sockaddr *) (&server_addr), sizeof(struct sockaddr)) == -1) {        /*连接网站 */  
        if (DEBUG)  
            fprintf(stderr, "Connect Error:%s/a/n", strerror(errno));  
        exit(1);  
    }  
  
    /* SSL初始化 */  
    SSL_library_init();  
    SSL_load_error_strings();  
    ctx = SSL_CTX_new(SSLv23_client_method());  
    if (ctx == NULL) {  
        ERR_print_errors_fp(stderr);  
        exit(1);  
    }  
  
    ssl = SSL_new(ctx);  
    if (ssl == NULL) {  
        ERR_print_errors_fp(stderr);  
        exit(1);  
    }  
  
    /* 把socket和SSL关联 */  
    ret = SSL_set_fd(ssl, sockfd);  
    if (ret == 0) {  
        ERR_print_errors_fp(stderr);  
        exit(1);  
    }  
  
    RAND_poll();  
    while (RAND_status() == 0) {  
        unsigned short rand_ret = rand() % 65536;  
        RAND_seed(&rand_ret, sizeof(rand_ret));  
    }  
  
    ret = SSL_connect(ssl);  
    if (ret != 1) {  
        ERR_print_errors_fp(stderr);  
        exit(1);  
    }  
  
    sprintf(request, "GET /%s HTTP/1.1/r/nAccept: */*/r/nAccept-Language: zh-cn/r/n/ 
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)/r/n/ 
Host: %s:%d/r/nConnection: Close/r/n/r/n", host_file, host_addr, 
            portnumber); 
    if (DEBUG) 
        printf("%s", request);        /*准备request，将要发送给主机 */  
  
    /*取得真实的文件名 */  
    if (host_file && *host_file)  
        pt = Rstrchr(host_file, '/');  
    else  
        pt = 0;  
  
    memset(local_file, 0, sizeof(local_file));  
    if (pt && *pt) {  
        if ((pt + 1) && *(pt + 1))  
            strcpy(local_file, pt + 1);  
        else  
            memcpy(local_file, host_file, strlen(host_file) - 1);  
    } else if (host_file && *host_file)  
        strcpy(local_file, host_file);  
    else  
        strcpy(local_file, "index.html");  
    if (DEBUG)  
        printf("local filename to write:%s/n/n", local_file);  
  
    /*发送https请求request */  
    send = 0;  
    totalsend = 0;  
    nbytes = strlen(request);  
    while (totalsend < nbytes) {  
        send = SSL_write(ssl, request + totalsend, nbytes - totalsend);  
        if (send == -1) {  
            if (DEBUG)  
                ERR_print_errors_fp(stderr);  
            exit(0);  
        }  
        totalsend += send;  
        if (DEBUG)  
            printf("%d bytes send OK!/n", totalsend);  
    }  
  
    fp = fopen("index.html", "a");  
    if (!fp) {  
        if (DEBUG)  
            printf("create file error! %s/n", strerror(errno));  
        return 0;  
    }  
    if (DEBUG)  
        printf("/nThe following is the response header:/n");  
    i = 0;  
    /* 连接成功了，接收https响应，response */  
    while ((nbytes = SSL_read(ssl, buffer, 1)) == 1) {  
        if (i < 4) {  
            if (buffer[0] == '/r' || buffer[0] == '/n')  
                i++;  
            else  
                i = 0;  
            if (DEBUG)  
                printf("%c", buffer[0]);        /*把https头信息打印在屏幕上 */  
        } else {  
            fwrite(buffer, 1, 1, fp);        /*将https主体信息写入文件 */  
            i++;  
            if (i % 1024 == 0)  
                fflush(fp);        /*每1K时存盘一次 */  
        }  
    }  
    fclose(fp);  
    /* 结束通讯 */  
    ret = SSL_shutdown(ssl);  
    if (ret != 1) {  
        ERR_print_errors_fp(stderr);  
        exit(1);  
    }  
    close(sockfd);  
    SSL_free(ssl);  
    SSL_CTX_free(ctx);  
    ERR_free_strings();  
    exit(0);  
}  

2.2层层封装的openssl编程。

这里BSD socket的基本操作，对上层是不可见的。而且openssl自己有对自己的底层操作进行了封装。

除此之外还需要了解BIO的概念。

BIO是openssl 对于io 类型的抽象封装，包括：内存、文件、日志、标准输入输出、socket、加/解密、摘要和ssl 通道等。

BIO分为两种：source/sink类型的BIO是数据源或输入数据源（我不知道sink该怎么翻译），例如，sokect BIO和文件BIO。而filter BIO就是把数据从一个BIO转换到另外一个BIO或应用接口，在转换过程中，这些数据可以不修改（如信息摘要BIO），也可以进行转换。

BIO链，可以预先设定好多个BIO之间的链接关系，当数据从source类型的BIO进来之后，数据自动再BIO链之间传递。这应该是BIO有吸引力的地方。比如三个BIO，mbio（内存类型），sbio（ssl类型），abio（accept类型），连成BIO链：mbio->sbio->abio。

那么对mbio的读操作实际上就包含了从accept接收数据、对加密数据ssl解密，最终把数据读到内存中的操作；对mbio的写操作实际上包含了对数据进行ssl加密，并把加密数据从socket发出去的操作。

BIO常用函数：

BIO * BIO_new(BIO_METHOD *type)：生成BIO

BIO_set(BIO *a,BIO_METHOD *type)：设置BIO

BIO_free(BIO *a)：删除BIO

BIO_free_all(BIO *a)：删除BIO链

BIO_read(BIO *b, void *buf, int len)

BIO_gets(BIO *b,char *buf, int size)

BIO_write(BIO *b, const void *buf, int len)

BIO_puts(BIO *b,const char *buf)

BIO * BIO_push(BIO *b,BIO *append)：该函数把参数中名为append的BIO附加到名为b的BIO上，并返回b。

BIO * BIO_pop(BIO *b)：为b的BIO从一个BIO链中移除并返回下一个BIO。

     代码示例（echo）：

     服务器端：

 
       [cpp] 
       view plaincopy
#include <stdio.h>  
#include <string.h>  
  
#include <openssl/bio.h>  
#include <openssl/ssl.h>  
#include <openssl/err.h>  
#include <unistd.h>  
  
#define SERVER_PEM "../digitCert/server.pem"  
#define SERVER_KRY "../digitCert/server.key"  
  
int password_callback(char *buf, int size, int rwflag, void *userdata)  
{  
    /* For the purposes of this demonstration, the password is "ibmdw" */  
  
    printf("*** Callback function called/n");  
    strcpy(buf,"123456");  
    return strlen(buf);  
}  
  
int main()  
{  
    SSL_CTX *ctx;  
    SSL *ssl;  
    BIO *sslbio, *acptbio, *out;  
    pid_t pid;  
    int len;  
    char buf[1024];  
  
    int (*callback)(char *, int, int, void *) = &password_callback;  
  
    printf("Secure Programming with the OpenSSL API, Part 4:/n");  
    printf("Serving it up in a secure manner/n/n");  
  
    SSL_library_init();  
    SSL_load_error_strings();  
    ERR_load_BIO_strings();  
    ERR_load_SSL_strings();  
    OpenSSL_add_all_algorithms();  
  
    printf("Attempting to create SSL context... ");  
    ctx = SSL_CTX_new(SSLv23_server_method());  
    if(ctx == NULL)  
    {  
        printf("Failed. Aborting./n");  
        return 0;  
    }  
  
    printf("/nLoading certificates.../n");  
    SSL_CTX_set_default_passwd_cb(ctx, callback);  
    if(!SSL_CTX_use_certificate_file(ctx, SERVER_PEM, SSL_FILETYPE_PEM))  
    {  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
    else printf("load server.csr successful!/n");  
    if((SSL_CTX_use_PrivateKey_file(ctx, SERVER_KRY, SSL_FILETYPE_PEM))<=0)  
    {  
        printf("use private key failed!/n/n");  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
  
    printf("Attempting to create BIO object... ");  
    sslbio = BIO_new_ssl(ctx, 0);//0 indicate using server mode  
    if(sslbio == NULL)  
    {  
        printf("Failed. Aborting./n");  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
  
    printf("/nAttempting to set up BIO for SSL.../n");  
    BIO_get_ssl(sslbio, &ssl);  
  
    printf("Waiting for incoming connection.../n");  
    /*Begin to listen the port*/  
    if(BIO_do_accept(acptbio) <= 0)  
    {  
        ERR_print_errors_fp(stdout);  
        SSL_CTX_free(ctx);  
        BIO_free_all(sslbio);  
        BIO_free_all(acptbio);  
        return 1;  
    }  
    while(1)  
    {  
        /*Waiting for a new connection to establish*/  
        if(BIO_do_accept(acptbio) <= 0)  
        {  
                ERR_print_errors_fp(stdout);  
                SSL_CTX_free(ctx);  
                BIO_free_all(sslbio);  
                BIO_free_all(acptbio);  
                return 1;  
        }  
        out = BIO_pop(acptbio);  
  
         if((pid=fork()))//parent process  
    {  
            BIO_free(out);  
    }  
    else  
    {  
            if(BIO_do_handshake(out) <= 0)  
            {  
                printf("Handshake failed./n");  
                ERR_print_errors_fp(stdout);  
                SSL_CTX_free(ctx);  
                BIO_free_all(sslbio);  
                BIO_free_all(acptbio);  
                return 1;  
            }  
            for(;;)  
            {  
                memset(buf,0,1023);  
                len = BIO_read(out,buf,1023);  
                                         switch(SSL_get_error(ssl,len))  
                {  
                    case SSL_ERROR_NONE:  
                        break;  
                    default:  
                        printf("Read Problem!/n");  
                        exit(0);  
                }  
                if(!strcmp(buf,"/r/n")||!strcmp(buf,"/n"))  
                    break;  
                if(buf[0]=='q')   
                       break;  
                BIO_write(out,buf,len);  
                printf("%s/n",buf);  
            }     
            BIO_free(out);  
            BIO_ssl_shutdown(sslbio);  
            exit(0);  
    }//end else  
    }  
    BIO_ssl_shutdown(sslbio);  
    BIO_free_all(sslbio);  
    BIO_free_all(acptbio);  
    SSL_CTX_free(ctx);  
}  

    客户端:

 
       [cpp] 
       view plaincopy
#include <openssl/ssl.h>  
#include <errno.h>  
#include <openssl/bio.h>  
#include <openssl/err.h>  
  
#include <stdio.h>  
#include <string.h>  
  
int main()  
{  
    BIO *sslbio;  
    SSL * ssl;  
    SSL_CTX * ctx;  
  
    int p;  
  
  
    /* Set up the library */  
    SSL_library_init();//一定要有，初始化ssl库  
    ERR_load_BIO_strings();  
    SSL_load_error_strings();  
    OpenSSL_add_all_algorithms();  
  
    /* Set up the SSL context */  
  
    ctx = SSL_CTX_new(SSLv23_method());  
  
    /* Load the trust store */  
  
    if(!SSL_CTX_load_verify_locations(ctx, "../digitCert/ca.crt",0))//读取CA根证书，用这个证书来验证对方的证书是否可信  
    {  
        fprintf(stderr, "Error loading trust store/n");  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
  
    /* Setup the connection */  
  
    sslbio = BIO_new_ssl_connect(ctx);//建立ssl类型的bio  
  
    /* Set the SSL_MODE_AUTO_RETRY flag */  
  
    BIO_get_ssl(sslbio, & ssl);//从已建立的ssl类型的bio sslbio中得到ssl变量  
    SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);//设置ssl的模式为SSL_MODE_AUTO_RETRY,使用这个选项进行设置，如果服务器突然希望进行一次新的握手，那么OpenSSL 可以在后台处理它。  
      
  
    /* Create and setup the connection */  
  
    BIO_set_conn_hostname(sslbio, "127.0.0.1:4433");  
  
    if(BIO_do_connect(sslbio) <= 0)//发起握手请求  
    {  
        fprintf(stderr, "Error attempting to connect/n");  
        ERR_print_errors_fp(stderr);  
        BIO_free_all(sslbio);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
    else printf("connent to server successful!/n");  
  
    /* Check the certificate */  
  
    if(SSL_get_verify_result(ssl) != X509_V_OK)//验证对方的证书是否是合法的（时间未过期，等等。。。）  
    {  
        fprintf(stderr, "Certificate verification error: %ld/n", SSL_get_verify_result(ssl));  
        BIO_free_all(sslbio);  
        SSL_CTX_free(ctx);  
        return 0;  
    }  
    else printf("verify server cert successful/n");  
  
    char buf[1024];  
    for(;;)  
    {  
        printf("/ninput:");  
            scanf("%s",&buf[0]);  
        BIO_write(sslbio,buf,strlen(buf));  
        p = BIO_read(sslbio, buf, 1023);  
        if(p <= 0) break;  
        buf[p] = 0;  
        printf("%s/n", buf);  
        memset(buf,0,1024);  
    }  
  
    /* Close the connection and free the context */  
    BIO_ssl_shutdown(sslbio);  
    BIO_free_all(sslbio);  
    SSL_CTX_free(ctx);  
    return 0;  
}  

文章标签：编程 ssl server callback file socket

个人分类：网络协议 linux 编程

想对作者说点什么？我来说一句

ben_lbj 2016-06-30 15:06:59 #4楼

感谢分享！！关注

pingd 2015-08-06 16:29:41 #3楼

受益了

swtheking 2013-08-27 16:23:20 #2楼

能给我一份源码么？亲

swtheking 2013-08-27 15:41:11 #1楼

你的https服务器能和正常的网页交互么

查看 4 条热评

个人资料

sealyao

关注

原创

粉丝

241

喜欢

173

等级：

访问：

69万+

积分：

5080

排名：

7365

个人分类

展开

联系我们

请扫描二维码联系客服

400-660-0108

百度提供支持

0
写评论
收藏
微信
微博
QQ

baidu_32526299

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
openssl 编程。证书制作

首页博客学院下载GitChatTinyMind论坛问答商城VIP活动写博客发Chat登录注册么刚的专栏RSS订阅原openssl证书制作及编程2010年07月29日 19:56:00阅读数：5990一、openssl证书制作：1、创建目录./demoCA/ ./demoCA/newcerts/，创建文件 ./demoCA/index.txt ./demoCA/serial。2、执行echo 01 ...
复制链接

扫一扫