WIZnet W55MH32 的 TLS 硬件加密功能说明

本篇总结

W55MH32 基于 DES、AES、SHA 硬件加密引擎和 TRNG，通过 SDK 移植的 mbedTLS 库实现 TLS 1.2 安全通信，演示通过 HTTPS 获取百度网页内容。

硬件平台：本例程基于 W55MH32L-EVB 开发板运行。

采购推荐：点击前往 WIZnet 官方淘宝店铺 选购 W55MH32L-EVB

硬件模块分工

AES 硬件负责对称加密/解密应用数据；SHA 硬件负责证书签名验证和消息认证码计算；TRNG 负责生成真随机数（Client/Server 随机数、预主密钥）；TOE 引擎提供底层硬连线 TCP/IP 协议栈支撑。

/* network information */
wiz_NetInfo default_net_info = {
    .mac  = {0x00, 0x08, 0xdc, 0x12, 0x22, 0x12},
    .ip   = {10, 0, 1, 140},
    .gw   = {10, 0, 1, 254},
    .sn   = {255, 255, 255, 0},
    .dns  = {8, 8, 8, 8},
    .dhcp = NETINFO_DHCP
};

uint8_t ethernet_buf[ETHERNET_BUF_MAX_SIZE] = {0};
uint8_t ssl_target_ip[4] = {220, 181, 111, 1}; /* baidu */
wiz_tls_context tlsContext;

/* hardware initialization */
rcc_clk_config();
delay_init();
console_usart_init(115200);

printf("W55MH32 TLS Example\r\n");

/* hardware crypt initialization */
*(uint32_t *)(0x400210F0) = 0x01;
*(uint32_t *)(0x40016C00) = 0xCDED3526;
*(uint32_t *)(0x40016CCC) = 0x07;

/* hardware TRNG enable */
TRNG_Out(ENABLE);

tim3_init();

/* wiztoe init */
wiz_toe_init();
getSHAR(default_net_info.mac);
wiz_phy_link_check();

network_init(ethernet_buf, &default_net_info);

硬件加密初始化

0x400210F0 = 0x01 开启加密模块时钟，0x40016C00 = 0xCDED3526 解锁 SYSCFG，TRNG_Out(ENABLE) 开启真随机数发生器，tim3_init() 为 MbedTLS 提供定时器支持。

uint32_t ver = wiz_crypt_version();
printf("WIZnet CARD Secure Test Demo V1.0, secure lib version is V%02x.%02x.%02x.%02x\n",
       ver >> 24, (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF);
printf("WIZnet CARD Crypt Test V1.0 start......\r\n");

/* open socket */
wiz_tls_socket(&tlsContext, SOCKET_SSL_ID, LOCAL_PORT);

/* tls init */
wiz_tls_init(&tlsContext, 2000, (char *)ssl_target_ip, NULL, NULL, NULL);

/* connect server */
connect(tlsContext.socket_fd, (uint8_t *)ssl_target_ip, SSL_TARGET_PORT);

/* tls handshake */
wiz_tls_connect(&tlsContext, (char *)ssl_target_ip, SSL_TARGET_PORT);

printf("W55MH32 MbedTLS Transmission test start......\r\n");

int wiz_tls_init(wiz_tls_context *tlsContext, uint32_t recv_timeout,
                 char *domain_name, char *root_ca,
                 char *client_cert, char *pkey)
{
    int ret = 1;
    const char *pers = "ssl_client1";

    /* Initialize session data */
    tlsContext->entropy   = malloc(sizeof(mbedtls_entropy_context));
    tlsContext->ctr_drbg  = malloc(sizeof(mbedtls_ctr_drbg_context));
    tlsContext->ssl       = malloc(sizeof(mbedtls_ssl_context));
    tlsContext->conf      = malloc(sizeof(mbedtls_ssl_config));
    tlsContext->cacert    = malloc(sizeof(mbedtls_x509_crt));
    tlsContext->clicert   = malloc(sizeof(mbedtls_x509_crt));
    tlsContext->pkey      = malloc(sizeof(mbedtls_pk_context));

    mbedtls_entropy_init(tlsContext->entropy);
    mbedtls_ctr_drbg_init(tlsContext->ctr_drbg);
    mbedtls_ssl_init(tlsContext->ssl);
    mbedtls_ssl_config_init(tlsContext->conf);
    mbedtls_x509_crt_init(tlsContext->cacert);

    /* Seed the random number generator */
    ret = mbedtls_ctr_drbg_seed(tlsContext->ctr_drbg, mbedtls_entropy_func,
                                tlsContext->entropy,
                                (const unsigned char *)pers, strlen(pers));

    /* Parse CA root certificate */
    if (root_ca != NULL) {
        ret = mbedtls_x509_crt_parse(tlsContext->cacert,
                    (const unsigned char *)root_ca, strlen(root_ca) + 1);
        if (ret < 0) {
            printf("mbedtls_x509_crt_parse returned -0x%x\r\n", -ret);
            return -1;
        }
        mbedtls_ssl_set_hostname(tlsContext->ssl, domain_name);
        tlsContext->root_ca_option = MBEDTLS_SSL_VERIFY_REQUIRED;
    } else {
        tlsContext->root_ca_option = MBEDTLS_SSL_VERIFY_NONE;
    }

    /* Configure SSL defaults */
    mbedtls_ssl_config_defaults(tlsContext->conf,
                                MBEDTLS_SSL_IS_CLIENT,
                                MBEDTLS_SSL_TRANSPORT_STREAM,
                                MBEDTLS_SSL_PRESET_DEFAULT);

    mbedtls_ssl_conf_authmode(tlsContext->conf, tlsContext->root_ca_option);
    mbedtls_ssl_conf_ca_chain(tlsContext->conf, tlsContext->cacert, NULL);
    mbedtls_ssl_conf_rng(tlsContext->conf, SSLRandomCB, tlsContext->ctr_drbg);
    mbedtls_ssl_conf_read_timeout(tlsContext->conf, recv_timeout);

    mbedtls_ssl_setup(tlsContext->ssl, tlsContext->conf);
    mbedtls_ssl_set_bio(tlsContext->ssl, (void *)tlsContext->socket_fd,
                        SSLSendCB, SSLRecvCB, SSLRecvTimeOutCB);
    return 1;
}

/* tls init */
wiz_tls_init(&tlsContext, 2000, (char *)ssl_target_ip, NULL, NULL, NULL);

/**
  * @brief  TRNG_Out
  * @param  NewState: ENABLE or DISABLE
  * @retval None
  */
void TRNG_Out(FunctionalState NewState)
{
    if (NewState != DISABLE)
    {
        RCC->RCC_SYSCFG_CONFIG = 0x01;
        SYSCFG->SYSCFG_LOCK = 0xCDED3526;
        SYSCFG->SSC_CLK_EN |= TRNG_RNG_ENABLE;
    }
    else
    {
        RCC->RCC_SYSCFG_CONFIG = 0x00;
        SYSCFG->SSC_CLK_EN &= ~TRNG_RNG_ENABLE;
    }
}

int wiz_tls_connect(wiz_tls_context *tlsContext, char *addr, unsigned int port)
{
    int      ret;
    uint32_t flags;

    printf(" Performing the SSL/TLS handshake...\r\n");
    while ((ret = mbedtls_ssl_handshake(tlsContext->ssl)) != 0)
    {
        if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
            ret != MBEDTLS_ERR_SSL_WANT_WRITE)
        {
            printf(" failed! mbedtls_ssl_handshake returned -0x%x\n\r", -ret);
            return (-1);
        }
        delay_ms(10);
    }

    if (tlsContext->root_ca_option == MBEDTLS_SSL_VERIFY_REQUIRED)
    {
        printf("  . Verifying peer X.509 certificate...\r\n");
        if ((flags = mbedtls_ssl_get_verify_result(tlsContext->ssl)) != 0)
        {
            char vrfy_buf[512];
            printf("failed\r\n");
            mbedtls_x509_crt_verify_info(vrfy_buf, sizeof(vrfy_buf), "  ! ", flags);
            printf("%s\r\n", vrfy_buf);
            return -1;
        }
        else
        {
            printf("ok\r\n");
        }
    }
    printf(" ok\n\r    [ Ciphersuite is %s ]\n\r",
           mbedtls_ssl_get_ciphersuite(tlsContext->ssl));
    return (0);
}

