OC网络学习25：OpenSSL探索

张建 lol
  2023-08-03 16:34:02 2023-08-03 16:34 Created   2023-08-12 16:48:01 2023-08-12 16:48 Updated      

Openssl 之 SSL

  1. 什么是SSL

  • SSL(Secure Sockets Layer 安全套接字协议)，及其继任者 安全传输层协议（Transport Layer Security，TLS） 是为网络通信提供安全及数据完整性的一种安全协议。TLS与SSL在传输层与应用层之间对网络连接进行加密，它最早为Netscape所研发，用以保障在Internet上数据传输的安全，利用数据加密(Encryption)技术，可确保数据在网络上的传输过程中不会被截取及窃听。

  • SSL协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持。

  1. SSL协议分层

SSL协议可分为两层：

  • SSL记录协议（SSL Record Protocol）—— 它建立在可靠的传输协议（如TCP）之上，为高层协议提供数据封装、压缩、加密等基本功能的支持。

  • SSL握手协议（SSL Handshake Protocol）—— 它建立在SSL记录协议之上，用于在实际的数据传输开始前，通讯双方进行身份认证、协商加密算法、交换加密密钥等。

  1. SSL提供的服务

SSL提供的服务：

  • 认证用户和服务器，确保数据发送到正确的客户机和服务器；
  • 加密数据以防止数据中途被窃取；
  • 维护数据的完整性，确保数据在传输过程中不被改变。

SSL开发流程

  1. 开发流程图

由图可知：

无论是服务端还是客户端，进行一次完整的SSL通讯，大致可以抽像为以下几个步骤：

1）初使化SSL环境。
2）创建SSL上下文。
3）配置SSL上下文证书及公钥信息。
4）创建SSL上下文。
5）创建TCP通讯端口。
6）建立SSL和TCP通讯端口的关联。
7）执行SSL握手。
8）执行SSL数据读写交互。
9）关闭SSL连接。
10）关闭TCP通讯端口。
11）释放SSL上下文。

  1. SSL服务端接口调用流程图

  1. SSL客户端接口调用流程图

主要接口：

SSL接口的主要头文件在ssl中。我们根据SSL通讯的流程摘录如下：

  1. 初使化SSL环境。
1
2
3
4
5
6
7
通常用得比较多的是这三个函数：
// 初始化SSL库
SSL_library_init()
// 加载所有SSL算法
OpenSSL_add_ssl_algorithms()
// 载入所有SSL错误消息
SSL_load_error_strings()

在1.1.1版本的定义中是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# if OPENSSL_API_COMPAT < 0x10100000L
#  define SSL_library_init() OPENSSL_init_ssl(0, NULL)
# endif

# if OPENSSL_API_COMPAT < 0x10100000L
#  define SSL_load_error_strings() \
    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS \
                     | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
# endif

# if OPENSSL_API_COMPAT < 0x10100000L
#  define OpenSSL_add_ssl_algorithms()   SSL_library_init()
#  define SSLeay_add_ssl_algorithms()    SSL_library_init()
# endif

int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);

可以看到，上面图示中的 OpenSSL_add_ssl_algorithms() 这一步是多余的，通常初使化只需要调用这两个就可以了：

1
2
SSL_library_init()
SSL_load_error_strings()

在初使化过程中，SSL_library_init() 注册了所有在SSL APIs中的 加密算法和哈希算法，SSL_load_error_strings() 则加载了所有的 错误描述字符串。

  1. 创建SSL上下文
1
SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth);

这个函数用于 创建SSL上下文，其参数 SSL_METHOD 用于传入SSL的抽象方法集合。

对于每个 SSL/TSL 来说，有三种APIs可以用来创建一个 SSL_METHOD：

一个可以用于服务端和客户端，一个只能用于服务端，另外一个只能由于客户端。定义如下：

1
2
3
4
5
6
7
const SSL_METHOD *TLS_method(void);
const SSL_METHOD *TLS_server_method(void);
const SSL_METHOD *TLS_client_method(void);

#define SSLv23_method           TLS_method
#define SSLv23_server_method    TLS_server_method
#define SSLv23_client_method    TLS_client_method
  1. 设置SSL上下文的算法套件信息
1
int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str);

成功返回1，失败返回0。

可用的算法如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
EDH-RSA-DES-CBC3-SHA
EDH-DSS-DES-CBC3-SHA
DES-CBC3-SHA
DHE-DSS-RC4-SHA
IDEA-CBC-SHA
RC4-SHA
RC4-MD5
EXP1024-DHE-DSS-RC4-SHA
EXP1024-RC4-SHA
EXP1024-DHE-DSS-DES-CBC-SHA
EXP1024-DES-CBC-SHA
EXP1024-RC2-CBC-MD5
EXP1024-RC4-MD5
EDH-RSA-DES-CBC-SHA
EDH-DSS-DES-CBC-SHA
DES-CBC-SHA
EXP-EDH-RSA-DES-CBC-SHA
EXP-EDH-DSS-DES-CBC-SHA
EXP-DES-CBC-SHA
EXP-RC2-CBC-MD5
EXP-RC4-MD5

这些算法按一定 优先级排列,如果不作任何指定，将选用 DES-CBC3-SHA，用SSL_CTX_set_cipher_list 可以指定自己希望用的算法(实际上只是 提高其优先级,是否能使用还要看对方是否支持)。

  1. 配置SSL上下文证书及公钥信息。
1
2
3
int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);

int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);

这两个函数用于 加载私钥和证书文件。

成功返回1，失败返回0。

其中，type的取值：

1
2
3
4
5
# define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1
# define SSL_FILETYPE_PEM        X509_FILETYPE_PEM
即
# define X509_FILETYPE_PEM       1
# define X509_FILETYPE_ASN1      2

也可以直接使用 二进制结构和ASN1序列化 的内存数据：

1
2
3
4
int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, long len);
int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d);

int SSL_CTX_check_private_key(const SSL_CTX *ctx); 在完成 私钥和证书 加载后，这个函数由于检查二者是否匹配。成功返回1，失败返回0。

  1. 创建SSL上下文
1
SSL *SSL_new(SSL_CTX *ctx);

创建SSL结构，SSL的连接信息都保存在SSL结构中。

新的SSL结构会从SSL_CTX结构中继承包括，连接类型、选项、验证方式以及超时。

  1. 创建TCP通讯端口。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#pragma mark -- Socket连接服务端
