基于MBE技术 基于mbd的三维工艺

引言：嵌入式应用的领域越来越广泛，功能需求也越来越复杂，有些嵌入式产品要求在产品出厂后，使用过程中保留有固件升级的功能，以保证用户可以使用最新的功能和及时修正产品bug支持固件升级就意味着在软件上留有“后门”（Bootloader与外界的交互），如果这个“后门”保护不当会造成固件代码泄露，针对这一安全隐患，本文讨论的话题就是如何提高嵌入式Bootloader程序的安全性，有效防止黑客的hacking和cloning，借助的工具是arm的mbedTLS加密算法库。

我们先来了解一下什么是mbedTLSMbedTLS前身是开源加密算法库PolarSLL，现已被arm公司收购并由arm技术团队进行维护更新，是对TLS和SSL协议实现的算法库mbedTLS的目标是：易于理解，使用，集成和扩展。

mbedTLS核心代码用C编程语言编写，实现SSL模块和各种加密算法，并提供各种加密算法的自测试代码和其他TLS/SSL算法库实现不同，mbedTLS主要是面向小型嵌入式设备，代码紧凑，最小完整的TLS堆栈需要60KB的程序空间和64KB的RAM空间，而且执行效率高，可以说是行业内最小巧的SSL加密算法库。

另外，mbedTLS是高度模块化的设计：每个组件，如加密函数，可以独立于框架的其余部分使用mbedTLS完全是由C语言编写的，没有外部依赖，因此，mbedTLS是应用于嵌入式系统最理想的TLS加密算法库。

更重要的一点是，mbedTSL是完全OpenSource的，支持Apache 2.0 license 或者GPL 2.0 license双重许可，可以自由应用于商业项目中上海润欣科技正在开发一个用于智能门锁等领域的指纹模块项目，用到的主控芯片是基于ARM Cortex-M4内核的

MCU，但是这个MCU没有代码读出保护功能，为了避免产品被非法克隆，必须引入一种保护机制来提高产品的安全性我们使用mbedTSL算法库中的RSASSA-PSS数字签名算法对MCU芯片中的UID和指纹传感器UID来进行签名(Sign)和验证(Verify)，保证每个被签名产品的性(不可复制)和合法性。

 原文签名（Sign）以及签名验证（Verify）一、具体的实施步骤：第1步：将mbedTLS生成的密钥对中的私钥存放与本地服务器，并禁止外部访问，以保证私钥的安全性；第2步：利用MCU的UID和指纹传感器的UID通过上述本地服务器上的私钥及签名生成工具生成数字签名sig文件；

第3步：将上述第二步生成的sig签名文件保存到Bootloader特定区域；第4步：将mbedTLS生成的密钥对中的公钥保存到APP固件中；第5步：Bootloader更新APP固件时，利用APP中的公钥对Bootloader中的签名文件sig进行校验（Verify），校验通过，说明Bootloader和APP固件均为原厂合法固件，否则Bootloader拒绝引导执行APP固件，达到保护产品软硬版权的目的。

二、使用到的mbedTLS资源和API函数1、mbedTSL代码包目录下使用VS2010或以上版本生成RSA密钥对生成工具：rsa_genkey.exe，用来生成上述步骤中第一步中的密钥对；2、mbedTSL代码包目录下使用VS2010或以上版本生成RSASSA签名生成工具rsa_sign_pss.exe，以用来生成上述步骤中第二步中的sig文件；

