Chinaunix首页 | 论坛 | 博客

水滴

首页　| 　博文目录　| 　关于我

qq526665621

  • 博客访问： 299506
  • 博文数量： 52
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 587
  • 用 户 组： 普通用户
  • 注册时间： 2017-03-09 09:24
个人简介

水滴

文章分类

全部博文（52）

文章存档

2021年（3）

2019年（8）

2018年（32）

2017年（9）

我的朋友
最近访客
推荐博文
相关博文
Linux-实现链路加密

分类： LINUX

2021-12-27 10:21:57

Linux-实现链路加密


1 mbedtls

    mbedtls为嵌入式提供了最小化的链路加密方式，资源网站：tls.mbed.org

2 mbedtls交叉编译


1 在CMakeList.txt中添加 set(CMAKE_C_FLAGS "-std=c99") //mbedtls 3.0.0 以上需要
2 cmake -DUSE_SHARED_MBEDTLS_LIBRARY:Bool=ON -DENABLE_TESTING:Bool=OFF - DENABLE_PROGRAMS:Bool=ON -DCMAKE_C_COMPILER=arm-fsl-linux-gnueabi-gcc
3 make

3 证书生成方法

3.1 tls证书

3.1.1 正文

SSL证书通过在客户端浏览器和Web服务器之间建立一条SSL安全通道（Secure socketlayer(SSL),SSL安全协议主要用来提供对用户和服务器的认证；对传送的数据进行加密和隐藏；确保数据在传送中不被改变，即数据的完整性，现已成为该领域中全球化的标准。由于SSL技术已建立到所有主要的浏览器和WEB服务器程序中，因此，仅需安装服务器证书就可以激活该功能了）。即通过它可以激活SSL协议，实现数据信息在客户端和服务器之间的加密传输，可以防止数据信息的泄露。保证了双方传递信息的安全性，而且用户可以通过服务器证书验证他所访问的网站是否是真实可靠。    SSL网站不同于一般的Web站点，它使用的是“HTTPS”协议，而不是普通的“HTTP”协议。因此它的URL（统一资源定位器）格式为“”。

3.1.2 概念

    首先要有一个CA根证书，然后用CA根证书来签发用户证书。    用户进行证书申请：一般先生成一个私钥，然后用私钥生成证书请求(证书请求里应含有公钥信息)，再利用证书服务器的CA根证书来签发证书。   
特别说明:（1）自签名证书(一般用于顶级证书、根证书): 证书的名称和认证机构的名称相同.（2）根证书：根证书是CA认证中心给自己颁发的证书,是信任链的起始点。任何安装CA根证书的服务器都意味着对这个CA认证中心是信任的。数字证书则是由证书认证机构（CA）对证书申请者真实身份验证之后，用CA的根证书对申请人的一些基本信息以及申请人的公钥进行签名（相当于加盖发证书机构的公章）后形成的一个数字文件。数字证书包含证书中所标识的实体的公钥（就是说你的证书里有你的公钥），由于证书将公钥与特定的个人匹配，并且该证书的真实性由颁发机构保证（就是说可以让大家相信你的证书是真的），因此，数字证书为如何找到用户的公钥并知道它是否有效这一问题提供了解决方案。
1 openssl中有如下后缀名的文件
.key格式：私有的密钥.csr格式：证书签名请求（证书请求文件），含有公钥信息，certificate signing request的缩写.crt格式：证书文件，certificate的缩写.crl格式：证书吊销列表，Certificate Revocation List的缩写.pem格式：用于导出，导入证书时候的证书的格式，有证书开头，结尾的格式
2 CA根证书的生成步骤
生成CA私钥（.key）-->生成CA证书请求（.csr）-->自签名得到根证书（.crt）（CA给自已颁发的证书）。
在实际的软件开发工作中，往往服务器就采用这种自签名的方式，因为毕竟找第三方签名机构是要给钱的，也是需要花时间的。
3 用户证书的生成步骤
生成私钥（.key）-->生成证书请求（.csr）-->用CA根证书签名得到证书（.crt）服务器端用户证书

3.2 根证书生成

1 openssl genrsa -out ca.key 2048

