+
+ | 参数 |
+ 类型 |
+ 说明 |
+
+
+ | method |
+ String |
+ action_reply 表示是设备端执行完指定的行为向云端回复的响应 |
+
+
+ | clientToken |
+ String |
+ 消息 ID，回复的消息将会返回该数据, 用于请求响应消息的对比。 |
+
+
+
+ | code |
+ Integer |
+ 行为执行结果，0表示成功。 |
+
+
+ | status |
+ String |
+ 行为执行失败后的错误信息描述。 |
+
+
+ | response |
+ JSON |
+ 设备行为中定义的返回参数，设备行为执行成功后，向云端返回执行结果 |
+
+
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/数据模板开发/数据模板应用开发.md b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/数据模板开发/数据模板应用开发.md
new file mode 100644
index 00000000..16afdb32
--- /dev/null
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/数据模板开发/数据模板应用开发.md
@@ -0,0 +1,121 @@
+## 数据模板业务逻辑开发
+数据模板示例data_template_sample.c已实现数据、事件收发及响应的通用处理框架。可以基于此示例开发业务逻辑，上下行业务逻辑添加的入口函数分别为 deal_up_stream_user_logic 、deal_down_stream_user_logic。可以参考智能灯的场景示例 light_data_template_sample.c 添加业务处理逻辑。
+
+### 下行业务逻辑实现
+- 服务端下行的数据，SDK已按数据模板协议完成了json数据的解析。ProductDataDefine是第三步中根据在平台定义的产品数据模板生成的模板结构体，由定义的各属性构成成员变量。入参pData所指向的属性数据，从服务端下行数据中，SDK已经按数据模板协议完成了属性数据的解析，用户在下行逻辑处理的函数里边可以直接使用解析好的数据添加业务逻辑即可。
+- 用户根据数据模板数据pData进行相应的业务逻辑处理。
+```
+/*用户需要实现的下行数据的业务逻辑,pData除字符串变量已实现用户定义的所有其他变量值解析赋值，待用户实现业务逻辑*/
+static void deal_down_stream_user_logic(void *client, ProductDataDefine * pData)
+{
+ Log_d("someting about your own product logic wait to be done");
+}
+```
+
+- 示例用法:
+
+```
+/*智能灯属性数据模板*/
+typedef struct _ProductDataDefine {
+ TYPE_DEF_TEMPLATE_BOOL m_light_switch;
+ TYPE_DEF_TEMPLATE_ENUM m_color;
+ TYPE_DEF_TEMPLATE_INT m_brightness;
+ TYPE_DEF_TEMPLATE_STRING m_name[MAX_STR_NAME_LEN+1];
+} ProductDataDefine;
+
+/*示例灯光控制处理逻辑*/
+static void deal_down_stream_user_logic(void *client,ProductDataDefine *light)
+{
+ int i;
+ const char * ansi_color = NULL;
+ const char * ansi_color_name = NULL;
+ char brightness_bar[] = "||||||||||||||||||||";
+ int brightness_bar_len = strlen(brightness_bar);
+
+ /*灯光颜色*/
+ switch(light->m_color) {
+ case eCOLOR_RED:
+ ansi_color = ANSI_COLOR_RED;
+ ansi_color_name = " RED ";
+ break;
+ case eCOLOR_GREEN:
+ ansi_color = ANSI_COLOR_GREEN;
+ ansi_color_name = "GREEN";
+ break;
+ case eCOLOR_BLUE:
+ ansi_color = ANSI_COLOR_BLUE;
+ ansi_color_name = " BLUE";
+ break;
+ default:
+ ansi_color = ANSI_COLOR_YELLOW;
+ ansi_color_name = "UNKNOWN";
+ break;
+ }
+
+
+ /* 灯光亮度显示条 */
+ brightness_bar_len = (light->m_brightness >= 100)?brightness_bar_len:(int)((light->m_brightness * brightness_bar_len)/100);
+ for (i = brightness_bar_len; i < strlen(brightness_bar); i++) {
+ brightness_bar[i] = '-';
+ }
+
+ if(light->m_light_switch){
+ /* 灯光开启式，按照控制参数展示 */
+ HAL_Printf( "%s[ lighting ]|[color:%s]|[brightness:%s]|[%s]\n" ANSI_COLOR_RESET,\
+ ansi_color,ansi_color_name,brightness_bar,light->m_name);
+ }else{
+ /* 灯光关闭展示 */
+ HAL_Printf( ANSI_COLOR_YELLOW"[ light is off ]|[color:%s]|[brightness:%s]|[%s]\n" ANSI_COLOR_RESET,\
+ ansi_color_name,brightness_bar,light->m_name);
+ }
+
+#ifdef EVENT_POST_ENABLED
+ if(eCHANGED == sg_DataTemplate[0].state){
+ if(light->m_light_switch){
+ memset(sg_message, 0, MAX_EVENT_STR_MESSAGE_LEN);
+ strcpy(sg_message,"light on");
+ sg_status = 1;
+ }else{
+ memset(sg_message, 0, MAX_EVENT_STR_MESSAGE_LEN);
+ strcpy(sg_message,"light off");
+ sg_status = 0;
+ }
+ IOT_Event_setFlag(client, FLAG_EVENT0);/*灯的开关状态发生变化时置位事件，在eventPostCheck中会将置位的事件上报*/
+ }
+#endif
+}
+```
+
+### 上行业务逻辑实现
+
+- 设备端根据业务场景需要，对设备端数据属性采取一定策略进行监测处理，用户可以在***deal_up_stream_user_logic***中将需要上报的属性更新给入参pReportDataList属性上报列表及需要上报的属性个数，数据模板的示例处理框架，在***IOT_Template_JSON_ConstructReportArray***中会将属性数据列表处理为数据模板的协议格式，***IOT_Template_Report***将数据发送给服务端。
+
+```
+/*用户根据业务修改属性值，然后设置属性状态为eCHANGED*/
+static void _refresh_local_property(void)
+{
+ //add your local property refresh logic
+}
+
+
+/*用户需要实现的上行数据的业务逻辑,此处仅供示例*/
+static int deal_up_stream_user_logic(DeviceProperty *pReportDataList[], int *pCount)
+{
+ int i, j;
+
+ /*监测是否需要更新本地数据*/
+ _refresh_local_property();
+
+ /*将变化的属性更新到上报列表*/
+ for (i = 0, j = 0; i < TOTAL_PROPERTY_COUNT; i++) {
+ if(eCHANGED == sg_DataTemplate[i].state) {
+ pReportDataList[j++] = &(sg_DataTemplate[i].data_property);
+ sg_DataTemplate[i].state = eNOCHANGE;
+ }
+ }
+ *pCount = j;
+
+ return (*pCount > 0)?QCLOUD_RET_SUCCESS:QCLOUD_ERR_FAILURE;
+}
+
+```
\ No newline at end of file
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/设备固件升级.md b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/设备固件升级.md
new file mode 100644
index 00000000..b42fa5a7
--- /dev/null
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/docs/设备固件升级.md
@@ -0,0 +1,129 @@
+## 操作场景
+设备固件升级又称 OTA，是物联网通信服务的重要组成部分。当物联设备有新功能或者需要修复漏洞时，设备可以通过 OTA 服务快速的进行固件升级。
+
+
+## 实现原理
+固件升级的过程中，需要设备订阅下面两个 Topic 来实现与云端的通信，如下图所示：
+
+示例：
+```php
+$ota/report/${productID}/${deviceName}
+用于发布（上行）消息，设备上报版本号及下载、升级进度到云端
+$ota/update/${productID}/${deviceName}
+用于订阅（下行）消息，设备接收云端的升级消息
+```
+
+
+## 操作流程
+设备的升级流程如下所示：
+
+1. 设备上报当前版本号。设备端通过 MQTT 协议发布一条消息到 Topic `$ota/report/${productID/${deviceName}`，进行版本号的上报，消息为 json 格式，内容如下：
+```json
+{
+ "type": "report_version",
+ "report":{
+ "version": "0.1"
+ }
+}
+// type：消息类型
+// version：上报的版本号
+```
+2. 然后您可以在控制台上传固件。
+3. 在控制台将指定的设备升级到指定的版本。
+4. 触发固件升级操作后，设备端会通过订阅的 Topic `$ota/update/${productID}/${deviceName}` 收到固件升级的消息，内容如下：
+``` json
+{
+ "file_size": 708482,
+ "md5sum": "36eb5951179db14a631463a37a9322a2",
+ "type": "update_firmware",
+ "url": "https://ota-1255858890.cos.ap-guangzhou.myqcloud.com",
+ "version": "0.2"
+}
+// type：消息类型为update_firmware
+// version：升级版本
+// url：下载固件的url
+// md5asum：固件的MD5值
+// file_size：固件大小，单位为字节
+```
+5. 设备在收到固件升级的消息后，根据 URL 下载固件，下载的过程中设备 SDK 会通过 Topic `$ota/report/${productID}/${deviceName}`不断的上报下载进度，上报的内容如下：
+```json
+{
+ "type": "report_progress",
+ "report":{
+ "progress":{
+ "state":"downloading",
+ "percent":"10",
+ "result_code":"0",
+ "result_msg":""
+ },
+ "version": "0.2"
+ }
+}
+// type：消息类型
+// state：状态为正在下载中
+// percent：当前下载进度，百分比
+```
+6. 当设备下载完固件，设备需要通过 Topic `$ota/report/${productID}/${deviceName}`上报一条开始升级的消息，内容如下：
+```json
+{
+ "type": "report_progress",
+ "report":{
+ "progress":{
+ "state":"burning",
+ "result_code":"0",
+ "result_msg":""
+ },
+ "version": "0.2"
+ }
+}
+// type：消息类型
+// state：状态为烧制中
+```
+7. 设备固件升级完成后，再向 Topic `$ota/report/${productID}/${deviceName}`上报升级成功消息，内容如下：
+```json
+{
+ "type": "report_progress",
+ "report":{
+ "progress":{
+ "state":"done",
+ "result_code":"0",
+ "result_msg":""
+ },
+ "version": "0.2"
+ }
+}
+// type：消息类型
+// state：状态为已完成
+```
+
+>!在下载固件或升级固件的过程中，如果失败，则通过 Topic `$ota/report/${productID}/${deviceName}`上报升级失败消息，内容如下：
+
+```json
+{
+ "type": "report_progress",
+ "report":{
+ "progress":{
+ "state":"fail",
+ "result_code":"-1",
+ "result_msg":"time_out"
+ },
+ "version": "0.2"
+ }
+}
+// state：状态为失败
+// result_code：错误码，-1：下载超时；-2：文件不存在；-3：签名过期；-4:MD5不匹配；-5：更新固件失败
+// result_msg：错误消息
+```
+
+## OTA断点续传
+物联网设备有部分场景处于弱网环境，在这个场景下连接会不稳定，固件下载会中断的情况出现。如果每次都从0偏移开始下载固件，则弱网环境有可能一直无法完成全部固件下载，因此固件的断点续传功能特别必要。
+
+断点续传就是从文件上次中断的地方开始重新下载或上传，要实现断点续传的功能，需要设备端记录固件下载的中断位置，同时记录下载固件的md5、文件大小、版本信息。
+
+平台针对OTA中断的场景，设备侧report设备的版本，如果上报的版本号与要升级的目标版本号不一致，则平台会再次下发固件升级消息，设备获取到升级的目标固件的信息与本地记录的中断的固件信息比较，确定为同一固件后，基于断点继续下载。
+
+SDK提供的OTA sample示例了断点续传的断点记录及续传实现，示例是基于json文件实现记录描述，对于没有文件系统的修改这部分实现即可。
+
+带断点续传的OTA升级流程如下，弱网环境下第3步到第6步有可能会多次执行，没有执行第7步，执行第3步，设备端都会收到第4步的消息。
+
+
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aes.c b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aes.c
index a186dee9..a251cce2 100644
--- a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aes.c
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aes.c
@@ -55,8 +55,10 @@
#if !defined(MBEDTLS_AES_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void mbedtls_zeroize( void *v, size_t n ) {
- volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
+static void mbedtls_zeroize( void *v, size_t n )
+{
+ volatile unsigned char *p = (unsigned char*)v;
+ while ( n-- ) *p++ = 0;
}
/*
@@ -91,8 +93,7 @@ static int aes_padlock_ace = -1;
/*
* Forward S-box
*/
-static const unsigned char FSb[256] =
-{
+static const unsigned char FSb[256] = {
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
@@ -218,8 +219,7 @@ static const uint32_t FT3[256] = { FT };
/*
* Reverse S-box
*/
-static const unsigned char RSb[256] =
-{
+static const unsigned char RSb[256] = {
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
@@ -345,8 +345,7 @@ static const uint32_t RT3[256] = { RT };
/*
* Round constants
*/
-static const uint32_t RCON[10] =
-{
+static const uint32_t RCON[10] = {
0x00000001, 0x00000002, 0x00000004, 0x00000008,
0x00000010, 0x00000020, 0x00000040, 0x00000080,
0x0000001B, 0x00000036
@@ -395,8 +394,7 @@ static void aes_gen_tables( void )
/*
* compute pow and log tables over GF(2^8)
*/
- for( i = 0, x = 1; i < 256; i++ )
- {
+ for ( i = 0, x = 1; i < 256; i++ ) {
pow[i] = x;
log[x] = i;
x = ( x ^ XTIME( x ) ) & 0xFF;
@@ -405,8 +403,7 @@ static void aes_gen_tables( void )
/*
* calculate the round constants
*/
- for( i = 0, x = 1; i < 10; i++ )
- {
+ for ( i = 0, x = 1; i < 10; i++ ) {
RCON[i] = (uint32_t) x;
x = XTIME( x ) & 0xFF;
}
@@ -417,14 +414,17 @@ static void aes_gen_tables( void )
FSb[0x00] = 0x63;
RSb[0x63] = 0x00;
- for( i = 1; i < 256; i++ )
- {
+ for ( i = 1; i < 256; i++ ) {
x = pow[255 - log[i]];
- y = x; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
- x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
- x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
- x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
+ y = x;
+ y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
+ x ^= y;
+ y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
+ x ^= y;
+ y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
+ x ^= y;
+ y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
x ^= y ^ 0x63;
FSb[i] = (unsigned char) x;
@@ -434,8 +434,7 @@ static void aes_gen_tables( void )
/*
* generate the forward and reverse tables
*/
- for( i = 0; i < 256; i++ )
- {
+ for ( i = 0; i < 256; i++ ) {
x = FSb[i];
y = XTIME( x ) & 0xFF;
z = ( y ^ x ) & 0xFF;
@@ -471,7 +470,7 @@ void mbedtls_aes_init( mbedtls_aes_context *ctx )
void mbedtls_aes_free( mbedtls_aes_context *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL )
return;
mbedtls_zeroize( ctx, sizeof( mbedtls_aes_context ) );
@@ -482,59 +481,61 @@ void mbedtls_aes_free( mbedtls_aes_context *ctx )
*/
#if !defined(MBEDTLS_AES_SETKEY_ENC_ALT)
int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
- unsigned int keybits )
+ unsigned int keybits )
{
unsigned int i;
uint32_t *RK;
#if !defined(MBEDTLS_AES_ROM_TABLES)
- if( aes_init_done == 0 )
- {
+ if ( aes_init_done == 0 ) {
aes_gen_tables();
aes_init_done = 1;
}
#endif
- switch( keybits )
- {
- case 128: ctx->nr = 10; break;
- case 192: ctx->nr = 12; break;
- case 256: ctx->nr = 14; break;
- default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
+ switch ( keybits ) {
+ case 128:
+ ctx->nr = 10;
+ break;
+ case 192:
+ ctx->nr = 12;
+ break;
+ case 256:
+ ctx->nr = 14;
+ break;
+ default :
+ return ( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
- if( aes_padlock_ace == -1 )
+ if ( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
- if( aes_padlock_ace )
+ if ( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
- ctx->rk = RK = ctx->buf;
+ ctx->rk = RK = ctx->buf;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
- if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
- return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
+ if ( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
+ return ( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
#endif
- for( i = 0; i < ( keybits >> 5 ); i++ )
- {
+ for ( i = 0; i < ( keybits >> 5 ); i++ ) {
GET_UINT32_LE( RK[i], key, i << 2 );
}
- switch( ctx->nr )
- {
+ switch ( ctx->nr ) {
case 10:
- for( i = 0; i < 10; i++, RK += 4 )
- {
+ for ( i = 0; i < 10; i++, RK += 4 ) {
RK[4] = RK[0] ^ RCON[i] ^
- ( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
RK[5] = RK[1] ^ RK[4];
RK[6] = RK[2] ^ RK[5];
@@ -544,13 +545,12 @@ int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
case 12:
- for( i = 0; i < 8; i++, RK += 6 )
- {
+ for ( i = 0; i < 8; i++, RK += 6 ) {
RK[6] = RK[0] ^ RCON[i] ^
- ( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
RK[7] = RK[1] ^ RK[6];
RK[8] = RK[2] ^ RK[7];
@@ -562,23 +562,22 @@ int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
case 14:
- for( i = 0; i < 7; i++, RK += 8 )
- {
+ for ( i = 0; i < 7; i++, RK += 8 ) {
RK[8] = RK[0] ^ RCON[i] ^
- ( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
RK[9] = RK[1] ^ RK[8];
RK[10] = RK[2] ^ RK[9];
RK[11] = RK[3] ^ RK[10];
RK[12] = RK[4] ^
- ( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
RK[13] = RK[5] ^ RK[12];
RK[14] = RK[6] ^ RK[13];
@@ -587,7 +586,7 @@ int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
break;
}
- return( 0 );
+ return ( 0 );
}
#endif /* !MBEDTLS_AES_SETKEY_ENC_ALT */
@@ -596,7 +595,7 @@ int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
*/
#if !defined(MBEDTLS_AES_SETKEY_DEC_ALT)
int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
- unsigned int keybits )
+ unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
@@ -606,26 +605,25 @@ int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
- if( aes_padlock_ace == -1 )
+ if ( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
- if( aes_padlock_ace )
+ if ( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
- ctx->rk = RK = ctx->buf;
+ ctx->rk = RK = ctx->buf;
/* Also checks keybits */
- if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
+ if ( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
- if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
- {
+ if ( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) ) {
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
- (const unsigned char *) cty.rk, ctx->nr );
+ (const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
@@ -637,10 +635,8 @@ int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
*RK++ = *SK++;
*RK++ = *SK++;
- for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
- {
- for( j = 0; j < 4; j++, SK++ )
- {
+ for ( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 ) {
+ for ( j = 0; j < 4; j++, SK++ ) {
*RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^
RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^
RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
@@ -656,7 +652,7 @@ int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
exit:
mbedtls_aes_free( &cty );
- return( ret );
+ return ( ret );
}
#endif /* !MBEDTLS_AES_SETKEY_DEC_ALT */
@@ -719,13 +715,16 @@ void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
RK = ctx->rk;
- GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
- GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
- GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
- GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
+ GET_UINT32_LE( X0, input, 0 );
+ X0 ^= *RK++;
+ GET_UINT32_LE( X1, input, 4 );
+ X1 ^= *RK++;
+ GET_UINT32_LE( X2, input, 8 );
+ X2 ^= *RK++;
+ GET_UINT32_LE( X3, input, 12 );
+ X3 ^= *RK++;
- for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
- {
+ for ( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- ) {
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
@@ -733,28 +732,28 @@ void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
- ( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
- ( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
- ( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
- ( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
- ( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
+ ( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
@@ -776,13 +775,16 @@ void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
RK = ctx->rk;
- GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
- GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
- GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
- GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
+ GET_UINT32_LE( X0, input, 0 );
+ X0 ^= *RK++;
+ GET_UINT32_LE( X1, input, 4 );
+ X1 ^= *RK++;
+ GET_UINT32_LE( X2, input, 8 );
+ X2 ^= *RK++;
+ GET_UINT32_LE( X3, input, 12 );
+ X3 ^= *RK++;
- for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
- {
+ for ( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- ) {
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
@@ -790,28 +792,28 @@ void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
- ( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
- ( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
+ ( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
- ( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
- ( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
+ ( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
- ( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
- ( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
+ ( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
- ( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
- ( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
- ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
- ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+ ( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
+ ( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
+ ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+ ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
@@ -824,20 +826,19 @@ void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
* AES-ECB block encryption/decryption
*/
int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
- int mode,
- const unsigned char input[16],
- unsigned char output[16] )
+ int mode,
+ const unsigned char input[16],
+ unsigned char output[16] )
{
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
- if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
- return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
+ if ( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
+ return ( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
#endif
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
- if( aes_padlock_ace )
- {
- if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
- return( 0 );
+ if ( aes_padlock_ace ) {
+ if ( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
+ return ( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
@@ -845,12 +846,12 @@ int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
}
#endif
- if( mode == MBEDTLS_AES_ENCRYPT )
+ if ( mode == MBEDTLS_AES_ENCRYPT )
mbedtls_aes_encrypt( ctx, input, output );
else
mbedtls_aes_decrypt( ctx, input, output );
- return( 0 );
+ return ( 0 );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
@@ -858,23 +859,22 @@ int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
* AES-CBC buffer encryption/decryption
*/
int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
int i;
unsigned char temp[16];
- if( length % 16 )
- return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
+ if ( length % 16 )
+ return ( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
- if( aes_padlock_ace )
- {
- if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
- return( 0 );
+ if ( aes_padlock_ace ) {
+ if ( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
+ return ( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
@@ -882,14 +882,12 @@ int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
}
#endif
- if( mode == MBEDTLS_AES_DECRYPT )
- {
- while( length > 0 )
- {
+ if ( mode == MBEDTLS_AES_DECRYPT ) {
+ while ( length > 0 ) {
memcpy( temp, input, 16 );
mbedtls_aes_crypt_ecb( ctx, mode, input, output );
- for( i = 0; i < 16; i++ )
+ for ( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
@@ -898,12 +896,9 @@ int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
output += 16;
length -= 16;
}
- }
- else
- {
- while( length > 0 )
- {
- for( i = 0; i < 16; i++ )
+ } else {
+ while ( length > 0 ) {
+ for ( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_aes_crypt_ecb( ctx, mode, output, output );
@@ -915,7 +910,7 @@ int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
}
}
- return( 0 );
+ return ( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
@@ -924,21 +919,19 @@ int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
* AES-CFB128 buffer encryption/decryption
*/
int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
- int mode,
- size_t length,
- size_t *iv_off,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ size_t *iv_off,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
int c;
size_t n = *iv_off;
- if( mode == MBEDTLS_AES_DECRYPT )
- {
- while( length-- )
- {
- if( n == 0 )
+ if ( mode == MBEDTLS_AES_DECRYPT ) {
+ while ( length-- ) {
+ if ( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
c = *input++;
@@ -947,12 +940,9 @@ int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
n = ( n + 1 ) & 0x0F;
}
- }
- else
- {
- while( length-- )
- {
- if( n == 0 )
+ } else {
+ while ( length-- ) {
+ if ( n == 0 )
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
@@ -963,39 +953,38 @@ int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
*iv_off = n;
- return( 0 );
+ return ( 0 );
}
/*
* AES-CFB8 buffer encryption/decryption
*/
int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
- int mode,
- size_t length,
- unsigned char iv[16],
- const unsigned char *input,
- unsigned char *output )
+ int mode,
+ size_t length,
+ unsigned char iv[16],
+ const unsigned char *input,
+ unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
- while( length-- )
- {
+ while ( length-- ) {
memcpy( ov, iv, 16 );
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
- if( mode == MBEDTLS_AES_DECRYPT )
+ if ( mode == MBEDTLS_AES_DECRYPT )
ov[16] = *input;
c = *output++ = (unsigned char)( iv[0] ^ *input++ );
- if( mode == MBEDTLS_AES_ENCRYPT )
+ if ( mode == MBEDTLS_AES_ENCRYPT )
ov[16] = c;
memcpy( iv, ov + 1, 16 );
}
- return( 0 );
+ return ( 0 );
}
#endif /*MBEDTLS_CIPHER_MODE_CFB */
@@ -1004,23 +993,22 @@ int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
* AES-CTR buffer encryption/decryption
*/
int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
- size_t length,
- size_t *nc_off,
- unsigned char nonce_counter[16],
- unsigned char stream_block[16],
- const unsigned char *input,
- unsigned char *output )
+ size_t length,
+ size_t *nc_off,
+ unsigned char nonce_counter[16],
+ unsigned char stream_block[16],
+ const unsigned char *input,
+ unsigned char *output )
{
int c, i;
size_t n = *nc_off;
- while( length-- )
- {
- if( n == 0 ) {
+ while ( length-- ) {
+ if ( n == 0 ) {
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );
- for( i = 16; i > 0; i-- )
- if( ++nonce_counter[i - 1] != 0 )
+ for ( i = 16; i > 0; i-- )
+ if ( ++nonce_counter[i - 1] != 0 )
break;
}
c = *input++;
@@ -1031,7 +1019,7 @@ int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
*nc_off = n;
- return( 0 );
+ return ( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CTR */
@@ -1043,45 +1031,65 @@ int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
*
* http://csrc.nist.gov/archive/aes/rijndael/rijndael-vals.zip
*/
-static const unsigned char aes_test_ecb_dec[3][16] =
-{
- { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
- 0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
- { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
- 0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
- { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
- 0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
+static const unsigned char aes_test_ecb_dec[3][16] = {
+ {
+ 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
+ 0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0
+ },
+ {
+ 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
+ 0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4
+ },
+ {
+ 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
+ 0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE
+ }
};
-static const unsigned char aes_test_ecb_enc[3][16] =
-{
- { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
- 0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
- { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
- 0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
- { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
- 0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
+static const unsigned char aes_test_ecb_enc[3][16] = {
+ {
+ 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
+ 0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F
+ },
+ {
+ 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
+ 0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14
+ },
+ {
+ 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
+ 0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4
+ }
};
#if defined(MBEDTLS_CIPHER_MODE_CBC)
-static const unsigned char aes_test_cbc_dec[3][16] =
-{
- { 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
- 0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86 },
- { 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,
- 0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B },
- { 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,
- 0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13 }
+static const unsigned char aes_test_cbc_dec[3][16] = {
+ {
+ 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
+ 0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86
+ },
+ {
+ 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,
+ 0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B
+ },
+ {
+ 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,
+ 0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13
+ }
};
-static const unsigned char aes_test_cbc_enc[3][16] =
-{
- { 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,
- 0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D },
- { 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,
- 0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04 },
- { 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
- 0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }
+static const unsigned char aes_test_cbc_enc[3][16] = {
+ {
+ 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,
+ 0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D
+ },
+ {
+ 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,
+ 0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04
+ },
+ {
+ 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
+ 0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0
+ }
};
#endif /* MBEDTLS_CIPHER_MODE_CBC */
@@ -1091,27 +1099,30 @@ static const unsigned char aes_test_cbc_enc[3][16] =
*
* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
*/
-static const unsigned char aes_test_cfb128_key[3][32] =
-{
- { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
- 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
- { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
- 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
- 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
- { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
- 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
- 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
- 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
+static const unsigned char aes_test_cfb128_key[3][32] = {
+ {
+ 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
+ 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
+ },
+ {
+ 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
+ 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
+ 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B
+ },
+ {
+ 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
+ 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
+ 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
+ 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
+ }
};
-static const unsigned char aes_test_cfb128_iv[16] =
-{
+static const unsigned char aes_test_cfb128_iv[16] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
};
-static const unsigned char aes_test_cfb128_pt[64] =
-{
+static const unsigned char aes_test_cfb128_pt[64] = {
0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
@@ -1122,32 +1133,37 @@ static const unsigned char aes_test_cfb128_pt[64] =
0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
};
-static const unsigned char aes_test_cfb128_ct[3][64] =
-{
- { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
- 0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
- 0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,
- 0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,
- 0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,
- 0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,
- 0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,
- 0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6 },
- { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
- 0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
- 0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,
- 0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,
- 0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,
- 0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,
- 0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,
- 0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF },
- { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
- 0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
- 0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,
- 0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,
- 0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,
- 0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,
- 0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
- 0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }
+static const unsigned char aes_test_cfb128_ct[3][64] = {
+ {
+ 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
+ 0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
+ 0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,
+ 0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,
+ 0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,
+ 0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,
+ 0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,
+ 0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6
+ },
+ {
+ 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
+ 0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
+ 0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,
+ 0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,
+ 0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,
+ 0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,
+ 0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,
+ 0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF
+ },
+ {
+ 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
+ 0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
+ 0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,
+ 0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,
+ 0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,
+ 0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,
+ 0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
+ 0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71
+ }
};
#endif /* MBEDTLS_CIPHER_MODE_CFB */
@@ -1158,60 +1174,80 @@ static const unsigned char aes_test_cfb128_ct[3][64] =
* http://www.faqs.org/rfcs/rfc3686.html
*/
-static const unsigned char aes_test_ctr_key[3][16] =
-{
- { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
- 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
- { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
- 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
- { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
- 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
+static const unsigned char aes_test_ctr_key[3][16] = {
+ {
+ 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
+ 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E
+ },
+ {
+ 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
+ 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63
+ },
+ {
+ 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
+ 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC
+ }
};
-static const unsigned char aes_test_ctr_nonce_counter[3][16] =
-{
- { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
- { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
- 0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
- { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
- 0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
+static const unsigned char aes_test_ctr_nonce_counter[3][16] = {
+ {
+ 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+ },
+ {
+ 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
+ 0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01
+ },
+ {
+ 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
+ 0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01
+ }
};
-static const unsigned char aes_test_ctr_pt[3][48] =
-{
- { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
- 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
+static const unsigned char aes_test_ctr_pt[3][48] = {
+ {
+ 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
+ 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67
+ },
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
+ {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
+ },
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
- 0x20, 0x21, 0x22, 0x23 }
+ {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
+ 0x20, 0x21, 0x22, 0x23
+ }
};
-static const unsigned char aes_test_ctr_ct[3][48] =
-{
- { 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
- 0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8 },
- { 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
- 0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
- 0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
- 0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28 },
- { 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
- 0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
- 0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
- 0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
- 0x25, 0xB2, 0x07, 0x2F }
+static const unsigned char aes_test_ctr_ct[3][48] = {
+ {
+ 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
+ 0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8
+ },
+ {
+ 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
+ 0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
+ 0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
+ 0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28
+ },
+ {
+ 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
+ 0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
+ 0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
+ 0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
+ 0x25, 0xB2, 0x07, 0x2F
+ }
};
static const int aes_test_ctr_len[3] =
- { 16, 32, 36 };
+{ 16, 32, 36 };
#endif /* MBEDTLS_CIPHER_MODE_CTR */
/*
@@ -1244,43 +1280,37 @@ int mbedtls_aes_self_test( int verbose )
/*
* ECB mode
*/
- for( i = 0; i < 6; i++ )
- {
+ for ( i = 0; i < 6; i++ ) {
u = i >> 1;
v = i & 1;
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( " AES-ECB-%3d (%s): ", 128 + u * 64,
- ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( buf, 0, 16 );
- if( v == MBEDTLS_AES_DECRYPT )
- {
+ if ( v == MBEDTLS_AES_DECRYPT ) {
mbedtls_aes_setkey_dec( &ctx, key, 128 + u * 64 );
- for( j = 0; j < 10000; j++ )
+ for ( j = 0; j < 10000; j++ )
mbedtls_aes_crypt_ecb( &ctx, v, buf, buf );
- if( memcmp( buf, aes_test_ecb_dec[u], 16 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_ecb_dec[u], 16 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
- }
- else
- {
+ } else {
mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
- for( j = 0; j < 10000; j++ )
+ for ( j = 0; j < 10000; j++ )
mbedtls_aes_crypt_ecb( &ctx, v, buf, buf );
- if( memcmp( buf, aes_test_ecb_enc[u], 16 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_ecb_enc[u], 16 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
@@ -1288,52 +1318,46 @@ int mbedtls_aes_self_test( int verbose )
}
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "passed\n" );
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
- for( i = 0; i < 6; i++ )
- {
+ for ( i = 0; i < 6; i++ ) {
u = i >> 1;
v = i & 1;
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( " AES-CBC-%3d (%s): ", 128 + u * 64,
- ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
- memset( iv , 0, 16 );
+ memset( iv, 0, 16 );
memset( prv, 0, 16 );
memset( buf, 0, 16 );
- if( v == MBEDTLS_AES_DECRYPT )
- {
+ if ( v == MBEDTLS_AES_DECRYPT ) {
mbedtls_aes_setkey_dec( &ctx, key, 128 + u * 64 );
- for( j = 0; j < 10000; j++ )
+ for ( j = 0; j < 10000; j++ )
mbedtls_aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
- if( memcmp( buf, aes_test_cbc_dec[u], 16 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_cbc_dec[u], 16 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
- }
- else
- {
+ } else {
mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
- for( j = 0; j < 10000; j++ )
- {
+ for ( j = 0; j < 10000; j++ ) {
unsigned char tmp[16];
mbedtls_aes_crypt_cbc( &ctx, v, 16, iv, buf, buf );
@@ -1343,9 +1367,8 @@ int mbedtls_aes_self_test( int verbose )
memcpy( buf, tmp, 16 );
}
- if( memcmp( prv, aes_test_cbc_enc[u], 16 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( prv, aes_test_cbc_enc[u], 16 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
@@ -1353,11 +1376,11 @@ int mbedtls_aes_self_test( int verbose )
}
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "passed\n" );
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
@@ -1365,14 +1388,13 @@ int mbedtls_aes_self_test( int verbose )
/*
* CFB128 mode
*/
- for( i = 0; i < 6; i++ )
- {
+ for ( i = 0; i < 6; i++ ) {
u = i >> 1;
v = i & 1;
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( " AES-CFB128-%3d (%s): ", 128 + u * 64,
- ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, aes_test_cfb128_iv, 16 );
memcpy( key, aes_test_cfb128_key[u], 16 + u * 8 );
@@ -1380,28 +1402,23 @@ int mbedtls_aes_self_test( int verbose )
offset = 0;
mbedtls_aes_setkey_enc( &ctx, key, 128 + u * 64 );
- if( v == MBEDTLS_AES_DECRYPT )
- {
+ if ( v == MBEDTLS_AES_DECRYPT ) {
memcpy( buf, aes_test_cfb128_ct[u], 64 );
mbedtls_aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
- if( memcmp( buf, aes_test_cfb128_pt, 64 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_cfb128_pt, 64 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
- }
- else
- {
+ } else {
memcpy( buf, aes_test_cfb128_pt, 64 );
mbedtls_aes_crypt_cfb128( &ctx, v, 64, &offset, iv, buf, buf );
- if( memcmp( buf, aes_test_cfb128_ct[u], 64 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_cfb128_ct[u], 64 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
@@ -1409,11 +1426,11 @@ int mbedtls_aes_self_test( int verbose )
}
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "passed\n" );
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CFB */
@@ -1421,14 +1438,13 @@ int mbedtls_aes_self_test( int verbose )
/*
* CTR mode
*/
- for( i = 0; i < 6; i++ )
- {
+ for ( i = 0; i < 6; i++ ) {
u = i >> 1;
v = i & 1;
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( " AES-CTR-128 (%s): ",
- ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
+ ( v == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
memcpy( key, aes_test_ctr_key[u], 16 );
@@ -1436,34 +1452,29 @@ int mbedtls_aes_self_test( int verbose )
offset = 0;
mbedtls_aes_setkey_enc( &ctx, key, 128 );
- if( v == MBEDTLS_AES_DECRYPT )
- {
+ if ( v == MBEDTLS_AES_DECRYPT ) {
len = aes_test_ctr_len[u];
memcpy( buf, aes_test_ctr_ct[u], len );
mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
- buf, buf );
+ buf, buf );
- if( memcmp( buf, aes_test_ctr_pt[u], len ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_ctr_pt[u], len ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
- }
- else
- {
+ } else {
len = aes_test_ctr_len[u];
memcpy( buf, aes_test_ctr_pt[u], len );
mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
- buf, buf );
+ buf, buf );
- if( memcmp( buf, aes_test_ctr_ct[u], len ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( buf, aes_test_ctr_ct[u], len ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
@@ -1471,11 +1482,11 @@ int mbedtls_aes_self_test( int verbose )
}
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "passed\n" );
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
@@ -1484,7 +1495,7 @@ int mbedtls_aes_self_test( int verbose )
exit:
mbedtls_aes_free( &ctx );
- return( ret );
+ return ( ret );
}
#endif /* MBEDTLS_SELF_TEST */
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aesni.c b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aesni.c
index 1ca3c3ef..e3ac91cc 100644
--- a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aesni.c
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/aesni.c
@@ -50,8 +50,7 @@ int mbedtls_aesni_has_support( unsigned int what )
static int done = 0;
static unsigned int c = 0;
- if( ! done )
- {
+ if ( ! done ) {
asm( "movl $1, %%eax \n\t"
"cpuid \n\t"
: "=c" (c)
@@ -60,7 +59,7 @@ int mbedtls_aesni_has_support( unsigned int what )
done = 1;
}
- return( ( c & what ) != 0 );
+ return ( ( c & what ) != 0 );
}
/*
@@ -93,9 +92,9 @@ int mbedtls_aesni_has_support( unsigned int what )
* AES-NI AES-ECB block en(de)cryption
*/
int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
- int mode,
- const unsigned char input[16],
- unsigned char output[16] )
+ int mode,
+ const unsigned char input[16],
+ unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
@@ -131,7 +130,7 @@ int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
: "memory", "cc", "xmm0", "xmm1" );
- return( 0 );
+ return ( 0 );
}
/*
@@ -139,15 +138,14 @@ int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
* Based on [CLMUL-WP] algorithms 1 (with equation 27) and 5.
*/
void mbedtls_aesni_gcm_mult( unsigned char c[16],
- const unsigned char a[16],
- const unsigned char b[16] )
+ const unsigned char a[16],
+ const unsigned char b[16] )
{
unsigned char aa[16], bb[16], cc[16];
size_t i;
/* The inputs are in big-endian order, so byte-reverse them */
- for( i = 0; i < 16; i++ )
- {
+ for ( i = 0; i < 16; i++ ) {
aa[i] = a[15 - i];
bb[i] = b[15 - i];
}
@@ -240,7 +238,7 @@ void mbedtls_aesni_gcm_mult( unsigned char c[16],
: "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5" );
/* Now byte-reverse the outputs */
- for( i = 0; i < 16; i++ )
+ for ( i = 0; i < 16; i++ )
c[i] = cc[15 - i];
return;
@@ -250,14 +248,14 @@ void mbedtls_aesni_gcm_mult( unsigned char c[16],
* Compute decryption round keys from encryption round keys
*/
void mbedtls_aesni_inverse_key( unsigned char *invkey,
- const unsigned char *fwdkey, int nr )
+ const unsigned char *fwdkey, int nr )
{
unsigned char *ik = invkey;
const unsigned char *fk = fwdkey + 16 * nr;
memcpy( ik, fk, 16 );
- for( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
+ for ( fk -= 16, ik += 16; fk > fwdkey; fk -= 16, ik += 16 )
asm( "movdqu (%0), %%xmm0 \n\t"
AESIMC xmm0_xmm0 "\n\t"
"movdqu %%xmm0, (%1) \n\t"
@@ -445,18 +443,24 @@ static void aesni_setkey_enc_256( unsigned char *rk,
* Key expansion, wrapper
*/
int mbedtls_aesni_setkey_enc( unsigned char *rk,
- const unsigned char *key,
- size_t bits )
+ const unsigned char *key,
+ size_t bits )
{
- switch( bits )
- {
- case 128: aesni_setkey_enc_128( rk, key ); break;
- case 192: aesni_setkey_enc_192( rk, key ); break;
- case 256: aesni_setkey_enc_256( rk, key ); break;
- default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
+ switch ( bits ) {
+ case 128:
+ aesni_setkey_enc_128( rk, key );
+ break;
+ case 192:
+ aesni_setkey_enc_192( rk, key );
+ break;
+ case 256:
+ aesni_setkey_enc_256( rk, key );
+ break;
+ default :
+ return ( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
}
- return( 0 );
+ return ( 0 );
}
#endif /* MBEDTLS_HAVE_X86_64 */
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/arc4.c b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/arc4.c
index 05b33d3f..de0fc52a 100644
--- a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/arc4.c
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/arc4.c
@@ -48,8 +48,10 @@
#if !defined(MBEDTLS_ARC4_ALT)
/* Implementation that should never be optimized out by the compiler */
-static void mbedtls_zeroize( void *v, size_t n ) {
- volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
+static void mbedtls_zeroize( void *v, size_t n )
+{
+ volatile unsigned char *p = (unsigned char*)v;
+ while ( n-- ) *p++ = 0;
}
void mbedtls_arc4_init( mbedtls_arc4_context *ctx )
@@ -59,7 +61,7 @@ void mbedtls_arc4_init( mbedtls_arc4_context *ctx )
void mbedtls_arc4_free( mbedtls_arc4_context *ctx )
{
- if( ctx == NULL )
+ if ( ctx == NULL )
return;
mbedtls_zeroize( ctx, sizeof( mbedtls_arc4_context ) );
@@ -69,7 +71,7 @@ void mbedtls_arc4_free( mbedtls_arc4_context *ctx )
* ARC4 key schedule
*/
void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
- unsigned int keylen )
+ unsigned int keylen )
{
int i, j, a;
unsigned int k;
@@ -79,14 +81,13 @@ void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
ctx->y = 0;
m = ctx->m;
- for( i = 0; i < 256; i++ )
+ for ( i = 0; i < 256; i++ )
m[i] = (unsigned char) i;
j = k = 0;
- for( i = 0; i < 256; i++, k++ )
- {
- if( k >= keylen ) k = 0;
+ for ( i = 0; i < 256; i++, k++ ) {
+ if ( k >= keylen ) k = 0;
a = m[i];
j = ( j + a + key[k] ) & 0xFF;
@@ -99,7 +100,7 @@ void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
* ARC4 cipher function
*/
int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
- unsigned char *output )
+ unsigned char *output )
{
int x, y, a, b;
size_t i;
@@ -109,22 +110,23 @@ int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned
y = ctx->y;
m = ctx->m;
- for( i = 0; i < length; i++ )
- {
- x = ( x + 1 ) & 0xFF; a = m[x];
- y = ( y + a ) & 0xFF; b = m[y];
+ for ( i = 0; i < length; i++ ) {
+ x = ( x + 1 ) & 0xFF;
+ a = m[x];
+ y = ( y + a ) & 0xFF;
+ b = m[y];
m[x] = (unsigned char) b;
m[y] = (unsigned char) a;
output[i] = (unsigned char)
- ( input[i] ^ m[(unsigned char)( a + b )] );
+ ( input[i] ^ m[(unsigned char)( a + b )] );
}
ctx->x = x;
ctx->y = y;
- return( 0 );
+ return ( 0 );
}
#endif /* !MBEDTLS_ARC4_ALT */
@@ -135,22 +137,19 @@ int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned
*
* http://groups.google.com/group/comp.security.misc/msg/10a300c9d21afca0
*/
-static const unsigned char arc4_test_key[3][8] =
-{
+static const unsigned char arc4_test_key[3][8] = {
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
};
-static const unsigned char arc4_test_pt[3][8] =
-{
+static const unsigned char arc4_test_pt[3][8] = {
{ 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
};
-static const unsigned char arc4_test_ct[3][8] =
-{
+static const unsigned char arc4_test_ct[3][8] = {
{ 0x75, 0xB7, 0x87, 0x80, 0x99, 0xE0, 0xC5, 0x96 },
{ 0x74, 0x94, 0xC2, 0xE7, 0x10, 0x4B, 0x08, 0x79 },
{ 0xDE, 0x18, 0x89, 0x41, 0xA3, 0x37, 0x5D, 0x3A }
@@ -168,9 +167,8 @@ int mbedtls_arc4_self_test( int verbose )
mbedtls_arc4_init( &ctx );
- for( i = 0; i < 3; i++ )
- {
- if( verbose != 0 )
+ for ( i = 0; i < 3; i++ ) {
+ if ( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ibuf, arc4_test_pt[i], 8 );
@@ -178,26 +176,25 @@ int mbedtls_arc4_self_test( int verbose )
mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );
- if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
- {
- if( verbose != 0 )
+ if ( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 ) {
+ if ( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "passed\n" );
}
- if( verbose != 0 )
+ if ( verbose != 0 )
mbedtls_printf( "\n" );
exit:
mbedtls_arc4_free( &ctx );
- return( ret );
+ return ( ret );
}
#endif /* MBEDTLS_SELF_TEST */
diff --git a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/asn1parse.c b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/asn1parse.c
index 4dd65c03..72a5717a 100644
--- a/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/asn1parse.c
+++ b/components/connectivity/qcloud-iot-explorer-sdk/3rdparty/external_libs/mbedtls/library/asn1parse.c
@@ -44,193 +44,192 @@
#endif
/* Implementation that should never be optimized out by the compiler */
-static void mbedtls_zeroize( void *v, size_t n ) {
- volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
+static void mbedtls_zeroize( void *v, size_t n )
+{
+ volatile unsigned char *p = (unsigned char*)v;
+ while ( n-- ) *p++ = 0;
}
/*
* ASN.1 DER decoding routines
*/
int mbedtls_asn1_get_len( unsigned char **p,
- const unsigned char *end,
- size_t *len )
+ const unsigned char *end,
+ size_t *len )
{
- if( ( end - *p ) < 1 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ if ( ( end - *p ) < 1 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- if( ( **p & 0x80 ) == 0 )
+ if ( ( **p & 0x80 ) == 0 )
*len = *(*p)++;
- else
- {
- switch( **p & 0x7F )
- {
- case 1:
- if( ( end - *p ) < 2 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ else {
+ switch ( **p & 0x7F ) {
+ case 1:
+ if ( ( end - *p ) < 2 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- *len = (*p)[1];
- (*p) += 2;
- break;
+ *len = (*p)[1];
+ (*p) += 2;
+ break;
- case 2:
- if( ( end - *p ) < 3 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ case 2:
+ if ( ( end - *p ) < 3 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- *len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
- (*p) += 3;
- break;
+ *len = ( (size_t)(*p)[1] << 8 ) | (*p)[2];
+ (*p) += 3;
+ break;
- case 3:
- if( ( end - *p ) < 4 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ case 3:
+ if ( ( end - *p ) < 4 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- *len = ( (size_t)(*p)[1] << 16 ) |
- ( (size_t)(*p)[2] << 8 ) | (*p)[3];
- (*p) += 4;
- break;
+ *len = ( (size_t)(*p)[1] << 16 ) |
+ ( (size_t)(*p)[2] << 8 ) | (*p)[3];
+ (*p) += 4;
+ break;
- case 4:
- if( ( end - *p ) < 5 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ case 4:
+ if ( ( end - *p ) < 5 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- *len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
- ( (size_t)(*p)[3] << 8 ) | (*p)[4];
- (*p) += 5;
- break;
+ *len = ( (size_t)(*p)[1] << 24 ) | ( (size_t)(*p)[2] << 16 ) |
+ ( (size_t)(*p)[3] << 8 ) | (*p)[4];
+ (*p) += 5;
+ break;
- default:
- return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+ default:
+ return ( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
}
}
- if( *len > (size_t) ( end - *p ) )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ if ( *len > (size_t) ( end - *p ) )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- return( 0 );
+ return ( 0 );
}
int mbedtls_asn1_get_tag( unsigned char **p,
- const unsigned char *end,
- size_t *len, int tag )
+ const unsigned char *end,
+ size_t *len, int tag )
{
- if( ( end - *p ) < 1 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ if ( ( end - *p ) < 1 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- if( **p != tag )
- return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
+ if ( **p != tag )
+ return ( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
- return( mbedtls_asn1_get_len( p, end, len ) );
+ return ( mbedtls_asn1_get_len( p, end, len ) );
}
int mbedtls_asn1_get_bool( unsigned char **p,
- const unsigned char *end,
- int *val )
+ const unsigned char *end,
+ int *val )
{
int ret;
size_t len;
- if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
- return( ret );
+ if ( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
+ return ( ret );
- if( len != 1 )
- return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+ if ( len != 1 )
+ return ( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = ( **p != 0 ) ? 1 : 0;
(*p)++;
- return( 0 );
+ return ( 0 );
}
int mbedtls_asn1_get_int( unsigned char **p,
- const unsigned char *end,
- int *val )
+ const unsigned char *end,
+ int *val )
{
int ret;
size_t len;
- if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
- return( ret );
+ if ( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
+ return ( ret );
- if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0 )
- return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+ if ( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0 )
+ return ( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = 0;
- while( len-- > 0 )
- {
+ while ( len-- > 0 ) {
*val = ( *val << 8 ) | **p;
(*p)++;
}
- return( 0 );
+ return ( 0 );
}
#if defined(MBEDTLS_BIGNUM_C)
int mbedtls_asn1_get_mpi( unsigned char **p,
- const unsigned char *end,
- mbedtls_mpi *X )
+ const unsigned char *end,
+ mbedtls_mpi *X )
{
int ret;
size_t len;
- if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
- return( ret );
+ if ( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
+ return ( ret );
ret = mbedtls_mpi_read_binary( X, *p, len );
*p += len;
- return( ret );
+ return ( ret );
}
#endif /* MBEDTLS_BIGNUM_C */
int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
- mbedtls_asn1_bitstring *bs)
+ mbedtls_asn1_bitstring *bs)
{
int ret;
/* Certificate type is a single byte bitstring */
- if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
- return( ret );
+ if ( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
+ return ( ret );
/* Check length, subtract one for actual bit string length */
- if( bs->len < 1 )
- return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ if ( bs->len < 1 )
+ return ( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
bs->len -= 1;
/* Get number of unused bits, ensure unused bits <= 7 */
bs->unused_bits = **p;
- if( bs->unused_bits > 7 )
- return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+ if ( bs->unused_bits > 7 )
+ return ( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
(*p)++;
/* Get actual bitstring */
bs->p = *p;
*p += bs->len;
- if( *p != end )
- return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
+ if ( *p != end )
+ return ( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- return( 0 );
+ return ( 0 );
}
/*
* Get a bit string without unused bits
*/
int mbedtls_asn1_get_bitstring_null( unsigned char **p, const unsigned char *end,
- size_t *len )
+ size_t *len )
{
int ret;
- if( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
- return( ret );
+ if ( ( ret = mbedtls_asn1_get_tag( p, end, len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
+ return ( ret );
- if( (*len)-- < 2 || *(*p)++ != 0 )
- return( MBEDTLS_ERR_ASN1_INVALID_DATA );
+ if ( (*len)-- < 2 || *(*p)++ != 0 )
+ return ( MBEDTLS_ERR_ASN1_INVALID_DATA );
- return( 0 );
+ return ( 0 );
}
@@ -239,41 +238,39 @@ int mbedtls_asn1_get_bitstring_null( unsigned char **p, const unsigned char *end
* Parses and splits an ASN.1 "SEQUENCE OF