- (void)connectToHost:(NSString *)host onPort:(int)port {
    _host = host;
    _port = port;
    
    if (!host || !port) {
        [self closeWithError:[self otherError:@"host/port error"]];
        return;
    }
    
    /*
      1.初始化socket
     a.参数domain指明通信域，如PF_UNIX(unix域)，PF_INET(IPv4)，PF_INET6(IPv6)等
     b.type 指明通信类型，最常用的如SOCK_STREAM(面向连接可靠方式，  比如TCP)、
        SOCK_DGRAM(非面向连接的非可靠方式，比如UDP)等。  SOCK_STREAM 是数据流,一般是tcp/ip协议的编程,SOCK_DGRAM分是数据抱,是udp协议网络编程。
     c.参数protocol指定需要使用的协议。虽然可以对同一个协议  家族(protocol family)
        (或者说通信域(domain))指定不同的协议  参数，
        但是通常只有一个。对于TCP参数可指定为IPPROTO_TCP,对于  UDP可以用IPPROTO_UDP。你不必显式制定这个参数，使用0则根据前两个参数使用默认的协议
     */
    _socketFD = socket(PF_INET, SOCK_STREAM, 0);
    if (_socketFD == -1) {
        [self closeWithError:[self otherError:@"socket error"]];
        return;
    }
    
    /* 2.向服务器发送socket连接请求 */
    struct sockaddr_in connectAddr;
    unsigned long ulIPV4 = [self DnsToIP:[host UTF8String]];
    connectAddr.sin_family       = PF_INET;
    connectAddr.sin_port         = htons(port);
    connectAddr.sin_addr.s_addr  = (in_addr_t)(ulIPV4);
    memset(&(connectAddr.sin_zero),'\0',8);
    // 连接（0 连接成功，-1 连接失败）
    int result = connect(_socketFD, (struct sockaddr*)&connectAddr, sizeof(connectAddr));
    if (result == 0) { // 连接成功
        [self didConnect];
    } else { // 连接失败
        [self closeWithError:[self otherError:@"connect error"]];
    }
}
  1. 建立SSL和TCP通讯端口的关联
1
2
// 成功返回1，失败返回0。
int SSL_set_fd(SSL *s, int fd);

或：也可以直接使用BIO代替:

1
2
BIO* bio = BIO_new_socket(socket, BIO_NOCLOSE);
SSL_set_bio(ssl, bio, bio);
  1. 执行SSL握手

SSL握手过程是一个复杂过程，涉及到重要的 加密秘钥交换。

但是握手过程可以通过 服务端调用SSL_accept() 和 客户端调用SSL_connect() 完成。

1
2
3
4
5
// 成功返回1，失败返回 <=0
int SSL_accept(SSL *ssl);

// 成功返回1，失败返回 <=0
int SSL_connect(SSL *ssl);

这两个函数是可以重复调用的，这个特性在非阻塞模式下尤为明显。

此外，在 握手完成 后，可通过调用 SSL_get_peer_certificate 来 获取对端的证书:

1
X509 *SSL_get_peer_certificate(const SSL *s);

如果对方存在证书，就可以调用X509的相关函数提取证书的身份信息，比如：

1
X509_NAME *X509_get_subject_name(X509 *a);
  1. 执行SSL数据读写交互

在SSL握手完成后，数据就可以通过已经建立好的连接安全的发送了。

不要再使用send、recv函数，而是要使用 SSL_write 和 SSL_read 。

1
2
int SSL_read(SSL *ssl, void *buf, int num);
int SSL_write(SSL *ssl, const void *buf, int num);

与send、recv用法相似。

成功返回发送或接收的字节数，失败返回 <=0。

当返回值 <0（通常为-1）时，应检查错误码，尤其是在非阻塞模式时。

  • 错误码可使用 SSL_get_error() 函数获取，其定义为：
1
int SSL_get_error(const SSL *s, int ret_code);
  1. 关闭SSL连接。

当关闭SSL连接时，SSL客户端和服务端需要发送 close_notify 消息，通知对端SSL将要关闭了，调用 SSL_shutdown 函数来发送 close_notify 消息。

1
2
// 成功返回1，失败返回 <=0
int SSL_shutdown(SSL *s);

关闭过包含以下两个步骤：

1）发送一个 close_notify 关闭告警。
2）从对端接收一个 close_notify 的关闭消息。

  • 发起关闭的客户端或者服务端可以调用 SSL_shutdown 一次或者两次。
  • 如果调用了两次，一次调用用于发送 close_notify 消息，另外一次用于响应对端的。
  • 如果只调用一次，发起关闭一端将不会等待对端的响应(发起关闭的一端不需要等待对端的关闭响应，一旦收到对端关闭消息就要马上发送关闭响应。
  1. 关于TCP通讯端口。
1
2
3
4
if(_socketFD > 0){
    close(_socketFD);
    _socketFD = 0;
}
  1. 释放SSL上下文。
1
2
void SSL_free(SSL *ssl);
void SSL_CTX_free(SSL_CTX *);

使用举例

  1. 阻塞模式用法
  • 服务端代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define SSL_print_error_and_freectx() \
    ERR_print_errors_fp(stdout); \
    SSL_CTX_free(ctx);

int listenLocal(unsigned short uPort)
{
    int sockS = socket(AF_INET, SOCK_STREAM, 0);
    if (sockS < 0)
    {
        printf("socket() error! \n");
        return -1;
    }

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(uPort);

    int ret = bind(sockS, (struct sockaddr*)&sin, sizeof(sin));
    if (ret < 0)
    {
        printf("bind() error! \n");
        close(sockS);
        return -1;
    }

    listen(sockS, 50);

    return sockS;
}

int main(int argc, char* argv[])
{
    SSL_library_init();
    SSL_load_error_strings();

    SSL_CTX* ctx = SSL_CTX_new( SSLv23_server_method() );
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stdout);
        return -1;
    }

    int ret = SSL_CTX_use_certificate_file(ctx, "test.crt", SSL_FILETYPE_PEM);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    ret = SSL_CTX_use_PrivateKey_file(ctx, "test.key", SSL_FILETYPE_PEM);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    ret = SSL_CTX_check_private_key(ctx);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    int sockS = listenLocal(9999);
    if (sockS < 0)
    {
        SSL_CTX_free(ctx);
        return -1;
    }

    while (true)
    {
        struct sockaddr_in sinfrom;
        socklen_t sinfromlen = sizeof(sinfrom);
        int sockC = accept(sockS, (struct sockaddr*)&sinfrom, &sinfromlen);
        if (sockC < 0)
        {
            printf("accept() error! \n");
            break;
        }

        printf("accpet connect:[%d - %s:%d] \n", sockC, inet_ntoa(sinfrom.sin_addr), ntohs(sinfrom.sin_port));

        SSL* ssl = SSL_new(ctx);
        SSL_set_fd(ssl, sockC);

        do
        {
            ret = SSL_accept(ssl);
            if (ret != 1)
            {
                printf("SSL handshake failed! \n");
                break;
            }
            printf("SSL handshake success! \n");

            SSL_write(ssl, "hello", 5);

            while (true)
            {
                char sBuf[1024] = {0};
                int bytesin = SSL_read(ssl, sBuf, sizeof(sBuf)-1);
                if (bytesin <= 0)
                {
                    printf("error or disconnect! \n");
                    break;
                }

                printf("read:[%s] \n", sBuf);
            }

            SSL_shutdown(ssl);
        } while(0);

        SSL_free(ssl);
        close(sockC);
    }

    close(sockS);
    SSL_CTX_free(ctx);

    return 0;
}
  • 客户端代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int connectPeer(const char* sIp, unsigned short uPort)
{
    int sockC = socket(AF_INET, SOCK_STREAM, 0);
    if (sockC < 0)
    {
        printf("socket() errror! \n");
        return -1;
    }

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = inet_addr(sIp);
    sin.sin_port = htons(uPort);

    int ret = connect(sockC, (struct sockaddr*)&sin, sizeof(sin));
    if (ret < 0)
    {
        printf("connect() failed! \n");
        close(sockC);
        return -1;
    }

    return sockC;
}

