当前位置:   article > 正文

mbedtls移植到k20简要笔记

mbedtls移植到k20简要笔记

原文链接:http://blog.csdn.net/ppdyhappy/article/details/64127332

mbedtls下载:

https://github.com/ARMmbed/mbedtls


移植源文件:

1)拿出解压后的mbedtls-development目录下的include文件和library文件

2)拿出mbedtls-development\programs\ssl下的demo,如ssl_client1.c(客户端代码)


程序处理:

1)随机数生成器

若芯片不支持随机数发生器可在config.h中打开宏  MBEDTLS_TEST_NULL_ENTROPY 并屏蔽宏  MBEDTLS_HAVEGE_C ,这样并不安全

若芯片支持随机数发生器则在config.h中关闭宏  MBEDTLS_TEST_NULL_ENTROPY 并打开宏  MBEDTLS_HAVEGE_C 

问题可在 mbedtls论坛上查询


2)程序裁剪:

为节省ROM和RAM,在config.h中注释如下宏定义

MBEDTLS_SELF_TEST //自测

MBEDTLS_VERSION_FEATURES  //disable run-time checking and save ROM space

其他根据宏定义的说明适当打开或屏蔽,如:MBEDTLS_BLOWFISH_C//实际不适用这个算法,可注释以节省空间


3)time接口:

在platform_time.h中

重定向 mbedtls_time宏,根据当前平台重新实现time接口,如这里实现如下

platform_time.h中:

#define mbedtls_time   new_time

new_time 接口实现如下,这里使用RTC寄存器

[cpp]  view plain  copy
  1. time_t new_time(time_t * parm)  
  2. {  
  3. struct tm* p;  
  4. RTC_QuickInit();  
  5. time_t timep = (time_t)RTC_GetTSR();  
  6. if(timep <= 1000)  
  7. {  
  8. timep = 0x95272759;  
  9. }  
  10.     p = localtime(&timep);  
  11.     timep = mktime(p);  
  12. return timep;  
  13. }  

证书部分:

证书制作参照 openssl+tomcat7使用简明笔记http://blog.csdn.net/ppdyhappy/article/details/56019429

    if( ( ret = mbedtls_ssl_set_hostname( &ssl, "host_name") ) != 0 )
    {
        mbedtls_printf( " failed\n  ! mbedtls_ssl_set_hostname returned %d\r\n", ret );
        goto exit;
    }

这里host_name对应服务器证书中的common name


使用openssl公钥最短为512bit,如此可降低芯片处理难度,对应要在x509_crt.c中修改公钥长度,修改部分如下:

[cpp]  view plain  copy
  1. const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default =  
  2. {  
  3.     /* Hashes from SHA-1 and above */  
  4.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |  
  5.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_RIPEMD160 ) |  
  6.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |  
  7.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |  
  8.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |  
  9.     MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),  
  10.     0xFFFFFFF, /* Any PK alg    */  
  11.     0xFFFFFFF, /* Any curve     */  
  12.     512, // 2048 修改这里  
  13. };  

这边实测mbedtls大概占用RAM 16kb左右

mbedtls论坛:https://tls.mbed.org/discussions


植接口及测试部分代码:

ssl_interface.h

//*******************************************************************//

[cpp]  view plain  copy
  1. #ifndef _SSL_INTERFACE_H_  
  2. #define _SSL_INTERFACE_H_  
  3.   
  4. int ssl_create( void );  
  5. int ssl_close( void );  
  6. int ssl_write( const unsigned char *buf, uint32_t len );  
  7. int ssl_read( unsigned char *buf, uint32_t len );  
  8.   
  9. #endif  



ssl_interface.c //rt-thread 操作系统,代码还未完善

//*******************************************************************//