2 openssl req -new -key ca.key -out ca.csr
3 openssl x509 -req -days 3650 -in ca.csr -signkey ca.key -out ca.crt
4 openssl x509 -in ca.crt -text   //查看证书内容

3.3 服务器证书生成

1 openssl genrsa -out server.key 2048
2 openssl req -new -key server.key -out server.csr
3 openssl x509 -req -days 3650 -inserver.csr -CAkey ca.key -CA ca.crt -CAcreateserial -out server.crt
4  openssl x509 -in server.crt -text


3.4 客户端证书生成

1 openssl genrsa -out client.key 2048
2 openssl req -new -key client.key -out client.csr

3 openssl x509 -req -days 3650 -inclient.csr -CAkey ca.key -CA ca.crt -CAcreateserial -out client.crt

4  openssl x509 -in client.crt -text


4 利用mbedtls实现链路加密

4.2 服务端实现方式


点击(此处)折叠或打开

  1. #if !defined(MBEDTLS_CONFIG_FILE)
  2. #include "mbedtls/config.h"
  3. #else
  4. #include MBEDTLS_CONFIG_FILE
  5. #endif

  7. #if defined(MBEDTLS_PLATFORM_C)
  8. #include "mbedtls/platform.h"
  9. #else
  10. #include
  11. #include
  12. #define mbedtls_time time
  13. #define mbedtls_time_t time_t
  14. #define mbedtls_fprintf fprintf
  15. #define mbedtls_printf printf
  16. #endif

  18. #include "mbedtls/entropy.h"
  19. #include "mbedtls/ctr_drbg.h"
  20. #include "mbedtls/certs.h"
  21. #include "mbedtls/x509.h"
  22. #include "mbedtls/ssl.h"
  23. #include "mbedtls/net_sockets.h"
  24. #include "mbedtls/error.h"
  25. #include "mbedtls/debug.h"

  27. #if defined(MBEDTLS_SSL_CACHE_C)
  28. #include "mbedtls/ssl_cache.h"
  29. #endif

  31. #define HTTP_RESPONSE \
  32.     "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n" \
  33.     "mbed TLS Test Server\r\n" \

  35.     "Successful connection using: %s\r\n"

  37. #define DEBUG_LEVEL 0

  39. static char *ca_path = "/root/openssl/ca.crt"; //根证书
  40. static char *cert_path = "/root/openssl/server.crt"; //服务器证书
  41. static char *key_path = "/root/openssl/server.key"; //证书密钥

  43. static void my_debug( void *ctx, int level,
  44.                       const char *file, int line,
  45.                       const char *str )
  46. {
  47.     ((void) level);
  48.     mbedtls_fprintf( (FILE *) ctx, "%s:%04d: %s", file, line, str );
  49.     fflush( (FILE *) ctx );
  50. }

  52. int main( void )
  53. {
  54.     int ret, len;
  55.     mbedtls_net_context listen_fd, client_fd;
  56.     unsigned char buf[1024];
  57.     const char *pers = "ssl_server";

  59.     mbedtls_entropy_context entropy;
  60.     mbedtls_ctr_drbg_context ctr_drbg;
  61.     mbedtls_ssl_context ssl;
  62.     mbedtls_ssl_config conf;
  63.     mbedtls_x509_crt srvcert;
  64.     mbedtls_x509_crt cacert;
  65.     mbedtls_pk_context pkey;
  66. #if defined(MBEDTLS_SSL_CACHE_C)
  67.     mbedtls_ssl_cache_context cache;
  68. #endif
  69.     mbedtls_net_init( &listen_fd );
  70.     mbedtls_net_init( &client_fd );
  71.     mbedtls_ssl_init( &ssl );
  72.     mbedtls_ssl_config_init( &conf );

  74. #if defined(MBEDTLS_SSL_CACHE_C)
  75.     mbedtls_ssl_cache_init( &cache );
  76. #endif

  78.     mbedtls_x509_crt_init( &srvcert );
  79.     mbedtls_x509_crt_init( &cacert );
  80.     mbedtls_pk_init( &pkey );
  81.     mbedtls_entropy_init( &entropy );
  82.     mbedtls_ctr_drbg_init( &ctr_drbg );

  84. #if defined(MBEDTLS_DEBUG_C)
  85.     mbedtls_debug_set_threshold( DEBUG_LEVEL );
  86. #endif
  87.     mbedtls_printf( "\n . Loading the server cert. and key..." );
  88.     fflush( stdout );

  90.     ret = mbedtls_x509_crt_parse_file(&(cacert), ca_path);
  91.     if( ret != 0 )
  92.     {
  93.         mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned %d\n\n", ret );
  94.         goto exit;
  95.     }
  96.     ret = mbedtls_x509_crt_parse_file(&(srvcert), cert_path);
  97.     if( ret != 0 )
  98.     {
  99.         mbedtls_printf( " failed\n ! mbedtls_x509_crt_parse returned %d\n\n", ret );
  100.         goto exit;
  101.     }

  103.     ret = ret = mbedtls_pk_parse_keyfile(&pkey, key_path, "");
  104.     if( ret != 0 )
  105.     {
  106.         mbedtls_printf( " failed\n ! mbedtls_pk_parse_key returned %d\n\n", ret );
  107.         goto exit;
  108.     }

  110.     mbedtls_printf( " ok\n" );

  112.     mbedtls_printf( " . Bind on ..." );
  113.     fflush( stdout );

  115.     if( ( ret = mbedtls_net_bind( &listen_fd, NULL, "873", MBEDTLS_NET_PROTO_TCP ) ) != 0 )
  116.     {
  117.         mbedtls_printf( " failed\n ! mbedtls_net_bind returned %d\n\n", ret );
  118.         goto exit;
  119.     }

  121.     mbedtls_printf( " ok\n" );

  123.     mbedtls_printf( " . Seeding the random number generator..." );
  124.     fflush( stdout );

  126.     if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
  127.                                (const unsigned char *) pers,
  128.                                strlen( pers ) ) ) != 0 )
  129.     {
  130.         mbedtls_printf( " failed\n ! mbedtls_ctr_drbg_seed returned %d\n", ret );
  131.         goto exit;
  132.     }

  134.     mbedtls_printf( " ok\n" );

  136.     mbedtls_printf( " . Setting up the SSL data...." );
  137.     fflush( stdout );

  139.     if( ( ret = mbedtls_ssl_config_defaults( &conf,
  140.                     MBEDTLS_SSL_IS_SERVER,
  141.                     MBEDTLS_SSL_TRANSPORT_STREAM,
  142.                     MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
  143.     {
  144.         mbedtls_printf( " failed\n ! mbedtls_ssl_config_defaults returned %d\n\n", ret );
  145.         goto exit;
  146.     }

  148.     mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
  149.     mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );

  151. #if defined(MBEDTLS_SSL_CACHE_C)
  152.     mbedtls_ssl_conf_session_cache( &conf, &cache,
  153.                                    mbedtls_ssl_cache_get,
  154.                                    mbedtls_ssl_cache_set );
  155. #endif

  157.     mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
  158.     if( ( ret = mbedtls_ssl_conf_own_cert( &conf, &srvcert, &pkey ) ) != 0 )
  159.     {
  160.         mbedtls_printf( " failed\n ! mbedtls_ssl_conf_own_cert returned %d\n\n", ret );
  161.         goto exit;
  162.     }

  164.     if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
  165.     {
  166.         mbedtls_printf( " failed\n ! mbedtls_ssl_setup returned %d\n\n", ret );
  167.         goto exit;
  168.     }

  170.     ret = mbedtls_ssl_set_hostname(&(ssl), "sixents");
  171.     if(ret != 0)
  172.     {
  173.        printf("mbedtls_x509_crt_parse failed, returned %d", ret);
  174.        return -1;
  175.     }

  177.     mbedtls_printf( " ok\n" );

  179. reset:
  180. #ifdef MBEDTLS_ERROR_C
  181.     if( ret != 0 )
  182.     {
  183.         char error_buf[100];
  184.         mbedtls_strerror( ret, error_buf, 100 );
  185.         mbedtls_printf("Last error was: %d - %s\n\n", ret, error_buf );
  186.     }
  187. #endif

  189.     mbedtls_net_free( &client_fd );
  190.     mbedtls_ssl_session_reset( &ssl );

  192.     mbedtls_printf( " . Waiting for a remote connection ..." );
  193.     fflush( stdout );

  195.     if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd,
  196.                                     NULL, 0, NULL ) ) != 0 )
  197.     {
  198.         mbedtls_printf( " failed\n ! mbedtls_net_accept returned %d\n\n", ret );
  199.         goto exit;
  200.     }

  202.     mbedtls_ssl_set_bio( &ssl, &client_fd, mbedtls_net_send, mbedtls_net_recv, NULL );

  204.     mbedtls_printf( " ok\n" );

  206.     mbedtls_printf( " . Performing the SSL/TLS handshake..." );
  207.     fflush( stdout );

  209.     while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
  210.     {
  211.         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
  212.         {
  213.             mbedtls_printf( " failed\n ! mbedtls_ssl_handshake returned %d\n\n", ret );
  214.             goto reset;
  215.         }
  216.     }

  218.     mbedtls_printf( " ok\n" );

  220.     mbedtls_printf( " < Read from client:" );
  221.     fflush( stdout );

  223.     do
  224.     {
  225.         len = sizeof( buf ) - 1;
  226.         memset( buf, 0, sizeof( buf ) );
  227.         ret = mbedtls_ssl_read( &ssl, buf, len );

  229.         if( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE )
  230.             continue;

  232.         if( ret <= 0 )
  233.         {
  234.             switch( ret )
  235.             {
  236.                 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
  237.                     mbedtls_printf( " connection was closed gracefully\n" );
  238.                     break;
  239.                 case MBEDTLS_ERR_NET_CONN_RESET:
  240.                     mbedtls_printf( " connection was reset by peer\n" );
  241.                     break;
  242.                 default:
  243.                     mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n", -ret );
  244.                     break;
  245.             }
  246.             break;
  247.         }

  249.         len = ret;
  250.         mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );

  252.         if( ret > 0 )
  253.             break;
  254.     }
  255.     while( 1 );

  257.     /*
  258.      * 7. Write the 200 Response
  259.      */
  260.     mbedtls_printf( " > Write to client:" );
  261.     fflush( stdout );

  263.     len = sprintf( (char *) buf, HTTP_RESPONSE,
  264.                    mbedtls_ssl_get_ciphersuite( &ssl ) );

  266.     while( ( ret = mbedtls_ssl_write( &ssl, buf, len ) ) <= 0 )
  267.     {
  268.         if( ret == MBEDTLS_ERR_NET_CONN_RESET )
  269.         {
  270.             mbedtls_printf( " failed\n ! peer closed the connection\n\n" );
  271.             goto reset;
  272.         }

  274.         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
  275.         {
  276.             mbedtls_printf( " failed\n ! mbedtls_ssl_write returned %d\n\n", ret );
  277.             goto exit;
  278.         }
  279.     }

  281.     len = ret;
  282.     mbedtls_printf( " %d bytes written\n\n%s\n", len, (char *) buf );
  283.     mbedtls_printf( " . Closing the connection..." );

  285.     while( ( ret = mbedtls_ssl_close_notify( &ssl ) ) < 0 )
  286.     {
  287.         if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
  288.             ret != MBEDTLS_ERR_SSL_WANT_WRITE )
  289.         {
  290.             mbedtls_printf( " failed\n ! mbedtls_ssl_close_notify returned %d\n\n", ret );
  291.             goto reset;
  292.         }
  293.     }
  294.     mbedtls_printf( " ok\n" );

  296.     ret = 0;
  297.     goto reset;

  299. exit:

  301. #ifdef MBEDTLS_ERROR_C
  302.     if( ret != 0 )
  303.     {
  304.         char error_buf[100];
  305.         mbedtls_strerror( ret, error_buf, 100 );
  306.         mbedtls_printf("Last error was: %d - %s\n\n", ret, error_buf );
  307.     }
  308. #endif

  310.     mbedtls_net_free( &client_fd );
  311.     mbedtls_net_free( &listen_fd );
  312.     mbedtls_x509_crt_free( &srvcert );
  313.     mbedtls_pk_free( &pkey );
  314.     mbedtls_ssl_free( &ssl );
  315.     mbedtls_ssl_config_free( &conf );
  316. #if defined(MBEDTLS_SSL_CACHE_C)
  317.     mbedtls_ssl_cache_free( &cache );
  318. #endif
  319.     mbedtls_ctr_drbg_free( &ctr_drbg );
  320.     mbedtls_entropy_free( &entropy );

  322. #if defined(_WIN32)
  323.     mbedtls_printf( " Press Enter to exit this program.\n" );
  324.     fflush( stdout ); getchar();
  325. #endif

  327.     return( ret );
  328. }

  330. 4.3 客户端实现方式
  331. typedef struct {
  332.   mbedtls_net_context net_context;
  333.   mbedtls_ssl_context ssl_context;
  334.   mbedtls_ssl_config conf;
  335.   mbedtls_x509_crt cacert;

  337.   mbedtls_x509_crt certchain;
  338.   mbedtls_pk_context pkey;
  339.   mbedtls_entropy_context entropy;
  340.   mbedtls_ctr_drbg_context ctr_drbg;
  341. } tls_parm_t;

  343. int tlscomm_init(tls_parm_t *tls_parm, tlsconf_t *tlsconf, const char *ser_addr, const char *ser_port)
  344. {
  345.   int ret = 0;
  346.   int force_ciphersuite;
  347.   int corebuf_len = 8*1024;
  348.   int get_corebuf_len;
  349.   int len = 0;


  352.   if(tls_parm == NULL || tlsconf == NULL || ser_addr == NULL || ser_port == NULL)
  353.   {
  354.     zlog_error(o, "input parameter error!");
  355.     return -1;
  356.   }
  357.   
  358.   len = sizeof(get_corebuf_len);
  359.   
  360.   mbedtls_debug_set_threshold(tlsconf->debuglevel);
  361.   zlog_info(o, "init environment.");
  362.   
  363.   mbedtls_net_init(&(tls_parm->net_context));
  364.   mbedtls_ssl_init(&(tls_parm->ssl_context));
  365.   mbedtls_ssl_config_init(&(tls_parm->conf));
  366.   mbedtls_x509_crt_init(&(tls_parm->cacert));
  367.   mbedtls_x509_crt_init(&(tls_parm->certchain));
  368.   mbedtls_pk_init(&(tls_parm->pkey));
  369.   mbedtls_entropy_init(&(tls_parm->entropy));
  370.   mbedtls_ctr_drbg_init(&(tls_parm->ctr_drbg));

  372.   ret = mbedtls_x509_crt_parse_file(&(tls_parm->cacert), tlsconf->cacert);
  373.   if(ret != 0)
  374.   {
  375.     mbedtls_strerror(ret, error_buf, 128);
  376.     zlog_error(o, "mbedtls_x509_crt_parse failed, returned %d - %s", ret, error_buf);
  377.     return -1;
  378.   }

  380.   ret = mbedtls_x509_crt_parse_file(&(tls_parm->certchain), tlsconf->cert);
  381.   if( ret != 0 )
  382.   {
  383.     mbedtls_strerror(ret, error_buf, 128);
  384.     zlog_error(o, "mbedtls_x509_crt_parse failed, returned %d - %s", ret, error_buf);
  385.     return -1;
  386.   }


  389.   ret = mbedtls_pk_parse_keyfile(&(tls_parm->pkey), tlsconf->key, "");
  390.   if(ret != 0)
  391.   {
  392.     mbedtls_strerror(ret, error_buf, 128);
  393.     zlog_error(o, "mbedtls_pk_parse_key failed, returned %d - %s", ret, error_buf);
  394.     return -1;
  395.   }

  397.   if((ret = mbedtls_ctr_drbg_seed(&(tls_parm->ctr_drbg), mbedtls_entropy_func, &(tls_parm->entropy),
  398.                                   (const unsigned char *)tlsconf->seed, tlsconf->seedlen)) != 0)
  399.   {
  400.     mbedtls_strerror(ret, error_buf, 128);
  401.     zlog_error(o, "mbedtls_ctr_drbg_seed failed, returned %d - %s", ret, error_buf);
  402.     return -1;
  403.   }

  405.   zlog_info(o, "config default environment.");
  406.   if((ret = mbedtls_ssl_config_defaults(&(tls_parm->conf),
  407.  MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM,MBEDTLS_SSL_PRESET_DEFAULT)) != 0)
  408.   {
  409.     mbedtls_strerror(ret, error_buf, 128);
  410.     zlog_error(o, "mbedtls_ssl_config_defaults failed, returned %d - %s", ret, error_buf);
  411.     return -1;
  412.   }
  413.    
  414.   force_ciphersuite = mbedtls_ssl_get_ciphersuite_id(tlsconf->ciphersuit);
  415.   mbedtls_ssl_conf_ciphersuites(&(tls_parm->conf), &force_ciphersuite);
  416.   mbedtls_ssl_conf_dbg(&(tls_parm->conf), my_debug, stdout);
  417.   mbedtls_ssl_conf_authmode(&(tls_parm->conf), MBEDTLS_SSL_VERIFY_REQUIRED);
  418.   mbedtls_ssl_conf_rng(&(tls_parm->conf), mbedtls_ctr_drbg_random, &(tls_parm->ctr_drbg));
  419.   mbedtls_ssl_conf_ca_chain(&(tls_parm->conf), &(tls_parm->cacert), NULL);
  420.   if((ret = mbedtls_ssl_conf_own_cert(&(tls_parm->conf), &(tls_parm->certchain), &(tls_parm->pkey))) != 0)
  421.   {
  422.     mbedtls_strerror(ret, error_buf, 128);
  423.     zlog_error(o, "mbedtls_ssl_conf_own_cert failed, returned %d - %s", ret, error_buf);
  424.     return -1;
  425.   }

  427.   if((ret = mbedtls_ssl_setup(&(tls_parm->ssl_context), &(tls_parm->conf))) != 0)
  428.   {
  429.     mbedtls_strerror(ret, error_buf, 128);
  430.     zlog_error(o, "mbedtls_ssl_setup failed, returned %d - %s", ret, error_buf);
  431.     return -1;
  432.   }

  434.   if((ret = tlscomm_connect(tls_parm, ser_addr, ser_port)) != 0)
  435.   {
  436.     zlog_error(o, "tlscomm_connect is error!");
  437.     return -1;
  438.   }

  440.   mbedtls_net_set_nonblock(&tls_parm->net_context);

  441.
  442.   setsockopt(tls_parm->net_context.fd, SOL_SOCKET, SO_SNDBUF, 
  443.                                            (const char *)&corebuf_len, sizeof(int));

  444.
  445.   getsockopt(tls_parm->net_context.fd, SOL_SOCKET, SO_SNDBUF, &get_corebuf_len, 
  446.                                             (socklen_t*)&len);
  447.  
  448.   if((ret = mbedtls_ssl_set_hostname(&(tls_parm->ssl_context), tlsconf->certcn)) != 0)
  449.   {
  450.     mbedtls_strerror(ret, error_buf, 128);
  451.     return -1;
  452.   }
  453.   mbedtls_ssl_set_bio(&(tls_parm->ssl_context), &(tls_parm->net_context), mbedtls_net_send, 
  454.                                       mbedtls_net_recv, mbedtls_net_recv_timeout);
  455.   mbedtls_ssl_conf_read_timeout(&(tls_parm->conf), 6000);

  457.   if((ret = mbedtls_ssl_handshake(&(tls_parm->ssl_context))) != 0)
  458.   {
  459.     mbedtls_strerror(ret, error_buf, 128);
  460.     zlog_error(o, "mbedtls_ssl_handshake failed, returned -0x%x - %s", -ret, error_buf);
  461.     if(ret == -0x6800)
  462.     {
  463.       tls_outtime_handle();
  464.     }
  465.     return -1;
  466.   }

  468.   if((ret = mbedtls_ssl_get_verify_result(&(tls_parm->ssl_context))) != 0)
  469.   {
  470.     char vrfy_buf[512];
  471.     mbedtls_x509_crt_verify_info(vrfy_buf, sizeof(vrfy_buf), " ! ", ret);
  472.     zlog_error(o, "mbedtls_ssl_get_verify_result failed, %s", vrfy_buf);
  473.     return -1;
  474.   }
  475.   return 0;
  476. }


阅读(1910) | 评论(0) | 转发(0) |
0

上一篇：linux-环形队列

下一篇：没有了

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6