void showCert(SSL* ssl)
{
    X509* x509 = SSL_get_peer_certificate(ssl);

    if (x509)
    {
        const char* subjectname = X509_NAME_oneline(X509_get_subject_name(x509), 0, 0);
        printf("subject name:[%s] \n", subjectname);

        const char* issuername = X509_NAME_oneline(X509_get_issuer_name(x509), 0, 0);
        printf("issuer name:[%s] \n", issuername);
        
        X509_free(x509);
    }
}

int main(int argc, char* argv[])
{
    SSL_library_init();
    SSL_load_error_strings();

    SSL_CTX* ctx = SSL_CTX_new( SSLv23_client_method() );
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stdout);
        SSL_CTX_free(ctx);
        return -1;
    }

    int sockC = connectPeer("127.0.0.1", 9999);
    if (sockC < 0)
    {
        SSL_CTX_free(ctx);
        return -1;
    }

    SSL* ssl = SSL_new(ctx);
    SSL_set_fd(ssl, sockC);

    do
    {
        int ret = SSL_connect(ssl);
        if (ret != 1)
        {
            printf("SSL handshake failed! \n");
            break;
        }
        printf("SSL handshake success! \n");

        showCert(ssl);

        char sBuf[1024] = {0};
        int bytesin = SSL_read(ssl, sBuf, sizeof(sBuf)-1);
        if (bytesin <= 0)
        {
            printf("disconnect! \n");
            SSL_shutdown(ssl);
            break;
        }

        printf("read:[%s] \n", sBuf);

        for (int i = 0; i < 3; ++i)
        {
            SSL_write(ssl, "hello", 5);
            sleep(1);
        }

        SSL_shutdown(ssl);
    } while (0);

    SSL_free(ssl);
    close(sockC);

    SSL_CTX_free(ctx);

    return 0;
}
  1. 非阻塞模式用法：

对非阻塞套接字来说，SSL_read() 和 SSL_write() 的调用通常会返回-1，这并不是真正表示收发失败了，大多可能的原因是套接字的缓冲不可用，我们需要稍后进行尝试。只不过，在非阻塞模式下，采用主动尝试的方法通常都不可取，正式的场合应该使用异步事件模型。

下面的代码出于简单性，暂时采用稍后尝试的方法。代码示例如下：

  • 服务端代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define SSL_print_error_and_freectx() \
    ERR_print_errors_fp(stdout); \
    SSL_CTX_free(ctx);

int listenLocal(unsigned short uPort)
{
    int sockS = socket(AF_INET, SOCK_STREAM, 0);
    if (sockS < 0)
    {
        printf("socket() error! \n");
        return -1;
    }

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(uPort);

    int ret = bind(sockS, (struct sockaddr*)&sin, sizeof(sin));
    if (ret < 0)
    {
        printf("bind() error! \n");
        close(sockS);
        return -1;
    }

    listen(sockS, 50);

    return sockS;
}

int main(int argc, char* argv[])
{
    SSL_library_init();
    SSL_load_error_strings();

    SSL_CTX* ctx = SSL_CTX_new( SSLv23_server_method() );
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stdout);
        return -1;
    }

    int ret = SSL_CTX_use_certificate_file(ctx, "test.crt", SSL_FILETYPE_PEM);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    ret = SSL_CTX_use_PrivateKey_file(ctx, "test.key", SSL_FILETYPE_PEM);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    ret = SSL_CTX_check_private_key(ctx);
    if (ret != 1)
    {
        SSL_print_error_and_freectx();
        return -1;
    }

    int sockS = listenLocal(9999);
    if (sockS < 0)
    {
        SSL_CTX_free(ctx);
        return -1;
    }

    while (true)
    {
        struct sockaddr_in sinfrom;
        socklen_t sinfromlen = sizeof(sinfrom);
        int sockC = accept(sockS, (struct sockaddr*)&sinfrom, &sinfromlen);
        if (sockC < 0)
        {
            printf("accept() error! \n");
            break;
        }

        printf("accpet connect:[%d - %s:%d] \n", sockC, inet_ntoa(sinfrom.sin_addr), ntohs(sinfrom.sin_port));

        fcntl(sockC, F_SETFL, fcntl(sockC, F_GETFL) | O_NONBLOCK);

        SSL* ssl = SSL_new(ctx);
        SSL_set_fd(ssl, sockC);

        do
        {
            bool bHandShake = false;
            while (true)
            {
                ret = SSL_accept(ssl);
                printf("SSL_accept() ret:[%d] \n", ret);
                if (ret != 1)
                {
                    int err = SSL_get_error(ssl, ret);
                    if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
                    {
                        printf("want read or write... \n");
                        usleep(1000);
                        continue;
                    }

                    break;
                }

                bHandShake = true;
                break;
            }

            if (!bHandShake)
            {
                printf("SSL handshake failed! \n");
                break;
            }

            printf("SSL handshake success! \n");

            SSL_write(ssl, "hello", 5);

            while (true)
            {
                char sBuf[1024] = {0};
                int bytesin = SSL_read(ssl, sBuf, sizeof(sBuf)-1);
                if (bytesin < 0)
                {
                    int err = SSL_get_error(ssl, -1);
                    if (err == SSL_ERROR_WANT_READ)
                    {
                        printf("want read... \n");
                        usleep(100000);
                        continue;
                    }

                    printf("read error! \n");
                    break;
                }

                if (bytesin == 0)
                {
                    printf("disconnect! \n");
                    break;
                }

                printf("read:[%s] \n", sBuf);
            }

            SSL_shutdown(ssl);
        } while(0);

        SSL_free(ssl);
        close(sockC);
    }

    close(sockS);
    SSL_CTX_free(ctx);

    return 0;
}
  • 客户端代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int connectPeer(const char* sIp, unsigned short uPort)
{
    int sockC = socket(AF_INET, SOCK_STREAM, 0);
    if (sockC < 0)
    {
        printf("socket() errror! \n");
        return -1;
    }

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = inet_addr(sIp);
    sin.sin_port = htons(uPort);

    int ret = connect(sockC, (struct sockaddr*)&sin, sizeof(sin));
    if (ret < 0)
    {
        printf("connect() failed! \n");
        close(sockC);
        return -1;
    }

    return sockC;
}

