; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\aesutils.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\aesutils.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\aesutils.crf ..\..\..\..\libraries\utilities\AESUtils.c]
                          THUMB

                          AREA ||i.AES_CBCFrame_Final||, CODE, READONLY, ALIGN=1

                  AES_CBCFrame_Final PROC
;;;441    
;;;442    void    AES_CBCFrame_Final( AES_CBCFrame_Context *inContext )
000000  b510              PUSH     {r4,lr}
;;;443    {
000002  4604              MOV      r4,r0
;;;444    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;445        if( inContext->cryptor ) CCCryptorRelease( inContext->cryptor );
;;;446    #endif
;;;447        memset( inContext, 0, sizeof( *inContext ) ); // Clear sensitive data.
000004  f44f7194          MOV      r1,#0x128
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       __aeabi_memclr4
;;;448    }
00000e  bd10              POP      {r4,pc}
;;;449    
                          ENDP


                          AREA ||i.AES_CBCFrame_Init||, CODE, READONLY, ALIGN=1

                  AES_CBCFrame_Init PROC
;;;215    OSStatus
;;;216        AES_CBCFrame_Init( 
000000  b5f8              PUSH     {r3-r7,lr}
;;;217            AES_CBCFrame_Context *  inContext, 
;;;218            const uint8_t           inKey[ kAES_CBCFrame_Size ], 
;;;219            const uint8_t           inIV[ kAES_CBCFrame_Size ], 
;;;220            Boolean                 inEncrypt )
;;;221    {
000002  4605              MOV      r5,r0
000004  460f              MOV      r7,r1
000006  4614              MOV      r4,r2
000008  461e              MOV      r6,r3
;;;222    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;223        OSStatus        err;
;;;224        
;;;225        inContext->cryptor = NULL;
;;;226        err = CCCryptorCreate( inEncrypt ? kCCEncrypt : kCCDecrypt, kCCAlgorithmAES128, 0, inKey, kAES_CTR_Size, 
;;;227            NULL, &inContext->cryptor );
;;;228        check_noerr( err );
;;;229        if( err ) return( err );
;;;230    #elif( AES_UTILS_USE_GLADMAN_AES )
;;;231        aes_init();
;;;232        if( inEncrypt ) aes_encrypt_key128( inKey, &inContext->ctx.encrypt );
;;;233        else            aes_decrypt_key128( inKey, &inContext->ctx.decrypt );
;;;234        inContext->encrypt = inEncrypt;
;;;235    #elif( AES_UTILS_USE_MICO_AES )
;;;236        if( inEncrypt ) AesSetKeyDirect(&inContext->ctx, (unsigned char *) inKey, AES_BLOCK_SIZE, inIV, AES_ENCRYPTION);
00000a  b146              CBZ      r6,|L2.30|
00000c  2000              MOVS     r0,#0
00000e  4623              MOV      r3,r4
000010  2210              MOVS     r2,#0x10
000012  4639              MOV      r1,r7
000014  9000              STR      r0,[sp,#0]
000016  4628              MOV      r0,r5
000018  f7fffffe          BL       AesSetKeyDirect
00001c  e007              B        |L2.46|
                  |L2.30|
;;;237        else            AesSetKeyDirect(&inContext->ctx, (unsigned char *) inKey, AES_BLOCK_SIZE, inIV, AES_DECRYPTION);
00001e  2001              MOVS     r0,#1
000020  4623              MOV      r3,r4
000022  2210              MOVS     r2,#0x10
000024  4639              MOV      r1,r7
000026  9000              STR      r0,[sp,#0]
000028  4628              MOV      r0,r5
00002a  f7fffffe          BL       AesSetKeyDirect
                  |L2.46|
;;;238    #elif( AES_UTILS_USE_USSL )
;;;239        if( inEncrypt ) aes_setkey_enc( &inContext->ctx, (unsigned char *) inKey, kAES_CBCFrame_Size * 8 );
;;;240        else            aes_setkey_dec( &inContext->ctx, (unsigned char *) inKey, kAES_CBCFrame_Size * 8 );
;;;241        inContext->encrypt = inEncrypt;
;;;242    #else
;;;243        if( inEncrypt ) AES_set_encrypt_key( inKey, kAES_CBCFrame_Size * 8, &inContext->key );
;;;244        else            AES_set_decrypt_key( inKey, kAES_CBCFrame_Size * 8, &inContext->key );
;;;245        inContext->mode = inEncrypt ? AES_ENCRYPT : AES_DECRYPT;
;;;246    #endif
;;;247        memcpy( inContext->iv, inIV, kAES_CBCFrame_Size );
00002e  2210              MOVS     r2,#0x10
000030  4621              MOV      r1,r4
000032  f505708c          ADD      r0,r5,#0x118
000036  f7fffffe          BL       __aeabi_memcpy
;;;248        return( kNoErr );
00003a  2000              MOVS     r0,#0
;;;249    }
00003c  bdf8              POP      {r3-r7,pc}
;;;250    
                          ENDP


                          AREA ||i.AES_CBCFrame_Update||, CODE, READONLY, ALIGN=1

                  AES_CBCFrame_Update PROC
;;;254    
;;;255    OSStatus    AES_CBCFrame_Update( AES_CBCFrame_Context *inContext, const void *inSrc, size_t inSrcLen, void *inDst )
000000  e92d5fff          PUSH     {r0-r12,lr}
;;;256    {
000004  460f              MOV      r7,r1
000006  4690              MOV      r8,r2
000008  4699              MOV      r9,r3
;;;257        OSStatus            err;
;;;258        const uint8_t *     src;
;;;259        const uint8_t *     end;
;;;260        uint8_t *           dst;
;;;261        size_t              len;
;;;262        
;;;263        src = (const uint8_t *) inSrc;
00000a  463c              MOV      r4,r7
;;;264        end = src + inSrcLen;
00000c  eb040b08          ADD      r11,r4,r8
;;;265        dst = (uint8_t *) inDst;
000010  464d              MOV      r5,r9
;;;266        
;;;267        // Process whole blocks.
;;;268        
;;;269        len = inSrcLen & ~( (size_t)( kAES_CBCFrame_Size - 1 ) );
000012  f028060f          BIC      r6,r8,#0xf
;;;270        if( len > 0 )
000016  b13e              CBZ      r6,|L3.40|
;;;271        {
;;;272            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;273                err = CCCryptorReset(  inContext->cryptor, inContext->iv );
;;;274                require_noerr( err, exit );
;;;275                
;;;276                err = CCCryptorUpdate( inContext->cryptor, src, len, dst, len, &len );
;;;277                require_noerr( err, exit );
;;;278            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;279                uint8_t     iv[ kAES_CBCFrame_Size ];
;;;280                
;;;281                memcpy( iv, inContext->iv, kAES_CBCFrame_Size ); // Use local copy so original IV is not changed.
;;;282                if( inContext->encrypt )    aes_cbc_encrypt( src, dst, (int) len, iv, &inContext->ctx.encrypt );
;;;283                else                        aes_cbc_decrypt( src, dst, (int) len, iv, &inContext->ctx.decrypt );
;;;284            #elif( AES_UTILS_USE_MICO_AES )
;;;285                AesCbcEncrypt(&inContext->ctx, dst, src, len);
000018  4633              MOV      r3,r6
00001a  4622              MOV      r2,r4
00001c  4629              MOV      r1,r5
00001e  9800              LDR      r0,[sp,#0]
000020  f7fffffe          BL       AesCbcEncrypt
;;;286            #elif( AES_UTILS_USE_USSL )
;;;287                uint8_t     iv[ kAES_CBCFrame_Size ];
;;;288    
;;;289                memcpy( iv, inContext->iv, kAES_CBCFrame_Size ); // Use local copy so original IV is not changed.
;;;290                if( inContext->encrypt )    aes_crypt_cbc( &inContext->ctx, AES_ENCRYPT, len, iv, (unsigned char *) src, dst );
;;;291                else                        aes_crypt_cbc( &inContext->ctx, AES_DECRYPT, len, iv, (unsigned char *) src, dst );
;;;292            #else
;;;293                uint8_t     iv[ kAES_CBCFrame_Size ];
;;;294                
;;;295                memcpy( iv, inContext->iv, kAES_CBCFrame_Size ); // Use local copy so original IV is not changed.
;;;296                AES_cbc_encrypt( src, dst, (unsigned long) len, &inContext->key, iv, inContext->mode );
;;;297            #endif
;;;298            src += len;
000024  4434              ADD      r4,r4,r6
;;;299            dst += len;
000026  4435              ADD      r5,r5,r6
                  |L3.40|
;;;300        }
;;;301        
;;;302        // The remaining bytes are just copied unencrypted.
;;;303        
;;;304        while( src != end ) *dst++ = *src++;
000028  e003              B        |L3.50|
                  |L3.42|
00002a  f8140b01          LDRB     r0,[r4],#1
00002e  f8050b01          STRB     r0,[r5],#1
                  |L3.50|
000032  455c              CMP      r4,r11
000034  d1f9              BNE      |L3.42|
;;;305        err = kNoErr;
000036  f04f0a00          MOV      r10,#0
;;;306        
;;;307    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;308    exit:
;;;309    #endif
;;;310        return( err );
00003a  4650              MOV      r0,r10
;;;311    }
00003c  b004              ADD      sp,sp,#0x10
00003e  e8bd9ff0          POP      {r4-r12,pc}
;;;312    
                          ENDP


                          AREA ||i.AES_CBCFrame_Update2||, CODE, READONLY, ALIGN=1

                  AES_CBCFrame_Update2 PROC
;;;317    OSStatus
;;;318        AES_CBCFrame_Update2( 
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;319            AES_CBCFrame_Context *  inContext, 
;;;320            const void *            inSrc1, 
;;;321            size_t                  inLen1, 
;;;322            const void *            inSrc2, 
;;;323            size_t                  inLen2, 
;;;324            void *                  inDst )
;;;325    {
000004  b089              SUB      sp,sp,#0x24
000006  468b              MOV      r11,r1
;;;326        const uint8_t *     src1 = (const uint8_t *) inSrc1;
000008  465c              MOV      r4,r11
;;;327        const uint8_t *     end1 = src1 + inLen1;
00000a  980b              LDR      r0,[sp,#0x2c]
00000c  eb040900          ADD      r9,r4,r0
;;;328        const uint8_t *     src2 = (const uint8_t *) inSrc2;
000010  9d0c              LDR      r5,[sp,#0x30]
;;;329        const uint8_t *     end2 = src2 + inLen2;
000012  9816              LDR      r0,[sp,#0x58]
000014  eb050a00          ADD      r10,r5,r0
;;;330        uint8_t *           dst  = (uint8_t *) inDst;
000018  9e17              LDR      r6,[sp,#0x5c]
;;;331        OSStatus            err;
;;;332        size_t              len;
;;;333        size_t              i;
;;;334    #if( !AES_UTILS_USE_COMMON_CRYPTO )
;;;335        uint8_t             iv[ kAES_CBCFrame_Size ];
;;;336    #endif
;;;337        
;;;338    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;339        if( ( inLen1 + inLen2 ) >= kAES_CBCFrame_Size )
;;;340        {
;;;341            err = CCCryptorReset(  inContext->cryptor, inContext->iv );
;;;342            require_noerr( err, exit );
;;;343        }
;;;344    #else
;;;345        memcpy( iv, inContext->iv, kAES_CBCFrame_Size ); // Use local copy so original IV is not changed.
00001a  9809              LDR      r0,[sp,#0x24]
00001c  f5007080          ADD      r0,r0,#0x100
000020  e9d02307          LDRD     r2,r3,[r0,#0x1c]
000024  6981              LDR      r1,[r0,#0x18]
000026  6a40              LDR      r0,[r0,#0x24]
000028  af04              ADD      r7,sp,#0x10
00002a  c70e              STM      r7!,{r1-r3}
00002c  9007              STR      r0,[sp,#0x1c]
;;;346    #endif
;;;347        
;;;348        // Process all whole blocks from buffer 1.
;;;349        
;;;350        len = inLen1 & ~( (size_t)( kAES_CBCFrame_Size - 1 ) );
00002e  980b              LDR      r0,[sp,#0x2c]
000030  f020080f          BIC      r8,r0,#0xf
;;;351        if( len > 0 )
000034  f1b80f00          CMP      r8,#0
000038  d007              BEQ      |L4.74|
;;;352        {
;;;353            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;354                err = CCCryptorUpdate( inContext->cryptor, src1, len, dst, len, &len );
;;;355                require_noerr( err, exit );
;;;356            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;357                if( inContext->encrypt )    aes_cbc_encrypt( src1, dst, (int) len, iv, &inContext->ctx.encrypt );
;;;358                else                        aes_cbc_decrypt( src1, dst, (int) len, iv, &inContext->ctx.decrypt );
;;;359            #elif( AES_UTILS_USE_MICO_AES )
;;;360                AesCbcEncrypt(&inContext->ctx, dst, src1, len);
00003a  4643              MOV      r3,r8
00003c  4622              MOV      r2,r4
00003e  4631              MOV      r1,r6
000040  9809              LDR      r0,[sp,#0x24]
000042  f7fffffe          BL       AesCbcEncrypt
;;;361            #elif( AES_UTILS_USE_USSL )
;;;362                if( inContext->encrypt )    aes_crypt_cbc( &inContext->ctx, AES_ENCRYPT, len, iv, (unsigned char *) src1, dst );
;;;363                else                        aes_crypt_cbc( &inContext->ctx, AES_DECRYPT, len, iv, (unsigned char *) src1, dst );
;;;364            #else
;;;365                AES_cbc_encrypt( src1, dst, (unsigned long) len, &inContext->key, iv, inContext->mode );
;;;366            #endif
;;;367            src1 += len;
000046  4444              ADD      r4,r4,r8
;;;368            dst  += len;
000048  4446              ADD      r6,r6,r8
                  |L4.74|
;;;369        }
;;;370        
;;;371        // If there are any partial block bytes in buffer 1 and enough bytes in buffer 2 to fill a 
;;;372        // block then combine them into a temporary buffer and encrypt it.
;;;373        
;;;374        if( ( src1 != end1 ) && ( ( ( end1 - src1 ) + ( end2 - src2 ) ) >= kAES_CBCFrame_Size ) )
00004a  454c              CMP      r4,r9
00004c  d021              BEQ      |L4.146|
00004e  eba90004          SUB      r0,r9,r4
000052  ebaa0105          SUB      r1,r10,r5
000056  4408              ADD      r0,r0,r1
000058  2810              CMP      r0,#0x10
00005a  db1a              BLT      |L4.146|
;;;375        {
;;;376            uint8_t     buf[ kAES_CBCFrame_Size ];
;;;377            
;;;378            for( i = 0; src1 != end1; ++i )
00005c  2700              MOVS     r7,#0
00005e  e004              B        |L4.106|
                  |L4.96|
;;;379            {
;;;380                buf[ i ] = *src1++;
000060  f8140b01          LDRB     r0,[r4],#1
000064  f80d0007          STRB     r0,[sp,r7]
000068  1c7f              ADDS     r7,r7,#1              ;378
                  |L4.106|
00006a  454c              CMP      r4,r9                 ;378
00006c  d1f8              BNE      |L4.96|
;;;381            }
;;;382            for( ; ( i < kAES_CBCFrame_Size ) && ( src2 != end2 ); ++i )
00006e  e004              B        |L4.122|
                  |L4.112|
;;;383            {
;;;384                buf[ i ] = *src2++;
000070  f8150b01          LDRB     r0,[r5],#1
000074  f80d0007          STRB     r0,[sp,r7]
000078  1c7f              ADDS     r7,r7,#1              ;382
                  |L4.122|
00007a  2f10              CMP      r7,#0x10              ;382
00007c  d201              BCS      |L4.130|
00007e  4555              CMP      r5,r10                ;382
000080  d1f6              BNE      |L4.112|
                  |L4.130|
;;;385            }
;;;386            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;387                err = CCCryptorUpdate( inContext->cryptor, buf, i, dst, i, &i );
;;;388                require_noerr( err, exit );
;;;389            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;390                if( inContext->encrypt )    aes_cbc_encrypt( buf, dst, (int) i, iv, &inContext->ctx.encrypt );
;;;391                else                        aes_cbc_decrypt( buf, dst, (int) i, iv, &inContext->ctx.decrypt );
;;;392            #elif( AES_UTILS_USE_MICO_AES )
;;;393                AesCbcEncrypt(&inContext->ctx, dst, buf, i);
000082  463b              MOV      r3,r7
000084  466a              MOV      r2,sp
000086  4631              MOV      r1,r6
000088  9809              LDR      r0,[sp,#0x24]
00008a  f7fffffe          BL       AesCbcEncrypt
;;;394            #elif( AES_UTILS_USE_USSL )
;;;395                if( inContext->encrypt )    aes_crypt_cbc( &inContext->ctx, AES_ENCRYPT, i, iv, buf, dst );
;;;396                else                        aes_crypt_cbc( &inContext->ctx, AES_DECRYPT, i, iv, buf, dst );
;;;397            #else
;;;398                AES_cbc_encrypt( buf, dst, (unsigned long) i, &inContext->key, iv, inContext->mode );
;;;399            #endif
;;;400            dst += i;
00008e  443e              ADD      r6,r6,r7
;;;401        }
000090  bf00              NOP      
                  |L4.146|
;;;402        
;;;403        // Process any remaining whole blocks in buffer 2.
;;;404        
;;;405        len = ( (size_t)( end2 - src2 ) ) & ~( (size_t)( kAES_CBCFrame_Size - 1 ) );
000092  ebaa0005          SUB      r0,r10,r5
000096  f020080f          BIC      r8,r0,#0xf
;;;406        if( len > 0 )
00009a  f1b80f00          CMP      r8,#0
00009e  d007              BEQ      |L4.176|
;;;407        {
;;;408            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;409                err = CCCryptorUpdate( inContext->cryptor, src2, len, dst, len, &len );
;;;410                require_noerr( err, exit );
;;;411            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;412                if( inContext->encrypt )    aes_cbc_encrypt( src2, dst, (int) len, iv, &inContext->ctx.encrypt );
;;;413                else                        aes_cbc_decrypt( src2, dst, (int) len, iv, &inContext->ctx.decrypt );
;;;414            #elif( AES_UTILS_USE_MICO_AES )
;;;415                AesCbcEncrypt(&inContext->ctx, dst, src2, len);
0000a0  4643              MOV      r3,r8
0000a2  462a              MOV      r2,r5
0000a4  4631              MOV      r1,r6
0000a6  9809              LDR      r0,[sp,#0x24]
0000a8  f7fffffe          BL       AesCbcEncrypt
;;;416            #elif( AES_UTILS_USE_USSL )
;;;417                if( inContext->encrypt )    aes_crypt_cbc( &inContext->ctx, AES_ENCRYPT, len, iv, (unsigned char *) src2, dst );
;;;418                else                        aes_crypt_cbc( &inContext->ctx, AES_DECRYPT, len, iv, (unsigned char *) src2, dst );
;;;419            #else
;;;420                AES_cbc_encrypt( src2, dst, (unsigned long) len, &inContext->key, iv, inContext->mode );
;;;421            #endif
;;;422            src2 += len;
0000ac  4445              ADD      r5,r5,r8
;;;423            dst  += len;
0000ae  4446              ADD      r6,r6,r8
                  |L4.176|
;;;424        }
;;;425        
;;;426        // Any remaining bytes are just copied unencrypted.
;;;427        
;;;428        while( src1 != end1 ) *dst++ = *src1++;
0000b0  e003              B        |L4.186|
                  |L4.178|
0000b2  f8140b01          LDRB     r0,[r4],#1
0000b6  f8060b01          STRB     r0,[r6],#1
                  |L4.186|
0000ba  454c              CMP      r4,r9
0000bc  d1f9              BNE      |L4.178|
;;;429        while( src2 != end2 ) *dst++ = *src2++;
0000be  e003              B        |L4.200|
                  |L4.192|
0000c0  f8150b01          LDRB     r0,[r5],#1
0000c4  f8060b01          STRB     r0,[r6],#1
                  |L4.200|
0000c8  4555              CMP      r5,r10
0000ca  d1f9              BNE      |L4.192|
;;;430        err = kNoErr;
0000cc  2000              MOVS     r0,#0
0000ce  9008              STR      r0,[sp,#0x20]
;;;431        
;;;432    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;433    exit:
;;;434    #endif
;;;435        return( err );
0000d0  9808              LDR      r0,[sp,#0x20]
;;;436    }
0000d2  b00d              ADD      sp,sp,#0x34
0000d4  e8bd8ff0          POP      {r4-r11,pc}
;;;437    
                          ENDP


                          AREA ||i.AES_CTR_Final||, CODE, READONLY, ALIGN=1

                  AES_CTR_Final PROC
;;;198    
;;;199    void    AES_CTR_Final( AES_CTR_Context *inContext )
000000  b510              PUSH     {r4,lr}
;;;200    {
000002  4604              MOV      r4,r0
;;;201    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;202        if( inContext->cryptor ) CCCryptorRelease( inContext->cryptor );
;;;203    #endif
;;;204        memset( inContext, 0, sizeof( *inContext ) ); // Clear sensitive data.
000004  f44f719e          MOV      r1,#0x13c
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       __aeabi_memclr4
;;;205    }
00000e  bd10              POP      {r4,pc}
;;;206    
                          ENDP


                          AREA ||i.AES_CTR_Increment||, CODE, READONLY, ALIGN=1

                  AES_CTR_Increment PROC
;;;78     
;;;79     static inline void AES_CTR_Increment( uint8_t *inCounter )
000000  4601              MOV      r1,r0
;;;80     {
;;;81         int     i;
;;;82         
;;;83         // Note: counter is always big endian so this adds from right to left.
;;;84         
;;;85         for( i = kAES_CTR_Size - 1; i >= 0; --i )
000002  200f              MOVS     r0,#0xf
000004  e006              B        |L6.20|
                  |L6.6|
;;;86         {
;;;87             if( ++( inCounter[ i ] ) != 0 )
000006  5c0a              LDRB     r2,[r1,r0]
000008  1c52              ADDS     r2,r2,#1
00000a  b2d2              UXTB     r2,r2
00000c  540a              STRB     r2,[r1,r0]
00000e  b102              CBZ      r2,|L6.18|
;;;88             {
;;;89                 break;
000010  e002              B        |L6.24|
                  |L6.18|
000012  1e40              SUBS     r0,r0,#1              ;85
                  |L6.20|
000014  2800              CMP      r0,#0                 ;85
000016  daf6              BGE      |L6.6|
                  |L6.24|
000018  bf00              NOP      
;;;90             }
;;;91         }
;;;92     }
00001a  4770              BX       lr
;;;93     
                          ENDP


                          AREA ||i.AES_CTR_Init||, CODE, READONLY, ALIGN=1

                  AES_CTR_Init PROC
;;;45     OSStatus
;;;46         AES_CTR_Init( 
000000  b5f8              PUSH     {r3-r7,lr}
;;;47             AES_CTR_Context *   inContext, 
;;;48             const uint8_t       inKey[ kAES_CTR_Size ], 
;;;49             const uint8_t       inNonce[ kAES_CTR_Size ] )
;;;50     {
000002  4604              MOV      r4,r0
000004  460e              MOV      r6,r1
000006  4615              MOV      r5,r2
;;;51     #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;52         OSStatus        err;
;;;53         
;;;54         inContext->cryptor = NULL;
;;;55         err = CCCryptorCreate( kCCEncrypt, kCCAlgorithmAES128, kCCOptionECBMode, inKey, kAES_CTR_Size, NULL, 
;;;56             &inContext->cryptor );
;;;57         check_noerr( err );
;;;58         if( err ) return( err );
;;;59     #elif( AES_UTILS_USE_GLADMAN_AES )
;;;60         aes_init();
;;;61         aes_encrypt_key128( inKey, &inContext->ctx );
;;;62     #elif( AES_UTILS_USE_MICO_AES )
;;;63         AesSetKeyDirect(&inContext->ctx, (unsigned char *) inKey, AES_BLOCK_SIZE, inNonce, AES_ENCRYPTION);
000008  2000              MOVS     r0,#0
00000a  462b              MOV      r3,r5
00000c  2210              MOVS     r2,#0x10
00000e  4631              MOV      r1,r6
000010  9000              STR      r0,[sp,#0]
000012  4620              MOV      r0,r4
000014  f7fffffe          BL       AesSetKeyDirect
;;;64     #elif( AES_UTILS_USE_USSL )
;;;65         aes_setkey_enc( &inContext->ctx, (unsigned char *) inKey, kAES_CTR_Size * 8 );
;;;66     #else
;;;67         AES_set_encrypt_key( inKey, kAES_CTR_Size * 8, &inContext->key );
;;;68     #endif
;;;69         memcpy( inContext->ctr, inNonce, kAES_CTR_Size );
000018  2210              MOVS     r2,#0x10
00001a  4629              MOV      r1,r5
00001c  f504708a          ADD      r0,r4,#0x114
000020  f7fffffe          BL       __aeabi_memcpy
;;;70         inContext->used = 0;
000024  2000              MOVS     r0,#0
000026  f8c40134          STR      r0,[r4,#0x134]
;;;71         inContext->legacy = false;
00002a  f8840138          STRB     r0,[r4,#0x138]
;;;72         return( kNoErr );
;;;73     }
00002e  bdf8              POP      {r3-r7,pc}
;;;74     
                          ENDP


                          AREA ||i.AES_CTR_Update||, CODE, READONLY, ALIGN=2

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                          REQUIRE _printf_str
                  AES_CTR_Update PROC
;;;97     
;;;98     OSStatus    AES_CTR_Update( AES_CTR_Context *inContext, const void *inSrc, size_t inLen, void *inDst )
000000  e92d4ff0          PUSH     {r4-r11,lr}
;;;99     {
000004  b087              SUB      sp,sp,#0x1c
000006  4604              MOV      r4,r0
000008  460e              MOV      r6,r1
00000a  4615              MOV      r5,r2
00000c  461f              MOV      r7,r3
;;;100        OSStatus            err;
;;;101        const uint8_t *     src;
;;;102        uint8_t *           dst;
;;;103        uint8_t *           buf;
;;;104        size_t              used;
;;;105        size_t              i;
;;;106        
;;;107        // inSrc and inDst may be the same, but otherwise, the buffers must not overlap.
;;;108        
;;;109    #if( DEBUG )
;;;110        if( inSrc != inDst ) check_ptr_overlap( inSrc, inLen, inDst, inLen );
00000e  42be              CMP      r6,r7
000010  d05d              BEQ      |L8.206|
000012  bf00              NOP      
000014  bf00              NOP      
000016  42be              CMP      r6,r7
000018  d329              BCC      |L8.110|
00001a  1978              ADDS     r0,r7,r5
00001c  42b0              CMP      r0,r6
00001e  d926              BLS      |L8.110|
000020  bf00              NOP      
000022  485d              LDR      r0,|L8.408|
000024  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
000026  b900              CBNZ     r0,|L8.42|
000028  e020              B        |L8.108|
                  |L8.42|
00002a  485c              LDR      r0,|L8.412|
00002c  f7fffffe          BL       mico_rtos_lock_mutex
000030  215c              MOVS     r1,#0x5c
000032  a05b              ADR      r0,|L8.416|
000034  f7fffffe          BL       strrchr
000038  b128              CBZ      r0,|L8.70|
00003a  215c              MOVS     r1,#0x5c
00003c  a058              ADR      r0,|L8.416|
00003e  f7fffffe          BL       strrchr
000042  1c40              ADDS     r0,r0,#1
000044  e000              B        |L8.72|
                  |L8.70|
000046  a056              ADR      r0,|L8.416|
                  |L8.72|
000048  9004              STR      r0,[sp,#0x10]
00004a  f7fffffe          BL       mico_get_time
00004e  9003              STR      r0,[sp,#0xc]
000050  a05e              ADR      r0,|L8.460|
000052  216e              MOVS     r1,#0x6e
000054  4b5e              LDR      r3,|L8.464|
000056  e9cd1000          STRD     r1,r0,[sp,#0]
00005a  a05e              ADR      r0,|L8.468|
00005c  e9dd1203          LDRD     r1,r2,[sp,#0xc]
000060  f7fffffe          BL       __2printf
000064  484d              LDR      r0,|L8.412|
000066  f7fffffe          BL       mico_rtos_unlock_mutex
00006a  bf00              NOP      
                  |L8.108|
00006c  bf00              NOP      
                  |L8.110|
00006e  bf00              NOP      
000070  bf00              NOP      
000072  42b7              CMP      r7,r6
000074  d329              BCC      |L8.202|
000076  1970              ADDS     r0,r6,r5
000078  42b8              CMP      r0,r7
00007a  d926              BLS      |L8.202|
00007c  bf00              NOP      
00007e  4846              LDR      r0,|L8.408|
000080  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
000082  b900              CBNZ     r0,|L8.134|
000084  e020              B        |L8.200|
                  |L8.134|
000086  4845              LDR      r0,|L8.412|
000088  f7fffffe          BL       mico_rtos_lock_mutex
00008c  215c              MOVS     r1,#0x5c
00008e  a044              ADR      r0,|L8.416|
000090  f7fffffe          BL       strrchr
000094  b128              CBZ      r0,|L8.162|
000096  215c              MOVS     r1,#0x5c
000098  a041              ADR      r0,|L8.416|
00009a  f7fffffe          BL       strrchr
00009e  1c40              ADDS     r0,r0,#1
0000a0  e000              B        |L8.164|
                  |L8.162|
0000a2  a03f              ADR      r0,|L8.416|
                  |L8.164|
0000a4  9004              STR      r0,[sp,#0x10]
0000a6  f7fffffe          BL       mico_get_time
0000aa  9003              STR      r0,[sp,#0xc]
0000ac  a047              ADR      r0,|L8.460|
0000ae  216e              MOVS     r1,#0x6e
0000b0  4b47              LDR      r3,|L8.464|
0000b2  e9cd1000          STRD     r1,r0,[sp,#0]
0000b6  a047              ADR      r0,|L8.468|
0000b8  e9dd1203          LDRD     r1,r2,[sp,#0xc]
0000bc  f7fffffe          BL       __2printf
0000c0  4836              LDR      r0,|L8.412|
0000c2  f7fffffe          BL       mico_rtos_unlock_mutex
0000c6  bf00              NOP      
                  |L8.200|
0000c8  bf00              NOP      
                  |L8.202|
0000ca  bf00              NOP      
0000cc  bf00              NOP      
                  |L8.206|
;;;111    #endif
;;;112        
;;;113        src = (const uint8_t *) inSrc;
0000ce  46b0              MOV      r8,r6
;;;114        dst = (uint8_t *) inDst;
0000d0  46b9              MOV      r9,r7
;;;115        
;;;116        // If there's any buffered key material from a previous block then use that first.
;;;117        
;;;118        buf  = inContext->buf;
0000d2  f5047092          ADD      r0,r4,#0x124
0000d6  9005              STR      r0,[sp,#0x14]
;;;119        used = inContext->used;
0000d8  f8d4a134          LDR      r10,[r4,#0x134]
;;;120        while( ( inLen > 0 ) && ( used != 0 ) ) 
0000dc  e00c              B        |L8.248|
                  |L8.222|
;;;121        {
;;;122            *dst++ = *src++ ^ buf[ used++ ];
0000de  f8180b01          LDRB     r0,[r8],#1
0000e2  4651              MOV      r1,r10
0000e4  f10a0a01          ADD      r10,r10,#1
0000e8  9a05              LDR      r2,[sp,#0x14]
0000ea  5c51              LDRB     r1,[r2,r1]
0000ec  4048              EORS     r0,r0,r1
0000ee  f8090b01          STRB     r0,[r9],#1
;;;123            used %= kAES_CTR_Size;
0000f2  f00a0a0f          AND      r10,r10,#0xf
;;;124            inLen -= 1;
0000f6  1e6d              SUBS     r5,r5,#1
                  |L8.248|
0000f8  b115              CBZ      r5,|L8.256|
0000fa  f1ba0f00          CMP      r10,#0                ;120
0000fe  d1ee              BNE      |L8.222|
                  |L8.256|
;;;125        }
;;;126        inContext->used = used;
000100  f8c4a134          STR      r10,[r4,#0x134]
;;;127        
;;;128        // Process whole blocks.
;;;129        
;;;130        while( inLen >= kAES_CTR_Size )
000104  e01e              B        |L8.324|
                  |L8.262|
;;;131        {
;;;132            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;133                err = CCCryptorUpdate( inContext->cryptor, inContext->ctr, kAES_CTR_Size, buf, kAES_CTR_Size, &i );
;;;134                require_noerr( err, exit );
;;;135                require_action( i == kAES_CTR_Size, exit, err = kSizeErr );
;;;136            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;137                aes_ecb_encrypt( inContext->ctr, buf, kAES_CTR_Size, &inContext->ctx );
;;;138            #elif( AES_UTILS_USE_MICO_AES )
;;;139                AesEncryptDirect( &inContext->ctx, buf, inContext->ctr );
000106  f504728a          ADD      r2,r4,#0x114
00010a  4620              MOV      r0,r4
00010c  9905              LDR      r1,[sp,#0x14]
00010e  f7fffffe          BL       AesEncryptDirect
;;;140            #elif( AES_UTILS_USE_USSL )
;;;141                aes_crypt_ecb( &inContext->ctx, AES_ENCRYPT, inContext->ctr, buf );
;;;142            #else
;;;143                AES_encrypt( inContext->ctr, buf, &inContext->key );
;;;144            #endif
;;;145            AES_CTR_Increment( inContext->ctr );
000112  f504708a          ADD      r0,r4,#0x114
000116  f7fffffe          BL       AES_CTR_Increment
;;;146            
;;;147            for( i = 0; i < kAES_CTR_Size; ++i )
00011a  f04f0b00          MOV      r11,#0
00011e  e009              B        |L8.308|
                  |L8.288|
;;;148            {
;;;149                dst[ i ] = src[ i ] ^ buf[ i ];
000120  f818000b          LDRB     r0,[r8,r11]
000124  9905              LDR      r1,[sp,#0x14]
000126  f811100b          LDRB     r1,[r1,r11]
00012a  4048              EORS     r0,r0,r1
00012c  f809000b          STRB     r0,[r9,r11]
000130  f10b0b01          ADD      r11,r11,#1            ;147
                  |L8.308|
000134  f1bb0f10          CMP      r11,#0x10             ;147
000138  d3f2              BCC      |L8.288|
;;;150            }
;;;151            src   += kAES_CTR_Size;
00013a  f1080810          ADD      r8,r8,#0x10
;;;152            dst   += kAES_CTR_Size;
00013e  f1090910          ADD      r9,r9,#0x10
;;;153            inLen -= kAES_CTR_Size;
000142  3d10              SUBS     r5,r5,#0x10
                  |L8.324|
000144  2d10              CMP      r5,#0x10              ;130
000146  d2de              BCS      |L8.262|
;;;154        }
;;;155        
;;;156        // Process any trailing sub-block bytes. Extra key material is buffered for next time.
;;;157        
;;;158        if( inLen > 0 )
000148  b1fd              CBZ      r5,|L8.394|
;;;159        {
;;;160            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;161                err = CCCryptorUpdate( inContext->cryptor, inContext->ctr, kAES_CTR_Size, buf, kAES_CTR_Size, &i );
;;;162                require_noerr( err, exit );
;;;163                require_action( i == kAES_CTR_Size, exit, err = kSizeErr );
;;;164            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;165                aes_ecb_encrypt( inContext->ctr, buf, kAES_CTR_Size, &inContext->ctx );
;;;166            #elif( AES_UTILS_USE_MICO_AES )
;;;167                AesEncryptDirect( &inContext->ctx, buf, inContext->ctr );
00014a  f504728a          ADD      r2,r4,#0x114
00014e  4620              MOV      r0,r4
000150  9905              LDR      r1,[sp,#0x14]
000152  f7fffffe          BL       AesEncryptDirect
;;;168            #elif( AES_UTILS_USE_USSL )
;;;169                aes_crypt_ecb( &inContext->ctx, AES_ENCRYPT, inContext->ctr, buf );
;;;170            #else
;;;171                AES_encrypt( inContext->ctr, buf, &inContext->key );
;;;172            #endif
;;;173            AES_CTR_Increment( inContext->ctr );
000156  f504708a          ADD      r0,r4,#0x114
00015a  f7fffffe          BL       AES_CTR_Increment
;;;174            
;;;175            for( i = 0; i < inLen; ++i )
00015e  f04f0b00          MOV      r11,#0
000162  e00b              B        |L8.380|
                  |L8.356|
;;;176            {
;;;177                *dst++ = *src++ ^ buf[ used++ ];
000164  f8180b01          LDRB     r0,[r8],#1
000168  4651              MOV      r1,r10
00016a  f10a0a01          ADD      r10,r10,#1
00016e  9a05              LDR      r2,[sp,#0x14]
000170  5c51              LDRB     r1,[r2,r1]
000172  4048              EORS     r0,r0,r1
000174  f8090b01          STRB     r0,[r9],#1
000178  f10b0b01          ADD      r11,r11,#1            ;175
                  |L8.380|
00017c  45ab              CMP      r11,r5                ;175
00017e  d3f1              BCC      |L8.356|
;;;178            }
;;;179            
;;;180            // For legacy mode, always leave the used amount as 0 so we always increment the counter each time.
;;;181            
;;;182            if( !inContext->legacy )
000180  f8940138          LDRB     r0,[r4,#0x138]
000184  b908              CBNZ     r0,|L8.394|
;;;183            {
;;;184                inContext->used = used;
000186  f8c4a134          STR      r10,[r4,#0x134]
                  |L8.394|
;;;185            }
;;;186        }
;;;187        err = kNoErr;
00018a  2000              MOVS     r0,#0
00018c  9006              STR      r0,[sp,#0x18]
;;;188        
;;;189    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;190    exit:
;;;191    #endif
;;;192        return( err );
00018e  9806              LDR      r0,[sp,#0x18]
;;;193    }
000190  b007              ADD      sp,sp,#0x1c
000192  e8bd8ff0          POP      {r4-r11,pc}
;;;194    
                          ENDP

000196  0000              DCW      0x0000
                  |L8.408|
                          DCD      mico_debug_enabled
                  |L8.412|
                          DCD      stdio_tx_mutex
                  |L8.416|
0001a0  2e2e5c2e          DCB      "..\\..\\..\\..\\libraries\\utilities\\AESUtils.c",0
0001a4  2e5c2e2e
0001a8  5c2e2e5c
0001ac  6c696272
0001b0  61726965
0001b4  735c7574
0001b8  696c6974
0001bc  6965735c
0001c0  41455355
0001c4  74696c73
0001c8  2e6300  
0001cb  00                DCB      0
                  |L8.460|
0001cc  00                DCB      0
0001cd  00                DCB      0
0001ce  00                DCB      0
0001cf  00                DCB      0
                  |L8.464|
                          DCD      __PRETTY_FUNCTION__
                  |L8.468|
0001d4  5b25645d          DCB      "[%d][MICO:%s:%s:%4d] **ASSERT** %s\r\n",0
0001d8  5b4d4943
0001dc  4f3a2573
0001e0  3a25733a
0001e4  2534645d
0001e8  202a2a41
0001ec  53534552
0001f0  542a2a20
0001f4  25730d0a
0001f8  00      
0001f9  00                DCB      0
0001fa  00                DCB      0
0001fb  00                DCB      0

                          AREA ||i.AES_ECB_Final||, CODE, READONLY, ALIGN=1

                  AES_ECB_Final PROC
;;;614    
;;;615    void    AES_ECB_Final( AES_ECB_Context *inContext )
000000  b510              PUSH     {r4,lr}
;;;616    {
000002  4604              MOV      r4,r0
;;;617    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;618        if( inContext->cryptor ) CCCryptorRelease( inContext->cryptor );
;;;619    #endif
;;;620        memset( inContext, 0, sizeof( *inContext ) ); // Clear sensitive data.
000004  f44f718c          MOV      r1,#0x118
000008  4620              MOV      r0,r4
00000a  f7fffffe          BL       __aeabi_memclr4
;;;621    }
00000e  bd10              POP      {r4,pc}
;;;622    
                          ENDP


                          AREA ||i.AES_ECB_Init||, CODE, READONLY, ALIGN=1

                  AES_ECB_Init PROC
;;;533    
;;;534    OSStatus    AES_ECB_Init( AES_ECB_Context *inContext, uint32_t inMode, const uint8_t inKey[ kAES_ECB_Size ] )
000000  b5f8              PUSH     {r3-r7,lr}
;;;535    {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
000006  4615              MOV      r5,r2
;;;536    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;537        OSStatus        err;
;;;538        
;;;539        inContext->cryptor = NULL;
;;;540        err = CCCryptorCreate( inMode, kCCAlgorithmAES128, kCCOptionECBMode, inKey, kAES_ECB_Size, NULL, &inContext->cryptor );
;;;541        check_noerr( err );
;;;542        if( err ) return( err );
;;;543    #elif( AES_UTILS_USE_GLADMAN_AES )
;;;544        aes_init();
;;;545        if( inMode == kAES_ECB_Mode_Encrypt )   aes_encrypt_key128( inKey, &inContext->ctx.encrypt );
;;;546        else                                    aes_decrypt_key128( inKey, &inContext->ctx.decrypt );
;;;547        inContext->encrypt = inMode;
;;;548    #elif( AES_UTILS_USE_MICO_AES )
;;;549        if( inMode == kAES_ECB_Mode_Encrypt )   AesSetKey( &inContext->ctx, inKey, kAES_ECB_Size, NULL, AES_ENCRYPTION );
000008  b944              CBNZ     r4,|L10.28|
00000a  2000              MOVS     r0,#0
00000c  4603              MOV      r3,r0
00000e  2210              MOVS     r2,#0x10
000010  4629              MOV      r1,r5
000012  9000              STR      r0,[sp,#0]
000014  4630              MOV      r0,r6
000016  f7fffffe          BL       AesSetKey
00001a  e007              B        |L10.44|
                  |L10.28|
;;;550        else                                    AesSetKey( &inContext->ctx, inKey, kAES_ECB_Size, NULL, AES_DECRYPTION );
00001c  2001              MOVS     r0,#1
00001e  2300              MOVS     r3,#0
000020  2210              MOVS     r2,#0x10
000022  4629              MOV      r1,r5
000024  9000              STR      r0,[sp,#0]
000026  4630              MOV      r0,r6
000028  f7fffffe          BL       AesSetKey
                  |L10.44|
;;;551    #elif( AES_UTILS_USE_USSL )
;;;552        if( inMode == kAES_ECB_Mode_Encrypt )   aes_setkey_enc( &inContext->ctx, (unsigned char *) inKey, kAES_ECB_Size * 8 );
;;;553        else                                    aes_setkey_dec( &inContext->ctx, (unsigned char *) inKey, kAES_ECB_Size * 8 );
;;;554        inContext->mode = inMode;
;;;555    #else
;;;556        AES_set_encrypt_key( inKey, kAES_ECB_Size * 8, &inContext->key );
;;;557        inContext->cryptFunc = ( inMode == kAES_ECB_Mode_Encrypt ) ? AES_encrypt : AES_decrypt;
;;;558    #endif
;;;559        return( kNoErr );
00002c  2000              MOVS     r0,#0
;;;560    }
00002e  bdf8              POP      {r3-r7,pc}
;;;561    
                          ENDP


                          AREA ||i.AES_ECB_Update||, CODE, READONLY, ALIGN=2

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                          REQUIRE _printf_str
                          REQUIRE _printf_str
                  AES_ECB_Update PROC
;;;565    
;;;566    OSStatus    AES_ECB_Update( AES_ECB_Context *inContext, const void *inSrc, size_t inLen, void *inDst )
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;567    {
000004  b083              SUB      sp,sp,#0xc
000006  460c              MOV      r4,r1
000008  4616              MOV      r6,r2
00000a  461d              MOV      r5,r3
;;;568        OSStatus            err;
;;;569        const uint8_t *     src;
;;;570        uint8_t *           dst;
;;;571        size_t              n;
;;;572        
;;;573        // inSrc and inDst may be the same, but otherwise, the buffers must not overlap.
;;;574        
;;;575    #if( DEBUG )
;;;576        if( inSrc != inDst ) check_ptr_overlap( inSrc, inLen, inDst, inLen );
00000c  42ac              CMP      r4,r5
00000e  d05f              BEQ      |L11.208|
000010  bf00              NOP      
000012  bf00              NOP      
000014  42ac              CMP      r4,r5
000016  d32a              BCC      |L11.110|
000018  19a8              ADDS     r0,r5,r6
00001a  42a0              CMP      r0,r4
00001c  d927              BLS      |L11.110|
00001e  bf00              NOP      
000020  484d              LDR      r0,|L11.344|
000022  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
000024  b900              CBNZ     r0,|L11.40|
000026  e021              B        |L11.108|
                  |L11.40|
000028  484c              LDR      r0,|L11.348|
00002a  f7fffffe          BL       mico_rtos_lock_mutex
00002e  215c              MOVS     r1,#0x5c
000030  a04b              ADR      r0,|L11.352|
000032  f7fffffe          BL       strrchr
000036  b128              CBZ      r0,|L11.68|
000038  215c              MOVS     r1,#0x5c
00003a  a049              ADR      r0,|L11.352|
00003c  f7fffffe          BL       strrchr
000040  1c40              ADDS     r0,r0,#1
000042  e000              B        |L11.70|
                  |L11.68|
000044  a046              ADR      r0,|L11.352|
                  |L11.70|
000046  4683              MOV      r11,r0
000048  f7fffffe          BL       mico_get_time
00004c  9002              STR      r0,[sp,#8]
00004e  a04f              ADR      r0,|L11.396|
000050  f44f7110          MOV      r1,#0x240
000054  4b4e              LDR      r3,|L11.400|
000056  465a              MOV      r2,r11
000058  e9cd1000          STRD     r1,r0,[sp,#0]
00005c  a04d              ADR      r0,|L11.404|
00005e  9902              LDR      r1,[sp,#8]
000060  f7fffffe          BL       __2printf
000064  483d              LDR      r0,|L11.348|
000066  f7fffffe          BL       mico_rtos_unlock_mutex
00006a  bf00              NOP      
                  |L11.108|
00006c  bf00              NOP      
                  |L11.110|
00006e  bf00              NOP      
000070  bf00              NOP      
000072  42a5              CMP      r5,r4
000074  d32a              BCC      |L11.204|
000076  19a0              ADDS     r0,r4,r6
000078  42a8              CMP      r0,r5
00007a  d927              BLS      |L11.204|
00007c  bf00              NOP      
00007e  4836              LDR      r0,|L11.344|
000080  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
000082  b900              CBNZ     r0,|L11.134|
000084  e021              B        |L11.202|
                  |L11.134|
000086  4835              LDR      r0,|L11.348|
000088  f7fffffe          BL       mico_rtos_lock_mutex
00008c  215c              MOVS     r1,#0x5c
00008e  a034              ADR      r0,|L11.352|
000090  f7fffffe          BL       strrchr
000094  b128              CBZ      r0,|L11.162|
000096  215c              MOVS     r1,#0x5c
000098  a031              ADR      r0,|L11.352|
00009a  f7fffffe          BL       strrchr
00009e  1c40              ADDS     r0,r0,#1
0000a0  e000              B        |L11.164|
                  |L11.162|
0000a2  a02f              ADR      r0,|L11.352|
                  |L11.164|
0000a4  4683              MOV      r11,r0
0000a6  f7fffffe          BL       mico_get_time
0000aa  9002              STR      r0,[sp,#8]
0000ac  a037              ADR      r0,|L11.396|
0000ae  f44f7110          MOV      r1,#0x240
0000b2  4b37              LDR      r3,|L11.400|
0000b4  465a              MOV      r2,r11
0000b6  e9cd1000          STRD     r1,r0,[sp,#0]
0000ba  a036              ADR      r0,|L11.404|
0000bc  9902              LDR      r1,[sp,#8]
0000be  f7fffffe          BL       __2printf
0000c2  4826              LDR      r0,|L11.348|
0000c4  f7fffffe          BL       mico_rtos_unlock_mutex
0000c8  bf00              NOP      
                  |L11.202|
0000ca  bf00              NOP      
                  |L11.204|
0000cc  bf00              NOP      
0000ce  bf00              NOP      
                  |L11.208|
;;;577        if( ( inLen % kAES_ECB_Size ) != 0 ) aes_log( "ECB doesn't support non-block-sized operations (%d bytes)", (int)inLen );
0000d0  f006000f          AND      r0,r6,#0xf
0000d4  2800              CMP      r0,#0
0000d6  d026              BEQ      |L11.294|
0000d8  bf00              NOP      
0000da  481f              LDR      r0,|L11.344|
0000dc  6800              LDR      r0,[r0,#0]  ; mico_debug_enabled
0000de  b900              CBNZ     r0,|L11.226|
0000e0  e020              B        |L11.292|
                  |L11.226|
0000e2  481e              LDR      r0,|L11.348|
0000e4  f7fffffe          BL       mico_rtos_lock_mutex
0000e8  215c              MOVS     r1,#0x5c
0000ea  a01d              ADR      r0,|L11.352|
0000ec  f7fffffe          BL       strrchr
0000f0  b128              CBZ      r0,|L11.254|
0000f2  215c              MOVS     r1,#0x5c
0000f4  a01a              ADR      r0,|L11.352|
0000f6  f7fffffe          BL       strrchr
0000fa  1c40              ADDS     r0,r0,#1
0000fc  e000              B        |L11.256|
                  |L11.254|
0000fe  a018              ADR      r0,|L11.352|
                  |L11.256|
000100  4683              MOV      r11,r0
000102  f7fffffe          BL       mico_get_time
000106  9002              STR      r0,[sp,#8]
000108  f2402041          MOV      r0,#0x241
00010c  465b              MOV      r3,r11
00010e  a22b              ADR      r2,|L11.444|
000110  e9cd0600          STRD     r0,r6,[sp,#0]
000114  482a              LDR      r0,|L11.448|
000116  9902              LDR      r1,[sp,#8]
000118  f7fffffe          BL       __2printf
00011c  480f              LDR      r0,|L11.348|
00011e  f7fffffe          BL       mico_rtos_unlock_mutex
000122  bf00              NOP      
                  |L11.292|
000124  bf00              NOP      
                  |L11.294|
;;;578    #endif
;;;579        
;;;580        src = (const uint8_t *) inSrc;
000126  4627              MOV      r7,r4
;;;581        dst = (uint8_t *) inDst;
000128  46a8              MOV      r8,r5
;;;582        for( n = inLen / kAES_ECB_Size; n > 0; --n )
00012a  ea4f1916          LSR      r9,r6,#4
00012e  e009              B        |L11.324|
                  |L11.304|
;;;583        {
;;;584            #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;585                size_t      len;
;;;586                
;;;587                err = CCCryptorUpdate( inContext->cryptor, src, kAES_ECB_Size, dst, kAES_ECB_Size, &len );
;;;588                require_noerr( err, exit );
;;;589                check( len == kAES_ECB_Size );
;;;590            #elif( AES_UTILS_USE_GLADMAN_AES )
;;;591                if( inContext->encrypt )    aes_ecb_encrypt( src, dst, kAES_ECB_Size, &inContext->ctx.encrypt );
;;;592                else                        aes_ecb_decrypt( src, dst, kAES_ECB_Size, &inContext->ctx.decrypt );
;;;593            #elif( AES_UTILS_USE_MICO_AES )
;;;594                AesEncryptDirect( &inContext->ctx, dst, src );
000130  463a              MOV      r2,r7
000132  4641              MOV      r1,r8
000134  9803              LDR      r0,[sp,#0xc]
000136  f7fffffe          BL       AesEncryptDirect
;;;595            #elif( AES_UTILS_USE_USSL )
;;;596                aes_crypt_ecb( &inContext->ctx, inContext->mode, (unsigned char *) src, dst );
;;;597            #else
;;;598                inContext->cryptFunc( src, dst, &inContext->key );
;;;599            #endif
;;;600            src += kAES_ECB_Size;
00013a  3710              ADDS     r7,r7,#0x10
;;;601            dst += kAES_ECB_Size;
00013c  f1080810          ADD      r8,r8,#0x10
000140  f1a90901          SUB      r9,r9,#1              ;582
                  |L11.324|
000144  f1b90f00          CMP      r9,#0                 ;582
000148  d1f2              BNE      |L11.304|
;;;602        }
;;;603        err = kNoErr;
00014a  f04f0a00          MOV      r10,#0
;;;604        
;;;605    #if( AES_UTILS_USE_COMMON_CRYPTO )
;;;606    exit:
;;;607    #endif
;;;608        return( err );
00014e  4650              MOV      r0,r10
;;;609    }
000150  b007              ADD      sp,sp,#0x1c
000152  e8bd8ff0          POP      {r4-r11,pc}
;;;610    
                          ENDP

000156  0000              DCW      0x0000
                  |L11.344|
                          DCD      mico_debug_enabled
                  |L11.348|
                          DCD      stdio_tx_mutex
                  |L11.352|
000160  2e2e5c2e          DCB      "..\\..\\..\\..\\libraries\\utilities\\AESUtils.c",0
000164  2e5c2e2e
000168  5c2e2e5c
00016c  6c696272
000170  61726965
000174  735c7574
000178  696c6974
00017c  6965735c
000180  41455355
000184  74696c73
000188  2e6300  
00018b  00                DCB      0
                  |L11.396|
00018c  00                DCB      0
00018d  00                DCB      0
00018e  00                DCB      0
00018f  00                DCB      0
                  |L11.400|
                          DCD      |symbol_number.30|
                  |L11.404|
000194  5b25645d          DCB      "[%d][MICO:%s:%s:%4d] **ASSERT** %s\r\n",0
000198  5b4d4943
00019c  4f3a2573
0001a0  3a25733a
0001a4  2534645d
0001a8  202a2a41
0001ac  53534552
0001b0  542a2a20
0001b4  25730d0a
0001b8  00      
0001b9  00                DCB      0
0001ba  00                DCB      0
0001bb  00                DCB      0
                  |L11.444|
0001bc  41455300          DCB      "AES",0
                  |L11.448|
                          DCD      ||.conststring||

                          AREA ||.constdata||, DATA, READONLY, ALIGN=0

                  __PRETTY_FUNCTION__
000000  7369676e          DCB      0x73,0x69,0x67,0x6e
000004  65642069          DCB      0x65,0x64,0x20,0x69
000008  6e742041          DCB      0x6e,0x74,0x20,0x41
00000c  45535f43          DCB      0x45,0x53,0x5f,0x43
000010  54525f55          DCB      0x54,0x52,0x5f,0x55
000014  70646174          DCB      0x70,0x64,0x61,0x74
000018  65287374          DCB      0x65,0x28,0x73,0x74
00001c  72756374          DCB      0x72,0x75,0x63,0x74
000020  203c756e          DCB      0x20,0x3c,0x75,0x6e
000024  6e616d65          DCB      0x6e,0x61,0x6d,0x65
000028  643e202a          DCB      0x64,0x3e,0x20,0x2a
00002c  2c20636f          DCB      0x2c,0x20,0x63,0x6f
000030  6e737420          DCB      0x6e,0x73,0x74,0x20
000034  766f6964          DCB      0x76,0x6f,0x69,0x64
000038  202a2c20          DCB      0x20,0x2a,0x2c,0x20
00003c  756e7369          DCB      0x75,0x6e,0x73,0x69
000040  676e6564          DCB      0x67,0x6e,0x65,0x64
000044  20696e74          DCB      0x20,0x69,0x6e,0x74
000048  2c20766f          DCB      0x2c,0x20,0x76,0x6f
00004c  6964202a          DCB      0x69,0x64,0x20,0x2a
000050  2900              DCB      0x29,0x00
                  |symbol_number.30|
000052  7369              DCB      0x73,0x69
000054  676e6564          DCB      0x67,0x6e,0x65,0x64
000058  20696e74          DCB      0x20,0x69,0x6e,0x74
00005c  20414553          DCB      0x20,0x41,0x45,0x53
000060  5f454342          DCB      0x5f,0x45,0x43,0x42
000064  5f557064          DCB      0x5f,0x55,0x70,0x64
000068  61746528          DCB      0x61,0x74,0x65,0x28
00006c  73747275          DCB      0x73,0x74,0x72,0x75
000070  6374203c          DCB      0x63,0x74,0x20,0x3c
000074  756e6e61          DCB      0x75,0x6e,0x6e,0x61
000078  6d65643e          DCB      0x6d,0x65,0x64,0x3e
00007c  202a2c20          DCB      0x20,0x2a,0x2c,0x20
000080  636f6e73          DCB      0x63,0x6f,0x6e,0x73
000084  7420766f          DCB      0x74,0x20,0x76,0x6f
000088  6964202a          DCB      0x69,0x64,0x20,0x2a
00008c  2c20756e          DCB      0x2c,0x20,0x75,0x6e
000090  7369676e          DCB      0x73,0x69,0x67,0x6e
000094  65642069          DCB      0x65,0x64,0x20,0x69
000098  6e742c20          DCB      0x6e,0x74,0x2c,0x20
00009c  766f6964          DCB      0x76,0x6f,0x69,0x64
0000a0  202a2900          DCB      0x20,0x2a,0x29,0x00

                          AREA ||.conststring||, DATA, READONLY, MERGE=1, STRINGS, ALIGN=2

000000  5b25645d          DCB      "[%d][%s: %s:%4d] ECB doesn't support non-block-sized op"
000004  5b25733a
000008  2025733a
00000c  2534645d
000010  20454342
000014  20646f65
000018  736e2774
00001c  20737570
000020  706f7274
000024  206e6f6e
000028  2d626c6f
00002c  636b2d73
000030  697a6564
000034  206f70  
000037  65726174          DCB      "erations (%d bytes)\r\n",0
00003b  696f6e73
00003f  20282564
000043  20627974
000047  6573290d
00004b  0a00    