/*
 * Perform the SSL handshake
 */
int mbedtls_ssl_handshake(mbedtls_ssl_context *ssl)
{
    int ret = 0;

    /* Sanity checks */
    if (ssl == NULL || ssl->conf == NULL) {
        return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
    }

    /* Main handshake loop */
    while (ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
        ret = mbedtls_ssl_handshake_step(ssl);
        if (ret != 0) break;
    }

    return ret;
}

unsigned int wiz_tls_read(wiz_tls_context *tlsContext, unsigned char *readbuf, unsigned int len)
{
    return mbedtls_ssl_read(tlsContext->ssl, readbuf, len);
}

unsigned int wiz_tls_write(wiz_tls_context *tlsContext, unsigned char *writebuf, unsigned int len)
{
    return mbedtls_ssl_write(tlsContext->ssl, writebuf, len);
}

printf("W55MH32 get baidu.com html content......\r\n");
mbedtls_ssl_conf_read_timeout(tlsContext.conf, 200);
sprintf(ethernet_buf,
        "GET / HTTP/1.1\r\nHost: www.baidu.com\r\n"
        "User-Agent: W55MH32/1.0\r\nAccept: text/html\r\n"
        "Connection: close\r\n\r\n");
wiz_tls_write(&tlsContext, (unsigned char *)ethernet_buf, strlen(ethernet_buf));

while (1)
{
    recv_len = wiz_tls_read(&tlsContext, ethernet_buf, ETHERNET_BUF_MAX_SIZE - 1);

    if (recv_len > 0)
    {
        printf("recv_len:%d\r\n", recv_len);
        ethernet_buf[recv_len] = '\0';
        printf("Received: %s", ethernet_buf);
    }
}

数据通信流程

应用数据使用 AES 硬件模块进行加密，使用 SHA 硬件和会话 MAC 密钥计算消息认证码（MAC）。加密后的数据和 MAC 被发送给另一方，接收方使用 AES 硬件解密数据，并使用 SHA 硬件验证 MAC，验证成功保证了数据的完整性和真实性。

密码套件格式

格式为「密钥交换算法 + 签名算法（认证算法） + 对称加密算法 + 摘要算法」。例如 TLS_RSA_WITH_AES_128_GCM_SHA256 表示：RSA 密钥交换与认证、AES-128-GCM 对称加密、SHA256 摘要算法。密钥交换算法和签名算法可以相同时合二为一。