void showCert(SSL* ssl)
{
    X509* x509 = SSL_get_peer_certificate(ssl);

    if (x509)
    {
        const char* subjectname = X509_NAME_oneline(X509_get_subject_name(x509), 0, 0);
        printf("subject name:[%s] \n", subjectname);

        const char* issuername = X509_NAME_oneline(X509_get_issuer_name(x509), 0, 0);
        printf("issuer name:[%s] \n", issuername);

        X509_free(x509);
    }
}

int main(int argc, char* argv[])
{
    SSL_library_init();
    SSL_load_error_strings();

    SSL_CTX* ctx = SSL_CTX_new( SSLv23_client_method() );
    if (ctx == NULL)
    {
        ERR_print_errors_fp(stdout);
        SSL_CTX_free(ctx);
        return -1;
    }

    int sockC = connectPeer("127.0.0.1", 9999);
    if (sockC < 0)
    {
        SSL_CTX_free(ctx);
        return -1;
    }

    fcntl(sockC, F_SETFL, fcntl(sockC, F_GETFL) | O_NONBLOCK);

    SSL* ssl = SSL_new(ctx);
    SSL_set_fd(ssl, sockC);

    do
    {
        bool bHandShake = false;
        while (true)
        {
            int ret = SSL_connect(ssl);
            printf("SSL_connect() ret:[%d] \n", ret);
            if (ret != 1)
            {
                int err = SSL_get_error(ssl, -1);
                if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE)
                {
                    printf("want read or write... \n");
                    usleep(1000);
                    continue;
                }

                break;
            }

            bHandShake = true;
            break;
        }

        if (!bHandShake)
        {
            printf("SSL handshake failed! \n");
            break;
        }

        printf("SSL handshake success! \n");

        showCert(ssl);

        bool bShutDown = false;
        while (true)
        {
            char sBuf[1024] = {0};
            int bytesin = SSL_read(ssl, sBuf, sizeof(sBuf)-1);
            if (bytesin < 0)
            {
                int err = SSL_get_error(ssl, -1);
                if (err == SSL_ERROR_WANT_READ)
                {
                    printf("want read... \n");
                    usleep(100000);
                    continue;
                }

                printf("read error! \n");
                SSL_shutdown(ssl);
                bShutDown = true;
                break;
            }

            if (bytesin == 0)
            {
                printf("disconnect! \n");
                SSL_shutdown(ssl);
                bShutDown = true;
                break;
            }

            printf("read:[%s] \n", sBuf);
            break;
        }

        if (bShutDown)
            break;

        for (int i = 0; i < 3; ++i)
        {
            SSL_write(ssl, "hello", 5);
            sleep(1);
        }

        SSL_shutdown(ssl);
    } while (0);

    SSL_free(ssl);
    close(sockC);

    SSL_CTX_free(ctx);

    return 0;
}

实际项目中的应用封装

我在做国密双向认证的时候使用了：

  1. GMSocket.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//
//  JITGMSocket.h
//  GMTest
//
//  Created by JITPlatform001 on 2021/10/29.
//

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@class JITPrivCertInfo;
@class JITSSLInfo;

@protocol JITSocketDelegate;

@interface JITGMSocket : NSObject

+ (instancetype)new NS_UNAVAILABLE;
- (instancetype)init NS_UNAVAILABLE;

/**
 【delegate：必传】
 */
- (instancetype)initWithDelegate:(id<JITSocketDelegate>)delegate;

- (void)connectToHost:(NSString *)host onPort:(int)port;
/**
 beOneWay：是否为单向认证
 sslInfo：双向认证用到的证书
 */
- (void)startSSL:(BOOL)beOneWay
      andSSLInfo:(JITSSLInfo *)sslInfo;
- (void)disconnect;

- (int)writeData:(char *)buff
          andLen:(int)len
      andTimeOut:(int)timeout;

- (int)readData:(char *)buff
         andLen:(int)len
     andTimeOut:(int)timeout;

@end

@protocol JITSocketDelegate <NSObject>

@required
- (void)didConnectSocket:(JITGMSocket *)socket host:(NSString *)host port:(int)port;
- (void)didDisconnectSocket:(JITGMSocket *)socket error:(NSError *)error;

- (void)didWriteData:(JITGMSocket *)socket;
- (void)didReadSocket:(JITGMSocket *)socket data:(NSData *)data;
- (void)didWriteOrRead:(JITGMSocket *)socket
                 error:(NSError *)error;

- (void)didSecure:(JITGMSocket *)socket error:(NSError *)error;

@end


@interface JITSSLInfo : NSObject
@property (assign, nonatomic) int ciperSuite;   // 加密套件 0:ECC-SM4-SM3 非0:ECDHE-SM4-SM3
@property (strong, nonatomic) JITPrivCertInfo *privCertInfo;    // 签名加密私钥
@property (strong, nonatomic) NSArray *caInfo;  // 根证
@end

@interface JITPrivCertInfo : NSObject
@property (strong, nonatomic) NSString *signCertPath;   // 签名证书
@property (strong, nonatomic) NSString *signPrivPath;   // 签名私钥
@property (strong, nonatomic) NSString *encCertPath;    // 加密证书
@property (strong, nonatomic) NSString *encPrivPath;    // 加密私钥
@end

NS_ASSUME_NONNULL_END

  1. GMSocket.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
//
//  JITGMSocket.m
//  GMTest
//
//  Created by JITPlatform001 on 2021/10/29.
//

#import "JITGMSocket.h"

#include <netdb.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include <openssl/ossl_typ.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#define SSL_ERROR_WANT_HSM_RESULT 10

/**
 是否单向认证
 */
BOOL G_beOneWay = YES;

@interface JITGMSocket()
{
    __weak id<JITSocketDelegate> _delegate;
    
    int _socketFD;
    NSString *_host;
    int _port;
    
    SSL *m_ssl;
    SSL_CTX *m_ctx;
    
    BOOL _isSecure;
}