3、mbedTSL代码包目录下使用VS2010或以上版本生成RSASSA签名验证工具rsa_verify_pss.exe，已确保代码的正确性；4、MCU代码中使用到的mbedTLS API函数：/* * Initialize an RSA context 初始化RSA算法内容

 */void mbedtls_rsa_init( mbedtls_rsa_context *ctx,               int padding,               int hash_id

){    memset( ctx, 0,sizeof( mbedtls_rsa_context ));    mbedtls_rsa_set_padding( ctx, padding, hash_id

);#if defined(MBEDTLS_THREADING_C)    mbedtls_mutex_init(&ctx->mutex );#endif}#if defined(MBEDTLS_PKCS1_V21)

/* * Implementation of the PKCS#1 v2.1 RSASSA-PSS-SIGN function* RSASSA-PSS签名算法实现函数 */int mbedtls_rsa_rsassa_pss_sign

( mbedtls_rsa_context *ctx,                         int (*f_rng)(void *, unsigned char *, size_t),                         void

*p_rng,                         int mode,                         mbedtls_md_type_t md_alg,                         unsigned int hashlen

,                         const unsigned char *hash,                         unsigned char *sig ){    size_t olen

;    unsigned char *p = sig;    unsigned char salt[MBEDTLS_MD_MAX_SIZE];    unsigned int slen, hlen, offset

= 0;    int ret;    size_t msb;    const mbedtls_md_info_t *md_info;    mbedtls_md_context_t md_ctx;if

( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA

);if( f_rng ==NULL)return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );    olen = ctx->len;if( md_alg != MBEDTLS_MD_NONE

){        /* Gather length of hash to sign */        md_info = mbedtls_md_info_from_type( md_alg );if

( md_info ==NULL)return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );        hashlen = mbedtls_md_get_size( md_info

);}    md_info = mbedtls_md_info_from_type((mbedtls_md_type_t) ctx->hash_id );if( md_info ==NULL)return

( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );    hlen = mbedtls_md_get_size( md_info );    slen = hlen;if( olen

< hlen + slen + 2 )return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );    memset( sig, 0, olen );    /* Generate salt of length slen */

if(( ret = f_rng( p_rng, salt, slen ))!= 0 )return( MBEDTLS_ERR_RSA_RNG_FAILED + ret );    /* Note: EMSA-PSS encoding is over the length of N - 1 bits */

    msb = mbedtls_mpi_bitlen(&ctx->N )- 1;    p += olen - hlen * 2 - 2;*p++= 0x01;    memcpy( p, salt

, slen );    p += slen;    mbedtls_md_init(&md_ctx );if(( ret = mbedtls_md_setup(&md_ctx, md_info, 0

))!= 0 )goto exit;    /* Generate H = Hash( M ) */if(( ret = mbedtls_md_starts(&md_ctx ))!= 0 )goto exit

;if(( ret = mbedtls_md_update(&md_ctx, p, 8 ))!= 0 )goto exit;if(( ret = mbedtls_md_update(&md_ctx, hash

, hashlen ))!= 0 )goto exit;if(( ret = mbedtls_md_update(&md_ctx, salt, slen ))!= 0 )goto exit;if(( ret

= mbedtls_md_finish(&md_ctx, p ))!= 0 )goto exit;    /* Compensate for boundary condition when applying mask */

if( msb % 8 == 0 )        offset = 1;    /* maskedDB: Apply dbMask to DB */if(( ret = mgf_mask( sig +

offset, olen - hlen - 1 - offset, p, hlen,&md_ctx ))!= 0 )goto exit;    msb = mbedtls_mpi_bitlen(&ctx

->N )- 1;    sig[0]&= 0xFF >>( olen * 8 - msb );    p += hlen;*p++= 0xBC;    mbedtls_zeroize( salt,sizeof

( salt ));exit:    mbedtls_md_free(&md_ctx );if( ret != 0 )return( ret );return(( mode == MBEDTLS_RSA_PUBLIC

)? mbedtls_rsa_public(  ctx, sig, sig ): mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig ));}#endif /* MBEDTLS_PKCS1_V21 */

#if defined(MBEDTLS_PKCS1_V21)/* * Implementation of the PKCS#1 v2.1 RSASSA-PSS-VERIFY function * RSASSA-PSS签名算法校验函数

 */int mbedtls_rsa_rsassa_pss_verify_ext( mbedtls_rsa_context *ctx,                               int

(*f_rng)(void *, unsigned char *, size_t),                               void *p_rng,                               int mode

,                               mbedtls_md_type_t md_alg,                               unsigned int hashlen

,                               const unsigned char *hash,                               mbedtls_md_type_t mgf1_hash_id

,                               int expected_salt_len,                               const unsigned char

*sig ){    int ret;    size_t siglen;    unsigned char *p;    unsigned char *hash_start;    unsigned char result

[MBEDTLS_MD_MAX_SIZE];    unsigned char zeros[8];    unsigned int hlen;    size_t observed_salt_len, msb

;    const mbedtls_md_info_t *md_info;    mbedtls_md_context_t md_ctx;    unsigned char buf[MBEDTLS_MPI_MAX_SIZE

];if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA

);    siglen = ctx->len;if( siglen sizeof( buf ))return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA

);    ret =( mode == MBEDTLS_RSA_PUBLIC )? mbedtls_rsa_public(  ctx, sig, buf ): mbedtls_rsa_private(

ctx, f_rng, p_rng, sig, buf );if( ret != 0 )return( ret );    p = buf;if( buf[siglen - 1]!= 0xBC )return