[cpp]  view plain  copy
  1. #if !defined(MBEDTLS_CONFIG_FILE)  
  2. #include "mbedtls/config.h"  
  3. #else  
  4. #include MBEDTLS_CONFIG_FILE  
  5. #endif  
  6.   
  7. #if defined(MBEDTLS_PLATFORM_C)  
  8. #include "mbedtls/platform.h"  
  9. #else  
  10. #include <stdio.h>  
  11. #include <stdlib.h>  
  12. #define mbedtls_time       mktime   
  13. #define mbedtls_time_t     time_t  
  14. #define mbedtls_fprintf    fprintf  
  15. //#define mbedtls_printf     rt_kprintf  
  16. #endif  
  17.   
  18. #include "mbedtls/net_sockets.h"  
  19. #include "mbedtls/debug.h"  
  20. #include "mbedtls/ssl.h"  
  21. #include "mbedtls/entropy.h"  
  22. #include "mbedtls/ctr_drbg.h"  
  23. #include "mbedtls/error.h"  
  24. #include "mbedtls/certs.h"  
  25.   
  26. #include <string.h>  
  27.   
  28. #include "socket.h"               //socket接口用  
  29. #include "ssl_interface.h"  
  30. #include "common.h"          //  
  31.   
  32. #define SERVER_PORT 8080  
  33. #define SERVER_NAME "www.baidu.com" //  
  34. #define SERVER_HOSTNAME "hello" //server's certificate common name  
  35.   
  36. #define DEBUG_LEVEL 1  
  37.   
  38. static void my_debug( void *ctx, int level,  
  39.                       const char *file, int line,  
  40.                       const char *str )  
  41. {  
  42.     ((void) level);  
  43.     mbedtls_fprintf( (FILE *) ctx, "%s:%04d: %s", file, line, str );  
  44.     fflush(  (FILE *) ctx  );  
  45. }  
  46.   
  47. static int32_t ssl_socketID = 0;  
  48. static void ssl_socket_recive_data(char * recv_buff, rt_uint32_t len);  
  49. static int ssl_connect_net(void)  
  50. {  
  51.     int32_t aswResult;  
  52. SockAddr addr;  
  53.   
  54.     memcpy(addr.g_u8_socket_connect_host,SERVER_NAME,sizeof(SERVER_NAME));  
  55.     addr.g_u16_socket_connect_port = SERVER_PORT;  
  56.     addr.g_vd_socket_rtcp_data_cb = ssl_socket_recive_data;  
  57.   
  58.     if (0 == ssl_socketID)  
  59.     {  
  60.         ssl_socketID = g_s32_NET_socket();  
  61. }  
  62.   
  63. if(ssl_socketID < 0)  
  64. {  
  65. return -1;  
  66. }  
  67.   
  68. if(g_s32_NET_connect(ssl_socketID,&addr,sizeof(SockAddr)) != 0)  
  69. {  
  70. return -1;  
  71. }  
  72.   
  73. return 0;  
  74. }  
  75.   
  76. static char ssl_rec_buf[500] = {0};  
  77. /* 
  78. ssl_rec_flag:-2 receive action is error 
  79. ssl_rec_flag:-1 no receive action 
  80. ssl_rec_flag:0 have receive action 
  81. ssl_rec_flag:1 have read action 
  82. ssl_rec_flag:2 read over 
  83. */  
  84.   
  85. //#define   
  86.   
  87. static int ssl_rec_flag = -1;  
  88. static uint32_t ssl_rec_len = 0;  
  89.   
  90. static void ssl_socket_recive_data(char * recv_buff, uint32_t len)  
  91. {  
  92. if((ssl_rec_flag != -1) || (ssl_rec_flag != 2))  
  93. {  
  94. ssl_rec_flag = -2;  
  95. }  
  96.   
  97. if(ssl_rec_flag == 1)  
  98. {  
  99.   
  100. }  
  101. else  
  102. {  
  103. ssl_rec_len = len;  
  104.   
  105. memcpy(ssl_rec_buf, recv_buff, len);  
  106.   
  107. ssl_rec_flag = 0;  
  108. }  
  109.   
  110. }  
  111. //int32_t g_s32_NET_write(int32_t sockfd, void *buf, uint32_t count)  
  112. //MBEDTLS_ERR_NET_SEND_FAILED  
  113. static int wrap_ssl_send( void *ctx, unsigned char *buf, size_t len )  
  114. {  
  115. ctx = ctx;  
  116.   
  117. if(g_s32_NET_write(ssl_socketID, (void*)buf, (uint32_t)len) == -1)  
  118. {  
  119. return MBEDTLS_ERR_NET_SEND_FAILED;  
  120. }  
  121.   
  122. return (int)len;  
  123. }  
  124.   
  125. static void wait_socket_rev(uint32_t count)  
  126. {  
  127.   
  128. }  
  129.   
  130. //MBEDTLS_ERR_NET_RECV_FAILED  
  131. static int wrap_ssl_recv( void *ctx, unsigned char *buf, size_t len )  
  132. {  
  133. static size_t get_len = 0;  
  134. static size_t sum_len = 0;  
  135. size_t temp_len = 0;  
  136. uint32_t k = 0;  
  137.   
  138. ctx = ctx;  
  139.   
  140. if(-2 == ssl_rec_flag)  
  141. {  
  142. return MBEDTLS_ERR_NET_RECV_FAILED;  
  143. }  
  144.   
  145. // have read action  
  146. if(ssl_rec_flag == 1)  
  147. {  
  148. // do nothing  
  149. }  
  150. else  
  151. {  
  152. while(ssl_rec_flag != 0)  
  153. {  
  154. DelayMs(1);  
  155.   
  156. k += 1;  
  157.   
  158. if(k == 10000)  
  159. {  
  160. return MBEDTLS_ERR_NET_RECV_FAILED;  
  161. }  
  162. }  
  163.   
  164. sum_len = (size_t)ssl_rec_len;  
  165. get_len = 0;  
  166. }  
  167. // have receive action  
  168. if(ssl_rec_flag == 0)  
  169. {  
  170. ssl_rec_flag = 1;  
  171. }  
  172.   
  173. if(sum_len >= (len + get_len))  
  174. {  
  175. temp_len = len;  
  176. }  
  177. else  
  178. {  
  179. temp_len = sum_len - get_len;  
  180. }  
  181.   
  182. if(0 == temp_len)  
  183. {  
  184. return MBEDTLS_ERR_NET_RECV_FAILED;  
  185. }  
  186.   
  187. memcpy(buf, ssl_rec_buf + get_len, temp_len);  
  188.   
  189. get_len += temp_len;  
  190.   
  191. if(get_len == sum_len)  
  192. {  
  193. ssl_rec_flag = 2;  
  194. }  
  195. else if(get_len > sum_len)  
  196. {  
  197. //  
  198. }  
  199. else  
  200. {  
  201.   
  202. }  
  203.   
  204. return (int)temp_len;  
  205. }  
  206. //0:no close action 1:have close action  
  207. static uint8_t close_socket_flag = 0;  
  208. static int close_socket_ret = 0;  
  209.   
  210. static int ssl_close_socket(void)  
  211. {  
  212. int ret = 0;  
  213.   
  214. if(1 == close_socket_flag)  
  215. return close_socket_ret;  
  216.   
  217. ssl_socketID = 0;  
  218.   
  219. if((close_socket_ret = g_s32_NET_close(ssl_socketID)) != 0)  
  220. {  
  221. mbedtls_printf("close ssl socket[%d] fail!\r\n", ssl_socketID);  
  222. }  
  223. else  
  224. {  
  225. mbedtls_printf("close ssl socket[%d] success!\r\n", ssl_socketID);  
  226. }  
  227.   
  228. close_socket_flag = 1;  
  229. return close_socket_ret;  
  230. }  
  231.   
  232. //0:no clean 1:have clean  
  233. static uint8_t clean_flag = 0;  
  234. static void ssl_clean_up(void);  
  235.   
  236.   
  237. mbedtls_net_context server_fd;  
  238. mbedtls_entropy_context entropy;  
  239. mbedtls_ctr_drbg_context ctr_drbg;  
  240. mbedtls_ssl_context ssl;  
  241. mbedtls_ssl_config conf;  
  242. mbedtls_x509_crt cacert;  
  243.   
  244. int ssl_create( void )  
  245. {  
  246.     int ret;  
  247.     uint32_t flags;  
  248.     unsigned char buf[1024];  
  249.     const char *pers = "bj";  
  250.   
  251. //Æô¶¯µ÷ÊÔ¹¦ÄÜ  
  252. #if defined(MBEDTLS_DEBUG_C)  
  253.     mbedtls_debug_set_threshold( DEBUG_LEVEL );  
  254. #endif  
  255.   
  256. clean_flag = 0;  
  257. close_socket_flag = 0;  
  258. close_socket_ret = 0;  
  259.   
  260.     /* 
  261.      * 0. Initialize the RNG and the session data 
  262.      */  
  263. // ÓÃsocket ÅäÖà 
  264. //    mbedtls_net_init( &server_fd ); // ignore ysw  
  265.     mbedtls_ssl_init( &ssl );  
  266.     mbedtls_ssl_config_init( &conf );  
  267.     mbedtls_x509_crt_init( &cacert );  
  268.     mbedtls_ctr_drbg_init( &ctr_drbg );  
  269.   
  270.     mbedtls_printf( "\n  . Seeding the random number generator..." );  
  271.     fflush( stdout );  
  272. // ìسõʼ»¯  
  273.     mbedtls_entropy_init( &entropy );  
  274. //DRBG---->Deterministic Random Bit Generators Î±Ëæ»úÊý²úÉúÆ÷  
  275.     if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,  
  276.                                (const unsigned char *) pers,  
  277.                                strlen( pers ) ) ) != 0 )  
  278.     {  
  279.         mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret );  
  280.         goto exit_no_socket;  
  281.     }  
  282.   
  283.     mbedtls_printf( " ok\n" );  
  284.   
  285.     /* 
  286.      * 0. Initialize certificates 
  287.      */  
  288.     mbedtls_printf( "  . Loading the CA root certificate ..." );  
  289.     fflush( stdout );  
  290. //±¾µØÖ¤Êé´¦Àí£¬ÓÃÓÚУÑé·þÎñÆ÷Ö¤ÊéÓ㬿ɼò»¯´¦Àí  
  291. //mbedtls_test_cas_pem ´æ·ÅÖ¤ÊéÊý¾ÝµÄbuf  
  292.     ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_cas_pem,  
  293.                           mbedtls_test_cas_pem_len );  
  294.     if( ret < 0 )  
  295.     {  
  296.         mbedtls_printf( " failed\n  !  mbedtls_x509_crt_parse returned -0x%x\r\n", -ret );  
  297.         goto exit_no_socket;  
  298.     }  
  299.   
  300.     mbedtls_printf( " ok (%d skipped)\n", ret );  
  301.   
  302.     /* 
  303.      * 1. Start the connection 
  304.      */  
  305.     mbedtls_printf( "  . Connecting to tcp/%s/%d...", SERVER_NAME, SERVER_PORT );  
  306.     fflush( stdout );  
  307. //ÏÖÔÚ socket Á¬½Ó½Ó¿ÚºÜ¼òµ¥£¬Ö±½Óµ÷Óü´¿É  
  308. #if 0   
  309.     if( ( ret = mbedtls_net_connect( &server_fd, SERVER_NAME,  
  310.                                          SERVER_PORT, MBEDTLS_NET_PROTO_TCP ) ) != 0 )  
  311.     {  
  312.         mbedtls_printf( " failed\n  ! mbedtls_net_connect returned %d\r\n", ret );  
  313.         goto exit;  
  314.     }  
  315. #endif   
  316.   
  317.     if( ( ret = ssl_connect_net() ) != 0 )  
  318.     {  
  319.         mbedtls_printf( " failed\n  ! ssl_connect_net returned %d\r\n", ret );  
  320.         goto exit;  
  321.     }   
  322.   
  323.     mbedtls_printf( " ok\n" );  
  324.   
  325.     /* 
  326.      * 2. Setup stuff 
  327.      */  
  328.     mbedtls_printf( "  . Setting up the SSL/TLS structure..." );  
  329.     fflush( stdout );  
  330.   
  331.   
  332. //MBEDTLS_SSL_IS_CLIENT ±íʾÅäÖÃΪ¿Í»§¶Ë  
  333. //MBEDTLS_SSL_TRANSPORT_STREAM ±íʾ´«Ê䷽ʽΪTLS  
  334. //ÉèÖð汾£¬ MBEDTLS_SSL_PRESET_DEFAULT ±íʾ TLS1.0  
  335.     if( ( ret = mbedtls_ssl_config_defaults( &conf,  
  336.                     MBEDTLS_SSL_IS_CLIENT,  
  337.                     MBEDTLS_SSL_TRANSPORT_STREAM,  
  338.                     MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )  
  339.     {  
  340.         mbedtls_printf( " failed\n  ! mbedtls_ssl_config_defaults returned %d\r\n", ret );  
  341.         goto exit;  
  342.     }  
  343.   
  344.     mbedtls_printf( " ok\n" );  
  345.   
  346.     /* OPTIONAL is not optimal for security, 
  347.      * but makes interop easier in this simplified example */  
  348. // ÉèÖÃÊý×ÖÖ¤Êé¼ì²éģʽ   
  349. // MBEDTLS_SSL_VERIFY_OPTIONAL ÔÚclientģʽϲ»ÍƼöʹÓã¬ÒòΪ²»¹»°²È«  
  350.   
  351. /* 
  352. *  MBEDTLS_SSL_VERIFY_NONE:      peer certificate is not checked 
  353. *                        (default on server) 
  354. *                        (insecure on client) 
  355. * 
  356. *  MBEDTLS_SSL_VERIFY_OPTIONAL:  peer certificate is checked, however the 
  357. *                        handshake continues even if verification failed; 
  358. *                        mbedtls_ssl_get_verify_result() can be called after the 
  359. *                        handshake is complete. 
  360. * 
  361. *  MBEDTLS_SSL_VERIFY_REQUIRED:  peer *must* present a valid certificate, 
  362. *                        handshake is aborted if verification failed. 
  363. *                        (default on client) 
  364. */  
  365.     mbedtls_ssl_conf_authmode( &conf, MBEDTLS_SSL_VERIFY_OPTIONAL );  
  366. // Ö¤ÊéÁ´£¬Ô¤ÏÈ´æ·ÅÔÚ±¾µØµÄ  
  367.     mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );  
  368. // ÅäÖÃËæ»úÊýÉú³ÉÆ÷µÄ»Øµ÷º¯Êý  
  369.     mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );  
  370. // ÅäÖõ÷ÊԻص÷º¯Êý  
  371.     mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );  
  372. // ¸ù¾ÝconfÉèÖÃssl½á¹¹  
  373.     if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )  
  374.     {  
  375.         mbedtls_printf( " failed\n  ! mbedtls_ssl_setup returned %d\r\n", ret );  
  376.         goto exit;  
  377.     }  
  378. // ÉèÖÃhost name Óõ½¶¯Ì¬ÄÚ´æ·ÖÅä  
  379.     if( ( ret = mbedtls_ssl_set_hostname( &ssl, SERVER_HOSTNAME ) ) != 0 )  
  380.     {  
  381.         mbedtls_printf( " failed\n  ! mbedtls_ssl_set_hostname returned %d\r\n", ret );  
  382.         goto exit;  
  383.     }  
  384. // ÉèÖ÷¢ËͺͽÓÊÕ½Ó¿Ú  
  385. //    mbedtls_ssl_set_bio( &ssl, &server_fd, mbedtls_net_send, mbedtls_net_recv, NULL );  
  386.     mbedtls_ssl_set_bio( &ssl, &server_fd, wrap_ssl_send, wrap_ssl_recv, NULL );  
  387.   
  388.     /* 
  389.      * 4. Handshake 
  390.      */  
  391.     mbedtls_printf( "  . Performing the SSL/TLS handshake..." );  
  392.     fflush( stdout );  
  393.   
  394.   
  395.     while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )  
  396.     {  
  397.         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )  
  398.         {  
  399.             mbedtls_printf( " failed\n  ! mbedtls_ssl_handshake returned -0x%x\r\n", -ret );  
  400.             goto exit;  
  401.         }  
  402.     }  
  403.   
  404.     mbedtls_printf( " ok\n" );  
  405.     /* 
  406.      * 5. Verify the server certificate 
  407.      */  
  408.     mbedtls_printf( "  . Verifying peer X.509 certificate..." );  
  409.   
  410.     /* In real life, we probably want to bail out when ret != 0 */  
  411.     if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )  
  412.     {  
  413.         char vrfy_buf[512];  
  414.         mbedtls_printf( " failed\n" );  
  415.         mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", flags );  
  416.         mbedtls_printf( "%s\n", vrfy_buf );  
  417.     }  
  418.     else  
  419.         mbedtls_printf( " ok\n" );  
  420.   
  421. return (ret);  
  422.   
  423. exit:  
  424.   
  425. #ifdef MBEDTLS_ERROR_C  
  426.     if( ret != 0 )  
  427.     {  
  428.         char error_buf[100];  
  429.         mbedtls_strerror( ret, error_buf, 100 );  
  430.         mbedtls_printf("Last error was: %d - %s\r\n", ret, error_buf );  
  431.     }  
  432. #endif  
  433.   
  434. ssl_close_socket();  
  435.   
  436. exit_no_socket:  
  437. ssl_clean_up();  
  438.   
  439. #if defined(_WIN32)  
  440.     mbedtls_printf( "  + Press Enter to exit this program.\n" );  
  441.     fflush( stdout ); getchar();  
  442. #endif  
  443.   
  444.     return( ret );  
  445. }  
  446. //#endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_SSL_TLS_C &&  
  447. //          MBEDTLS_SSL_CLI_C && MBEDTLS_NET_C && MBEDTLS_RSA_C &&  
  448. //          MBEDTLS_CERTS_C && MBEDTLS_PEM_PARSE_C && MBEDTLS_CTR_DRBG_C &&  
  449. //          MBEDTLS_X509_CRT_PARSE_C */  
  450.   
  451. // return 0:success  
  452. // return -1:fail  
  453. int ssl_write( const unsigned char *buf, uint32_t len )  
  454. {  
  455. int ret;  
  456.   
  457.     while( ( ret = mbedtls_ssl_write( &ssl, buf, (size_t)len ) ) <= 0 )  
  458.     {  
  459.         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )  
  460.         {  
  461.             mbedtls_printf( " failed\n  ! mbedtls_ssl_write returned %d\r\n", ret );  
  462.   
  463. ssl_close_socket();  
  464.   
  465.             ssl_clean_up();  
  466.   
  467. return -1;  
  468.         }  
  469.     }  
  470. return 0;  
  471. }  
  472.   
  473. int ssl_read( unsigned char *buf, uint32_t len )  
  474. {  
  475. int ret;  
  476.   
  477.     do  
  478.     {  
  479.         ret = mbedtls_ssl_read( &ssl, buf, len );  
  480.   
  481.   
  482.         if( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE )  
  483.             continue;  
  484.   
  485.   
  486.         if( ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY )  
  487. mbedtls_printf( "failed\n  ! mbedtls_ssl_read returned %d\n\n", ret );  
  488. mbedtls_ssl_close_notify( &ssl );  
  489. ssl_clean_up();  
  490.   
  491.             return -1;  
  492.   
  493.         if( ret < 0 )  
  494.         {  
  495.             mbedtls_printf( "failed\n  ! mbedtls_ssl_read returned %d\n\n", ret );  
  496. ssl_clean_up();  
  497.             return -1;  
  498.         }  
  499.   
  500. //        if( ret == 0 )  
  501. //        {  
  502. //            mbedtls_printf( "\n\nEOF\n\n" );  
  503. //            break;  
  504. //        }  
  505.   
  506.   
  507.         len = ret;  
  508.         mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );  
  509.     }  
  510.     while( 1 );   
  511.   
  512. return ret;  
  513. }  
  514.   
  515. //clean up  
  516. static void ssl_clean_up(void)  
  517. {  
  518. if(1 == clean_flag)  
  519. return;  
  520.   
  521. mbedtls_printf(" ssl clean up\r\n");  
  522.   
  523.     mbedtls_x509_crt_free( &cacert );  
  524.     mbedtls_ssl_free( &ssl );  
  525. mbedtls_ssl_config_free( &conf );  
  526.     mbedtls_ctr_drbg_free( &ctr_drbg );  
  527.     mbedtls_entropy_free( &entropy );  
  528.   
  529. clean_flag = 1;  
  530. }  
  531.   
  532. //ssl close  
  533. int ssl_close( void )  
  534. {  
  535. mbedtls_printf(" ssl close\r\n");  
  536. ssl_clean_up();  
  537. return( ssl_close_socket() );  
  538. }  


测试代码

//*******************************************************************//

[cpp]  view plain  copy
  1. unsigned char t_buff[] = {"GET /dispatcher?user=dididada HTTP/1.1\r\nHost: www.baidu.com:8080\r\nAccept: */*\r\nConnection: keep-alive\r\n\r\n"};  
  2. unsigned char rec_buf[300] = {0};  
  3.  void mbedtls_test(void * parameter)  
  4. {  
  5. int flag = 0;  
  6. flag = ssl_create();  
  7. ssl_write(t_buff, sizeof(t_buff));  
  8. flag = ssl_read(rec_buf, sizeof(rec_buf));  
  9. ssl_close();  
  10. }  
声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop】
推荐阅读
相关标签
  

闽ICP备14008679号