@property (retain, readonly) NSMutableData *sslWriteData;
@property (retain, readonly) NSMutableData *sslReadData;

@end

@implementation JITGMSocket

#pragma mark -- Life Cycle
- (instancetype)initWithDelegate:(id<JITSocketDelegate>)aDelegate {
    
    if (!aDelegate)
        return nil;
    
    self = [super init];
    if(self) {
        _delegate = aDelegate;
        
        _sslWriteData = [[NSMutableData alloc] init];
        _sslReadData = [[NSMutableData alloc] init];
    }
    
    return self;
}

- (void)dealloc {
    NSLog(@"%s",__func__);
    
    [self disconnect];
}

#pragma mark -- Socket连接服务端
- (void)connectToHost:(NSString *)host onPort:(int)port {
    _host = host;
    _port = port;
    
    if (!host || !port) {
        [self closeWithError:[self otherError:@"host/port error"]];
        return;
    }
    
    /*
      1.初始化socket
     a.参数domain指明通信域，如PF_UNIX(unix域)，PF_INET(IPv4)，PF_INET6(IPv6)等
     b.type 指明通信类型，最常用的如SOCK_STREAM(面向连接可靠方式，  比如TCP)、
        SOCK_DGRAM(非面向连接的非可靠方式，比如UDP)等。  SOCK_STREAM 是数据流,一般是tcp/ip协议的编程,SOCK_DGRAM分是数据抱,是udp协议网络编程。
     c.参数protocol指定需要使用的协议。虽然可以对同一个协议  家族(protocol family)
        (或者说通信域(domain))指定不同的协议  参数，
        但是通常只有一个。对于TCP参数可指定为IPPROTO_TCP,对于  UDP可以用IPPROTO_UDP。你不必显式制定这个参数，使用0则根据前两个参数使用默认的协议
     */
    _socketFD = socket(PF_INET, SOCK_STREAM, 0);
    if (_socketFD == -1) {
        [self closeWithError:[self otherError:@"socket error"]];
        return;
    }
    
    /* 2.向服务器发送socket连接请求 */
    struct sockaddr_in connectAddr;
    unsigned long ulIPV4 = [self DnsToIP:[host UTF8String]];
    connectAddr.sin_family       = PF_INET;
    connectAddr.sin_port         = htons(port);
    connectAddr.sin_addr.s_addr  = (in_addr_t)(ulIPV4);
    memset(&(connectAddr.sin_zero),'\0',8);
    // 连接（0 连接成功，-1 连接失败）
    int result = connect(_socketFD, (struct sockaddr*)&connectAddr, sizeof(connectAddr));
    if (result == 0) { // 连接成功
        [self didConnect];
    } else { // 连接失败
        [self closeWithError:[self otherError:@"connect error"]];
    }
}
// 域名转ip地址
- (unsigned long)DnsToIP:(const char *)pszDomainName{
    unsigned long dwIP = 0;
    int nAdapter = 0;
    struct sockaddr_in sAddr;
    unsigned long  dwError = -1;

    dwIP = inet_addr(pszDomainName);
    if( dwIP!=INADDR_NONE && dwIP!=INADDR_ANY )
    {
        return dwIP;
    }

    struct hostent *pHostEnt = gethostbyname(pszDomainName);
    if( pHostEnt!=NULL )
    {
        while (pHostEnt->h_addr_list[nAdapter] )
        {
            memcpy(&sAddr.sin_addr.s_addr, pHostEnt->h_addr_list[nAdapter], pHostEnt->h_length);
            dwIP = sAddr.sin_addr.s_addr;
            nAdapter++;
            return dwIP;
        }
    }

    struct addrinfo* pstAddrInfo = NULL;
    struct addrinfo* ptr = NULL;
    struct addrinfo stHints ;
    memset(&stHints, 0, sizeof(stHints));

    stHints.ai_family = AF_INET;
    stHints.ai_socktype = SOCK_STREAM;
    stHints.ai_protocol = IPPROTO_TCP;
    getaddrinfo(pszDomainName, NULL, &stHints, &pstAddrInfo);
    dwError = 0;
    if (0 == dwError)
    {
        for (ptr = pstAddrInfo; ptr != NULL ;ptr = ptr->ai_next)
        {
            if (AF_INET == ptr->ai_family && SOCK_STREAM == ptr->ai_socktype && IPPROTO_TCP == ptr->ai_protocol)
            {
                struct sockaddr_in *pstAddr_in = (struct sockaddr_in *)ptr->ai_addr;
                dwIP = pstAddr_in->sin_addr.s_addr;
                dwError = 0;
                break;
            }
        }
    }
    freeaddrinfo(pstAddrInfo);

    if (dwError == 0) {
        return dwIP;
    }
    return -1;
}
// 已经连接
- (void)didConnect {
    if (_delegate && [_delegate respondsToSelector:@selector(didConnectSocket:host:port:)]) {
        NSLog(@"didSecure");
        [_delegate didConnectSocket:self host:_host port:_port];
    }
}

#pragma mark - 显示证书
- (void)showCert{
    X509 * cert;
    char * line;
    
    cert = SSL_get_peer_certificate(m_ssl);
    // 如果验证不通过，那么程序抛出异常终止连接
    if (SSL_get_verify_result(m_ssl) == X509_V_OK) {
        NSLog(@"证书验证通过\n");
        if (cert != NULL) {
            NSLog(@"数字证书信息:\n");
            line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
            NSLog(@"证书:%s\n",line);
            free(line);
            
            // 颁发者
            line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
            NSLog(@"颁发者:%s\n",line);
            free(line);
            
            // 释放
            X509_free(cert);
        }else {
            NSLog(@"无证书信息!\n");
        }
    }else {
        NSLog(@"证书验证不通过\n");
    }
}