( MBEDTLS_ERR_RSA_INVALID_PADDING );if( md_alg != MBEDTLS_MD_NONE ){        /* Gather length of hash to sign */

        md_info = mbedtls_md_info_from_type( md_alg );if( md_info ==NULL)return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA

);        hashlen = mbedtls_md_get_size( md_info );}    md_info = mbedtls_md_info_from_type( mgf1_hash_id

);if( md_info ==NULL)return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );    hlen = mbedtls_md_get_size( md_info

);    memset( zeros, 0, 8 );    /*     * Note: EMSA-PSS verification is over the length of N - 1 bits

     */    msb = mbedtls_mpi_bitlen(&ctx->N )- 1;if( buf[0]>>( 8 - siglen * 8 + msb ))return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA

);    /* Compensate for boundary condition when applying mask */if( msb % 8 == 0 ){        p++;        siglen

-= 1;}if( siglen < hlen + 2 )return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );    hash_start = p + siglen - hlen

- 1;    mbedtls_md_init(&md_ctx );if(( ret = mbedtls_md_setup(&md_ctx, md_info, 0 ))!= 0 )goto exit;    ret

= mgf_mask( p, siglen - hlen - 1, hash_start, hlen,&md_ctx );if( ret != 0 )goto exit;    buf[0]&= 0xFF

>>( siglen * 8 - msb );while( p < hash_start - 1 &&*p == 0 )        p++;if(*p++!= 0x01 ){        ret

= MBEDTLS_ERR_RSA_INVALID_PADDING;goto exit;}    observed_salt_len = hash_start - p;if( expected_salt_len

!= MBEDTLS_RSA_SALT_LEN_ANY &&        observed_salt_len !=(size_t) expected_salt_len ){        ret = MBEDTLS_ERR_RSA_INVALID_PADDING

;goto exit;}    /*     * Generate H = Hash( M )     */    ret = mbedtls_md_starts(&md_ctx );if( ret !=

0 )goto exit;    ret = mbedtls_md_update(&md_ctx, zeros, 8 );if( ret != 0 )goto exit;    ret = mbedtls_md_update

(&md_ctx, hash, hashlen );if( ret != 0 )goto exit;    ret = mbedtls_md_update(&md_ctx, p, observed_salt_len

);if( ret != 0 )goto exit;    ret = mbedtls_md_finish(&md_ctx, result );if( ret != 0 )goto exit;if( memcmp

( hash_start, result, hlen )!= 0 ){        ret = MBEDTLS_ERR_RSA_VERIFY_FAILED;goto exit;}exit:    mbedtls_md_free

(&md_ctx );return( ret );}/* * Simplified PKCS#1 v2.1 RSASSA-PSS-VERIFY function */int mbedtls_rsa_rsassa_pss_verify

( mbedtls_rsa_context *ctx,                           int (*f_rng)(void *, unsigned char *, size_t),                           void

*p_rng,                           int mode,                           mbedtls_md_type_t md_alg,                           unsigned int hashlen

,                           const unsigned char *hash,                           const unsigned char

*sig ){    mbedtls_md_type_t mgf1_hash_id =( ctx->hash_id != MBEDTLS_MD_NONE )?(mbedtls_md_type_t) ctx

->hash_id: md_alg;return( mbedtls_rsa_rsassa_pss_verify_ext( ctx, f_rng, p_rng, mode,                                       md_alg

, hashlen, hash,                                       mgf1_hash_id, MBEDTLS_RSA_SALT_LEN_ANY,                                       sig

));}#endif /* MBEDTLS_PKCS1_V21 */文章出处：润欣科技