#pragma mark -- STL/SSL 加密通信
- (void)startSSL:(BOOL)beOneWay andSSLInfo:(JITSSLInfo *)sslInfo{
    if (!_delegate) {
        return;
    }
    
    // 1.SSL初始化
    // SSL 库初始化
    SSL_library_init();
    // 载入所有 SSL 算法
    OpenSSL_add_ssl_algorithms();
    // 载入所有 SSL 错误消息
    SSL_load_error_strings();
    
    /* 2.初始化SSL上下文环境(调用成功返回SSL_CTX结构体指针， 否则返回NULL)
     a.SSL_METHOD:代表使用的协议
     SSLv2_server_method()：V2标准
     SSLv3_server_method()：V3标准
     SSLv23_server_method(): V2和V3标准
     CNTLS_client_method(): 国密标准
     */
    if (!m_ctx) {
        m_ctx = SSL_CTX_new((const SSL_METHOD *)CNTLS_client_method());
    }
        
    /* 3.设置SSL通信方式 */
    G_beOneWay = beOneWay;
    // 如果是 单向认证(只需要验证SSL服务器身份，不需要验证SSL客户端身份。)
    if (G_beOneWay) {
        // 配置启不启用双向认证（SSL_VERIFY_NONE 不启用,SSL_VERIFY_PEER 启用）
        SSL_CTX_set_verify(m_ctx, SSL_VERIFY_NONE, NULL);
    }
    // 如果是 双向认证(要求服务器和客户端双方都有证书，客户端需要校验服务端，服务端也需要校验客户端。)
    else {
        if (!sslInfo || !sslInfo.privCertInfo || !sslInfo.caInfo) {
            if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                [_delegate didSecure:self
                               error:[self sslError:@"sslInfo is null"]];
            }
            return;
        }
        
        /* 如果传输被阻塞，永远不要用重试来打扰应用程序:
           SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
         */

        /* 4.设置信任根证书，加载CA证书 */
        NSArray *caArray = sslInfo.caInfo;
        for (NSString *path in caArray) {
            if (!path) {
                continue;
            }
            NSLog(@"SSL_CTX_load_verify_locations start!");

            // SSL_CTX_load_verify_locations:加载信任的根证书
            if (!SSL_CTX_load_verify_locations(m_ctx, (const char *)[path UTF8String], NULL)){
                NSLog(@"SSL_CTX_load_verify_locations error!");
                ERR_print_errors_fp(stderr);
                if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self
                                   error:[self sslError:@"SSL_CTX_load_verify_locations Error"]];
                }
                return;
            }
            NSLog(@"SSL_CTX_load_verify_locations ok!");
        }

        JITPrivCertInfo *privCertInfo = sslInfo.privCertInfo;

        /* 5.加载自己的 证书 */
        if (privCertInfo.signCertPath) {
            NSString *strUserCertPath = privCertInfo.signCertPath;
            NSLog(@"SSL_CTX_use_Key_sign_cert start!");
            if (SSL_CTX_use_certificate_file(m_ctx, (const char *)[strUserCertPath UTF8String], SSL_FILETYPE_PEM) <= 0){
                NSLog(@"SSL_CTX_use_Key_sign_cert error!");
                ERR_print_errors_fp(stderr);
                if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self
                                   error:[self sslError:@"SSL_CTX_use_Key_sign_cert Error"]];
                }
                return;
            }
            NSLog(@"SSL_CTX_use_Key_sign_cert ok!");
        }


        /* 6.加载自己的 私钥 */
        if (privCertInfo.signPrivPath) {
            NSString *strUserKeyPath = privCertInfo.signPrivPath;
            NSLog(@"SSL_CTX_use_Key_sign_key start!");
            if (SSL_CTX_use_PrivateKey_file(m_ctx, (const char *)[strUserKeyPath UTF8String], SSL_FILETYPE_PEM) <= 0){
                NSLog(@"SSL_CTX_use_Key_sign_key error!");
                ERR_print_errors_fp(stderr);
                if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self
                                   error:[self sslError:@"SSL_CTX_use_Key_sign_key Error"]];
                }
                return;
            }
            NSLog(@"SSL_CTX_use_Key_sign_key ok!");
        }

        /* 7.加载自己 加密证书 */
        if (privCertInfo.encCertPath) {
            NSString *strUserCertPath = privCertInfo.encCertPath;
            NSLog(@"SSL_CTX_use_Key_enc_cert start!");
            if (SSL_CTX_use_enc_certificate_file(m_ctx, (const char *)[strUserCertPath UTF8String], SSL_FILETYPE_PEM) <= 0){
                NSLog(@"SSL_CTX_use_Key_enc_cert error!");
                ERR_print_errors_fp(stderr);
                if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self
                                   error:[self sslError:@"SSL_CTX_use_Key_enc_cert Error"]];
                }
                return;
            }
            NSLog(@"SSL_CTX_use_Key_enc_cert ok!");
        }

        /* 8.加载自己的 加密证书私钥 */
        if (privCertInfo.encPrivPath) {
            NSString *strUserKeyPath = privCertInfo.encPrivPath;
            NSLog(@"SSL_CTX_use_Key_enc_key start!");
            if (SSL_CTX_use_enc_PrivateKey_file(m_ctx, (const char *)[strUserKeyPath UTF8String], SSL_FILETYPE_PEM) <= 0){
                NSLog(@"SSL_CTX_use_Key_enc_key error!");
                ERR_print_errors_fp(stderr);
                if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self
                                   error:[self sslError:@"SSL_CTX_use_Key_enc_key Error"]];
                }
                return;
            }
            NSLog(@"SSL_CTX_use_Key_enc_key ok!");
        }
        
        /*
         9.客户端验证 证书和私钥 是否一致(成功返回1)
         验证导致握手失败?
         */
        NSLog(@"SSL_CTX_check_private_key start!");
        if (SSL_CTX_check_private_key(m_ctx) != 1) {
            ERR_print_errors_fp(stderr);
            NSLog(@"SSL_CTX_use_Key_sign_key error!");
            if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                    [_delegate didSecure:self error:[self sslError:@"SSL_CTX_check_private_key Error"]];
            }
        }
        NSLog(@"SSL_CTX_check_private_key ok!");
        
        
        /* 10.检查用户私钥是否正确
         真正进行验证，一定要调用这个函数不然前面四个光配置而已并不会进行双向验证）
         */
        NSLog(@"SSL_CTX_check_private_key start!");
        if (!SSL_CTX_check_private_key(m_ctx))
        {
           NSLog(@"SSL_CTX_check_private_key error!");
           ERR_print_errors_fp(stderr);
           if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
               [_delegate didSecure:self
                              error:[self sslError:@"SSL_CTX_check_private_key Error"]];
           }
           return;
        }
        NSLog(@"SSL_CTX_check_private_key ok!");

        // 11.初始化SSL安全通信的对象(为一个新SSL链接建立SSL*结构体变量。)
        if (!m_ssl) {
            m_ssl = SSL_new(m_ctx);
        }
        
        // 12.将SSL对象和文件描述符关联起来
        int result = SSL_set_fd(m_ssl, _socketFD);
        if (result == -1) {
            if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
                [_delegate didSecure:self error:[self sslError:@"SSL_set_fd Error"]];
                return;
            }
        }
        
        /*
         13.SSL_CTX_set_verify:配置启用双向认证
         1、SSL_VERIFY_PEER:要求对证书进行认证，表示需要验证服务器端，没有证书也会放行，若不需要验证则使用  SSL_VERIFY_NONE
         2、SSL_VERIFY_FAIL_IF_NO_PEER_CERT:要求客户端需要提供证书，但验证发现单独使用没有证书也会放行
         */
        SSL_CTX_set_verify(m_ctx, SSL_VERIFY_PEER, NULL);
        SSL_set_verify(m_ssl, SSL_VERIFY_PEER, NULL);
        
        /* 14.设置加密套件 */
        if (sslInfo.ciperSuite == 0) {
            SSL_set_cipher_list(m_ssl,"ECC-SM4-SM3");
        } else {
            SSL_set_cipher_list(m_ssl,"ECDHE-SM4-SM3");
        }
    }
    
    /* 15.SSL握手 */
    [self sslHandshake];
}
// SSL握手
- (void)sslHandshake {
    
    int ret = 0;
    // 初始化SSL协商处理
    SSL_set_connect_state(m_ssl);
    while (1){
        // 实现握手
        ret = SSL_do_handshake(m_ssl);
        if (ret > 0) {
            break;
        } else {
            ERR_print_errors_fp(stderr);
            // SSL_get_error:获取错误码
            if (SSL_get_error(m_ssl, ret) == SSL_ERROR_WANT_HSM_RESULT) {
                continue;
            } else {
                NSLog(@"error of ssl do handshake");
                break;
            }
        }
    }
    // 握手失败
    if(ret <= 0) {
        NSLog(@"handshake failed");
        if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
            [_delegate didSecure:self
                           error:[self sslError:@"handshake failed"]];
        }
    }
    // 握手成功
    else {
        NSLog(@"ssl connect ok");
        // 握手成功的回调
        [self didSSLHandshake];
        
        // 显示证书
        [self showCert];
    }
}
// 关闭连接
- (void)disconnect{
    if(_socketFD > 0){
        close(_socketFD);
        _socketFD = 0;
    }

    if(m_ssl != NULL){
        SSL_shutdown(m_ssl);
        SSL_free(m_ssl);
        m_ssl = NULL;
    }

    if (m_ctx != NULL) {
        SSL_CTX_free(m_ctx);
        m_ctx = NULL;
    }
}
// 已经SSL握手
- (void)didSSLHandshake {
    _isSecure = YES;
    NSError * error = nil;
    if (_delegate && [_delegate respondsToSelector:@selector(didSecure:error:)]) {
        [_delegate didSecure:self error:error];
    }
}

#pragma mark -- 向网关写数据
- (int)writeData:(char *)buff andLen:(int)len andTimeOut:(int)timeout{
    int ret = -100;
    
    if (!buff || !len) {
        [self didWriteOrReadError:[self wOrRError:@"parameter error"]];
        return ret;
    }
    
    struct timeval sendtimeout = {0,0};
    if (timeout > 0) {
        sendtimeout.tv_sec = timeout/1000;
        sendtimeout.tv_usec=(timeout%1000)*1000;
        setsockopt(_socketFD,
                   SOL_SOCKET,
                   SO_SNDTIMEO,
                   (const void *)(&sendtimeout),
                   sizeof(struct timeval));
    }
    
    if (m_ssl) {
        ret = SSL_write(m_ssl, (const void *)buff, len);
    } else {
        ret = (int)send(_socketFD, buff, (size_t)len, 0);
    }
    
    if (ret > 0) {
        [self _didWrite];
    } else {
        [self didWriteOrReadError:[self wOrRError:@"write failed"]];
    }
    return ret;
}
// 写成功的代理回调
- (void)_didWrite {
    if (_delegate && [_delegate respondsToSelector:@selector(didWriteData:)]) {
        [_delegate didWriteData:self];
    }
}

#pragma mark - 从网关读数据
- (int)readData:(char *)buff andLen:(int)len andTimeOut:(int)timeout{
    int ret = -100;
    
    if (!buff || !len) {
        [self didWriteOrReadError:[self wOrRError:@"parameter error"]];
        return ret;
    }
    
    // 设置超时时间
    struct timeval receiveTimeout = {0,0};
    if (timeout > 0) {
        receiveTimeout.tv_sec = timeout/1000;
        receiveTimeout.tv_usec=(timeout%1000)*1000;
        setsockopt(_socketFD,
                   SOL_SOCKET,
                   SO_RCVTIMEO,
                   (const void *)(&receiveTimeout),
                   sizeof(struct timeval));
    }

    if (m_ssl) {
        ret = SSL_read(m_ssl, buff, len);
    } else {
        ret = (int)recv(_socketFD, buff, len, 0);
    }

    if (ret == -1) {
        NSString *strErr = [NSString stringWithFormat:@"read failed, ssl code = [%d]", SSL_get_error(m_ssl, ret)];
        [self didWriteOrReadError:[self wOrRError:strErr]];
    } else {
        int err = SSL_get_error(m_ssl, ret);
        NSLog(@"err:%d",err);
        /*
         ret:0 表示被关闭了 ret:大于0 表示接收到数据
         */
        NSData *data = [NSData dataWithBytes:buff length:ret];
        [self _didRead:data];
    }
    return ret;
}
// 从网关读数据成功的代理回调
- (void)_didRead:(NSData *)data {
    if (_delegate && [_delegate respondsToSelector:@selector(didReadSocket:data:)]) {
        [_delegate didReadSocket:self data:data];
    }
}

#pragma mark - 读/写错误的代理回调
- (void)didWriteOrReadError:(NSError *)error {
    if (_delegate && [_delegate respondsToSelector:@selector(didWriteOrRead:error:)]) {
        [_delegate didWriteOrRead:self error:error];
    }
}

#pragma mark -- 关闭socket连接
- (void)closeWithError:(NSError *)error {
    close(_socketFD);
    _socketFD = -1;
    
    if (_delegate && [_delegate respondsToSelector:@selector(didDisconnectSocket:error:)]) {
        [_delegate didDisconnectSocket:self error:error];
    }
}


#pragma mark -- Error
- (NSError *)otherError:(NSString *)errMsg {
    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg
                                                         forKey:NSLocalizedDescriptionKey];
    return [NSError errorWithDomain:@"SocketErrorDomain" code:5 userInfo:userInfo];
}

- (NSError *)wOrRError:(NSString *)errMsg {
    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg
                                                         forKey:NSLocalizedDescriptionKey];
    return [NSError errorWithDomain:@"SSLWriteOrReadErrorDomain" code:6 userInfo:userInfo];
}

- (NSError *)sslError:(NSString *)errMsg {
    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg
                                                         forKey:NSLocalizedDescriptionKey];
    return [NSError errorWithDomain:@"SSLErrorDomain" code:7 userInfo:userInfo];
}

@end

@implementation JITSSLInfo

- (instancetype)init
{
    self = [super init];
    if (self) {
        _ciperSuite = 0;
        _caInfo = @[];
        _privCertInfo = [[JITPrivCertInfo alloc] init];
    }
    return self;
}

@end

@implementation JITPrivCertInfo

- (instancetype)init
{
    self = [super init];
    if (self) {
        _signCertPath = nil;
        _signPrivPath = nil;
        _encCertPath = nil;
        _encPrivPath = nil;
    }
    return self;
}

@end

  1. GmsslManager.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//
//  GmsslManager.h
//  JiAnBaoStandard
//
//  Created by Mac on 2023/7/31.
//  Copyright © 2023 JITPlatform. All rights reserved.
//

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface GmsslManager : NSObject
// 读取数据成功的block回调
@property (nonatomic,copy)void(^readDataSuccessBlock)(NSData * data);

// 单例
+ (instancetype)sharedManager;

// 连接国密
- (void)connectGmsslWithData:(NSData *)data;
@end

NS_ASSUME_NONNULL_END

  1. GmsslManager.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
//
//  GmsslManager.m
//  JiAnBaoStandard
//
//  Created by Mac on 2023/7/31.
//  Copyright © 2023 JITPlatform. All rights reserved.
//

#import "GmsslManager.h"
#import "JITGMSocket.h"

@interface GmsslManager ()<JITSocketDelegate>
// 国密socket
@property (nonatomic,strong)JITGMSocket * gmSocket;
// 当前要发送的数据
@property (nonatomic,strong)NSData * currentSendData;
@end
@implementation GmsslManager
// 单例
+ (instancetype)sharedManager{
    static GmsslManager * manager = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        manager = [[self alloc] init];
    });
    return manager;
}

#pragma mark - 连接国密
- (void)connectGmsslWithData:(NSData *)data{
    // 获取缓存网关地址
    NSString * gwAddr = [NSUserDefaults cacheGetObjectForKey:kGwAddress];
    NSArray * arr = [gwAddr componentsSeparatedByString:@":"];
    NSString * ip = [arr objectAtIndex:0];
    NSString * port = [arr objectAtIndex:1];
    
    // 赋值当前发送数据
    self.currentSendData = data;
    
    // 初始化socket
    self.gmSocket = [[JITGMSocket alloc] initWithDelegate:self];
    
    // 连接到网关服务器
    [self.gmSocket connectToHost:ip onPort:[port intValue]];
    
}

#pragma mark - 国密双向认证
- (void)startSSL{
    // 双向认证信息
    JITSSLInfo * sslInfo = [[JITSSLInfo alloc] init];
    // 加密套件 0:ECC-SM4-SM3 非0:ECDHE-SM4-SM3
    sslInfo.ciperSuite = 0;
    // 根证
    sslInfo.caInfo = @[[self getCertPathWithFileName:@"ca"]];
    // 证书信息
    JITPrivCertInfo * certInfo = [[JITPrivCertInfo alloc] init];
    // 签名证书
    certInfo.signCertPath = [self getCertPathWithFileName:@"cli.cert.sig"];
    // 签名私钥
    certInfo.signPrivPath =  [self getCertPathWithFileName:@"cli.key.sig"];
    // 加密证书
    certInfo.encCertPath =  [self getCertPathWithFileName:@"cli.cert.enc"];
    // 加密私钥
    certInfo.encPrivPath =  [self getCertPathWithFileName:@"cli.key.enc"];
    // 设置私证信息
    sslInfo.privCertInfo = certInfo;
    
    // 开始双向认证(NO：双向 YES：单向)
    [self.gmSocket startSSL:NO andSSLInfo:sslInfo];
}

#pragma mark - 获取证书信息
- (NSString *)getCertPathWithFileName:(NSString *)fileName{
    // 证书路径
    NSString * certsPath = [[NSBundle mainBundle] pathForResource:fileName ofType:@"pem"];
    
//    // 打印证书内容
//    NSError * error;
//    NSString * contentInUTF8 = [NSString stringWithContentsOfFile:certsPath
//                                                         encoding:NSUTF8StringEncoding
//                                                            error:&error];
//    NSLog(@"content:%@",contentInUTF8);
    // 返回
    return certsPath;
}

#pragma mark - 国密socketDelegate
// socket连接成功
- (void)didConnectSocket:(JITGMSocket *)socket host:(NSString *)host port:(int)port {
    NSLog(@"连接成功%@:%d 可以进行国密SSL认证",host,port);
    // 开始SSL认证
    [self startSSL];
}
// socket连接失败
- (void)didDisconnectSocket:(JITGMSocket *)socket error:(NSError *)error{
    NSLog(@"连接失败, %@",error);
}
// 已经写/读数据
- (void)didWriteOrRead:(JITGMSocket *)socket error:(NSError *)error {
    NSLog(@"已经写或读");
}
// 已经写数据
- (void)didWriteData:(nonnull JITGMSocket *)socket {
    NSLog(@"已经写数据");
}

#pragma mark - 已经读取到socket返回的数据
- (void)didReadSocket:(JITGMSocket *)socket data:(NSData *)data{
    if (data.length > 0) {
        if (self.readDataSuccessBlock) {
            self.readDataSuccessBlock(data);
        }
    }
}

#pragma mark - SSL握手结果
- (void)didSecure:(JITGMSocket *)socket error:(NSError *)error {
    if (error) {
        NSLog(@"握手失败, error:%@",error.localizedDescription);
    }else {
        NSLog(@"握手成功");
        // 写数据（unicode编码，是一个字符 \U00000005\U00000001\X90）
        char * write_buff = (char *)[self.currentSendData bytes];
        // 长度计算不对会导致读取不到想要的结果(3 而不是 8)
        NSInteger write_len = self.currentSendData.length;
        int write_result = [socket writeData:write_buff andLen:(int)write_len andTimeOut:5];
        NSLog(@"write_result:%d",write_result);
        
        // 读取数据（\U00000005\X90）
        char read_buff[1024] = {0};
        int read_len = sizeof(read_buff);
        int read_result = [socket readData:read_buff andLen:read_len andTimeOut:10];
        NSLog(@"read_result:%d",read_result);
    }
}

#pragma mark - dealloc
- (void)dealloc{
    NSLog(@"%s",__func__);
}
@end

  • Post title：OC网络学习25：OpenSSL探索
  • Post author：张建
  • Create time：2023-08-03 16:34:02
  • Post link：https://redefine.ohevan.com/2023/08/03/OC网络/OC网络学习25：OpenSSL探索/
  • Copyright Notice：All articles in this blog are licensed under BY-NC-SA unless stating additionally.
On this page
OC网络学习25：OpenSSL探索
  1. Openssl 之 SSL
  2. SSL开发流程
  3. 主要接口：
  4. 使用举例
  5. 实际项目中的应用封装