diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/api.h b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/api.h new file mode 100644 index 0000000..a4aa567 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/api.h @@ -0,0 +1,5 @@ +#define CRYPTO_KEYBYTES 16 +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 16 +#define CRYPTO_ABYTES 16 +#define CRYPTO_NOOVERLAP 1 diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/crypto_aead.h b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/crypto_aead.h new file mode 100644 index 0000000..cfc09d6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/crypto_aead.h @@ -0,0 +1,11 @@ +int crypto_aead_encrypt(unsigned char *c, unsigned long long *clen, + const unsigned char *m, unsigned long long mlen, + const unsigned char *ad, unsigned long long adlen, + const unsigned char *nsec, const unsigned char *npub, + const unsigned char *k); + +int crypto_aead_decrypt(unsigned char *m, unsigned long long *outputmlen, + unsigned char *nsec, + const unsigned char *c, unsigned long long clen, + const unsigned char *ad, unsigned long long adlen, + const unsigned char *npub, const unsigned char *k); diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/encrypt.c b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/encrypt.c new file mode 100644 index 0000000..91d0e6e --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/encrypt.c @@ -0,0 +1,738 @@ +/* + * Date: 29 November 2018 + * Contact: Thomas Peyrin - thomas.peyrin@gmail.com + * Mustafa Khairallah - mustafam001@e.ntu.edu.sg + */ + +#include "crypto_aead.h" +#include "api.h" +#include "skinny.h" +#include +#include + +void pad (const unsigned char* m, unsigned char* mp, int l, int len8) { + int i; + + for (i = 0; i < l; i++) { + if (i < len8) { + mp[i] = m[i]; + } + else if (i == l - 1) { + mp[i] = (len8 & 0x0f); + } + else { + mp[i] = 0x00; + } + } + +} + +void g8A (unsigned char* s, unsigned char* c) { + unsigned int tmps[4]; + unsigned int tmpc[4]; + + tmps[0] = *((unsigned int *)&s[0]); + tmps[1] = *((unsigned int *)&s[4]); + tmps[2] = *((unsigned int *)&s[8]); + tmps[3] = *((unsigned int *)&s[12]); + + // c[i] = (s[i] >> 1) ^ (s[i] & 0x80) ^ ((s[i] & 0x01) << 7); + // + // (s[i] >> 1) -> ((s[i]>>1)&0x7f) + // (s[i] & 0x80) -> (s[i])&0x80) not changed + // ((s[i] & 0x01) << 7) -> ((s[i]<<7)&0x80) + + // use word access because of speeding up + tmpc[0] = ((tmps[0]>>1) & 0x7f7f7f7f) ^ (tmps[0] & 0x80808080) ^ ((tmps[0]<<7) & 0x80808080); + tmpc[1] = ((tmps[1]>>1) & 0x7f7f7f7f) ^ (tmps[1] & 0x80808080) ^ ((tmps[1]<<7) & 0x80808080); + tmpc[2] = ((tmps[2]>>1) & 0x7f7f7f7f) ^ (tmps[2] & 0x80808080) ^ ((tmps[2]<<7) & 0x80808080); + tmpc[3] = ((tmps[3]>>1) & 0x7f7f7f7f) ^ (tmps[3] & 0x80808080) ^ ((tmps[3]<<7) & 0x80808080); + + *((unsigned int *)&c[0]) = tmpc[0]; + *((unsigned int *)&c[4]) = tmpc[1]; + *((unsigned int *)&c[8]) = tmpc[2]; + *((unsigned int *)&c[12]) = tmpc[3]; +} + +void g8A_for_Tag_Generation (unsigned char* s, unsigned char* c) { + unsigned int tmps[4]; + unsigned int tmpc[4]; + + tmps[0] = *((unsigned int *)&s[0]); + tmps[1] = *((unsigned int *)&s[4]); + tmps[2] = *((unsigned int *)&s[8]); + tmps[3] = *((unsigned int *)&s[12]); + + // c[i] = (s[i] >> 1) ^ (s[i] & 0x80) ^ ((s[i] & 0x01) << 7); + // + // (s[i] >> 1) -> ((s[i]>>1)&0x7f) + // (s[i] & 0x80) -> (s[i])&0x80) not changed + // ((s[i] & 0x01) << 7) -> ((s[i]<<7)&0x80) + + // use word access because of speeding up + tmpc[0] = ((tmps[0]>>1) & 0x7f7f7f7f) ^ (tmps[0] & 0x80808080) ^ ((tmps[0]<<7) & 0x80808080); + tmpc[1] = ((tmps[1]>>1) & 0x7f7f7f7f) ^ (tmps[1] & 0x80808080) ^ ((tmps[1]<<7) & 0x80808080); + tmpc[2] = ((tmps[2]>>1) & 0x7f7f7f7f) ^ (tmps[2] & 0x80808080) ^ ((tmps[2]<<7) & 0x80808080); + tmpc[3] = ((tmps[3]>>1) & 0x7f7f7f7f) ^ (tmps[3] & 0x80808080) ^ ((tmps[3]<<7) & 0x80808080); + + // use byte access because of memory alignment. + // c is not always in word(4 byte) alignment. + c[0] = tmpc[0] &0xFF; + c[1] = (tmpc[0]>>8) &0xFF; + c[2] = (tmpc[0]>>16)&0xFF; + c[3] = (tmpc[0]>>24)&0xFF; + c[4] = tmpc[1] &0xFF; + c[5] = (tmpc[1]>>8) &0xFF; + c[6] = (tmpc[1]>>16)&0xFF; + c[7] = (tmpc[1]>>24)&0xFF; + c[8] = tmpc[2] &0xFF; + c[9] = (tmpc[2]>>8) &0xFF; + c[10] = (tmpc[2]>>16)&0xFF; + c[11] = (tmpc[2]>>24)&0xFF; + c[12] = tmpc[3] &0xFF; + c[13] = (tmpc[3]>>8) &0xFF; + c[14] = (tmpc[3]>>16)&0xFF; + c[15] = (tmpc[3]>>24)&0xFF; +} + +void rho_ad_eqov16 (const unsigned char* m, + unsigned char* s) { + *((unsigned int *)&s[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&m[12]); +} + +void rho_ad_ud16 (const unsigned char* m, + unsigned char* s, + int len8) { + unsigned char mp [16]; + + pad(m,mp,16,len8); + *((unsigned int *)&s[0]) ^= *((unsigned int *)&mp[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&mp[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&mp[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&mp[12]); +} + +void rho_eqov16 (const unsigned char* m, + unsigned char* c, + unsigned char* s) { + g8A(s,c); + + *((unsigned int *)&s[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&m[12]); + + *((unsigned int *)&c[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&c[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&c[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&c[12]) ^= *((unsigned int *)&m[12]); +} + +void rho_ud16 (const unsigned char* m, + unsigned char* c, + unsigned char* s, + int len8, + int ver) { + int i; + unsigned char mp [16]; + + pad(m,mp,ver,len8); + + g8A(s,c); + *((unsigned int *)&s[0]) ^= *((unsigned int *)&mp[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&mp[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&mp[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&mp[12]); + for (i = 0; i < ver; i++) { + if (i < len8) { + c[i] = c[i] ^ mp[i]; + } + else { + c[i] = 0; + } + } +} + +void irho (unsigned char* m, + const unsigned char* c, + unsigned char* s, + int len8, + int ver) { + int i; + unsigned char cp [16]; + + pad(c,cp,ver,len8); + + g8A(s,m); + for (i = 0; i < ver; i++) { + if (i < len8) { + s[i] = s[i] ^ cp[i] ^ m[i]; + } + else { + s[i] = s[i] ^ cp[i]; + } + if (i < len8) { + m[i] = m[i] ^ cp[i]; + } + else { + m[i] = 0; + } + } +} + +void reset_lfsr_gf56 (unsigned char* CNT) { + *((unsigned int *)&CNT[0]) = 0x00000001; + *((unsigned int *)&CNT[4]) = 0x00000000; +} + +void lfsr_gf56 (unsigned char* CNT) { + unsigned int tmpCNT[2]; + unsigned int fb0; + + tmpCNT[0] = *((unsigned int *)&CNT[0]); // CNT3 CNT2 CNT1 CNT0 + tmpCNT[1] = *((unsigned int *)&CNT[4]); // CNT7 CNT6 CNT5 CNT4 + + fb0 = 0; + if ((tmpCNT[1] >> 23)&0x01) { + fb0 = 0x95; + } + + tmpCNT[1] = tmpCNT[1] << 1 | tmpCNT[0] >> 31; + tmpCNT[0] = tmpCNT[0] << 1 ^ fb0; + + *((unsigned int *)&CNT[0]) = tmpCNT[0]; + *((unsigned int *)&CNT[4]) = tmpCNT[1]; +} + +void block_cipher(unsigned char* s, + const unsigned char* k, unsigned char* T, + unsigned char* CNT, + skinny_ctrl* p_skinny_ctrl) { + p_skinny_ctrl->func_skinny_128_384_enc (s,p_skinny_ctrl,CNT,T,k); +} + +void nonce_encryption (const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + skinny_ctrl* p_skinny_ctrl) { + unsigned char T [16]; + *((unsigned int *)&T[0]) = *((unsigned int *)&N[0]); + *((unsigned int *)&T[4]) = *((unsigned int *)&N[4]); + *((unsigned int *)&T[8]) = *((unsigned int *)&N[8]); + *((unsigned int *)&T[12]) = *((unsigned int *)&N[12]); + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + +} + +void generate_tag (unsigned char** c, unsigned char* s, + int n, unsigned long long* clen) { + + g8A_for_Tag_Generation(s, *c); + *c = *c + n; + *c = *c - *clen; + +} + +unsigned long long msg_encryption (const unsigned char** M, unsigned char** c, + const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long mlen, + skinny_ctrl* p_skinny_ctrl) { + int len8; + + if (mlen >= 16) { + len8 = 16; + mlen = mlen - 16; + rho_eqov16(*M, *c, s); + } + else { + len8 = mlen; + mlen = 0; + rho_ud16(*M, *c, s, len8, 16); + } + *c = *c + len8; + *M = *M + len8; + lfsr_gf56(CNT); + if (mlen != 0) { + nonce_encryption(N,CNT,s,k,D,p_skinny_ctrl); + } + return mlen; +} + + + +unsigned long long msg_decryption (unsigned char** M, const unsigned char** c, + const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long clen, + skinny_ctrl* p_skinny_ctrl) { + int len8; + + if (clen >= 16) { + len8 = 16; + clen = clen - 16; + } + else { + len8 = clen; + clen = 0; + } + irho(*M, *c, s, len8, 16); + *c = *c + len8; + *M = *M + len8; + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,D,p_skinny_ctrl); + return clen; +} + +unsigned long long ad2msg_encryption (const unsigned char** M, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long mlen, + skinny_ctrl* p_skinny_ctrl) { + unsigned char T [16]; + int len8; + + if (mlen <= 16) { + len8 = mlen; + mlen = 0; + + pad (*M,T,16,len8); + } + else { + len8 = 16; + mlen = mlen - 16; + + unsigned char *pM = (unsigned char *)(*M); + *((unsigned int *)&T[0]) = *((unsigned int *)&pM[0]); + *((unsigned int *)&T[4]) = *((unsigned int *)&pM[4]); + *((unsigned int *)&T[8]) = *((unsigned int *)&pM[8]); + *((unsigned int *)&T[12]) = *((unsigned int *)&pM[12]); + } + + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + lfsr_gf56(CNT); + *M = *M + len8; + + return mlen; + +} + + +unsigned long long ad_encryption (const unsigned char** A, unsigned char* s, + const unsigned char* k, unsigned long long adlen, + unsigned char* CNT, + unsigned char D, + skinny_ctrl* p_skinny_ctrl) { + + unsigned char T [16]; + int len8; + + if (adlen >= 16) { + len8 = 16; + adlen = adlen - 16; + rho_ad_eqov16(*A, s); + } + else { + len8 = adlen; + adlen = 0; + rho_ad_ud16(*A, s, len8); + } + *A = *A + len8; + lfsr_gf56(CNT); + if (adlen != 0) { + if (adlen >= 16) { + len8 = 16; + adlen = adlen - 16; + + unsigned char *pA = (unsigned char *)(*A); + *((unsigned int *)&T[0]) = *((unsigned int *)&pA[0]); + *((unsigned int *)&T[4]) = *((unsigned int *)&pA[4]); + *((unsigned int *)&T[8]) = *((unsigned int *)&pA[8]); + *((unsigned int *)&T[12]) = *((unsigned int *)&pA[12]); + } + else { + len8 = adlen; + adlen = 0; + + pad(*A, T, 16, len8); + } + *A = *A + len8; + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + lfsr_gf56(CNT); + } + + return adlen; +} + +int crypto_aead_encrypt ( + unsigned char* c, unsigned long long* clen, + const unsigned char* m, unsigned long long mlen, + const unsigned char* ad, unsigned long long adlen, + const unsigned char* nsec, + const unsigned char* npub, + const unsigned char* k + ) +{ + unsigned char s[16]; + unsigned char CNT[8]; // size 7 -> 8 for word access + unsigned char T[16]; + const unsigned char* N; + unsigned char w; + unsigned long long xlen; + + skinny_ctrl l_skinny_ctrl; + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc123_12; + + (void)nsec; + N = npub; + + xlen = mlen; + + *((unsigned int *)&s[0]) = 0x00000000; + *((unsigned int *)&s[4]) = 0x00000000; + *((unsigned int *)&s[8]) = 0x00000000; + *((unsigned int *)&s[12]) = 0x00000000; + reset_lfsr_gf56(CNT); + + w = 48; + + if (adlen == 0) { + w = w ^ 2; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) == 0) { + w = w ^ 8; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) < 16) { + w = w ^ 2; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) == 16) { + w = w ^ 0; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else { + w = w ^ 10; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + + if (adlen == 0) { // AD is an empty string + lfsr_gf56(CNT); + } + else while (adlen > 0) { + adlen = ad_encryption(&ad,s,k,adlen,CNT,40,&l_skinny_ctrl); + } + + if ((w & 8) == 0) { + xlen = ad2msg_encryption (&m,CNT,s,k,44,xlen,&l_skinny_ctrl); + } + else if (mlen == 0) { + lfsr_gf56(CNT); + } + while (xlen > 0) { + xlen = ad_encryption(&m,s,k,xlen,CNT,44,&l_skinny_ctrl); + } + nonce_encryption(N,CNT,s,k,w,&l_skinny_ctrl); + + // because, nonce_encryption is called at the last block of AD encryption + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc1_1; + + // Tag generation + g8A(s, T); + + m = m - mlen; + + reset_lfsr_gf56(CNT); + + *((unsigned int *)&s[0]) = *((unsigned int *)&T[0]); + *((unsigned int *)&s[4]) = *((unsigned int *)&T[4]); + *((unsigned int *)&s[8]) = *((unsigned int *)&T[8]); + *((unsigned int *)&s[12]) = *((unsigned int *)&T[12]); + + *clen = mlen + 16; + + if (mlen > 0) { + nonce_encryption(N,CNT,s,k,36,&l_skinny_ctrl); + while (mlen > 16) { + mlen = msg_encryption(&m,&c,N,CNT,s,k,36,mlen,&l_skinny_ctrl); + } + rho_ud16(m, c, s, mlen, 16); + c = c + mlen; + m = m + mlen; + } + + // Tag Concatenation + + // use byte access because of memory alignment. + // c is not always in word(4 byte) alignment. + + for (int i = 0; i < 16; i = i + 1) { + *(c + i) = T[i]; + } + + c = c - *clen; + + return 0; +} + +int crypto_aead_decrypt( +unsigned char *m,unsigned long long *mlen, +unsigned char *nsec, +const unsigned char *c,unsigned long long clen, +const unsigned char *ad,unsigned long long adlen, +const unsigned char *npub, +const unsigned char *k +) +{ + unsigned char s[16]; + unsigned char CNT[8]; // size 7 -> 8 for word access + unsigned char T[16]; + const unsigned char* N; + unsigned char w; + unsigned long long xlen; + const unsigned char* mauth; + + skinny_ctrl l_skinny_ctrl; + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc123_12; + + (void)nsec; + mauth = m; + + N = npub; + + xlen = clen-16; + + reset_lfsr_gf56(CNT); + + for (int i = 0; i < 16; i++) { + T[i] = *(c + clen - 16 + i); + } + + *((unsigned int *)&s[0]) = *((unsigned int *)&T[0]); + *((unsigned int *)&s[4]) = *((unsigned int *)&T[4]); + *((unsigned int *)&s[8]) = *((unsigned int *)&T[8]); + *((unsigned int *)&s[12]) = *((unsigned int *)&T[12]); + + clen = clen - 16; + *mlen = clen; + + if (clen > 0) { + nonce_encryption(N,CNT,s,k,36,&l_skinny_ctrl); + while (clen > 16) { + clen = msg_decryption(&m,&c,N,CNT,s,k,36,clen,&l_skinny_ctrl); + } + irho(m, c, s, clen, 16); + c = c + clen; + m = m + clen; + } + + *((unsigned int *)&s[0]) = 0x00000000; + *((unsigned int *)&s[4]) = 0x00000000; + *((unsigned int *)&s[8]) = 0x00000000; + *((unsigned int *)&s[12]) = 0x00000000; + reset_lfsr_gf56(CNT); + + w = 48; + + if (adlen == 0) { + w = w ^ 2; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) == 0) { + w = w ^ 8; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) < 16) { + w = w ^ 2; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else if (adlen%(32) == 16) { + w = w ^ 0; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + else { + w = w ^ 10; + if (xlen == 0) { + w =w ^ 1; + } + else if (xlen%(32) == 0) { + w = w ^ 4; + } + else if (xlen%(32) < 16) { + w = w ^ 1; + } + else if (xlen%(32) == 16) { + w = w ^ 0; + } + else { + w = w ^ 5; + } + } + + if (adlen == 0) { // AD is an empty string + lfsr_gf56(CNT); + } + else while (adlen > 0) { + adlen = ad_encryption(&ad,s,k,adlen,CNT,40,&l_skinny_ctrl); + } + + if ((w & 8) == 0) { + xlen = ad2msg_encryption (&mauth,CNT,s,k,44,xlen,&l_skinny_ctrl); + } + else if (clen == 0) { + lfsr_gf56(CNT); + } + while (xlen > 0) { + xlen = ad_encryption(&mauth,s,k,xlen,CNT,44,&l_skinny_ctrl); + } + nonce_encryption(N,CNT,s,k,w,&l_skinny_ctrl); + + // Tag generation + g8A_for_Tag_Generation(s, T); + for (int i = 0; i < 16; i++) { + if (T[i] != (*(c+i))) { + return -1; + } + } + + return 0; +} diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny.h b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny.h new file mode 100644 index 0000000..2da62ae --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny.h @@ -0,0 +1,8 @@ +typedef struct ___skinny_ctrl { + unsigned char roundKeys[704]; // number of round : 40 + void (*func_skinny_128_384_enc)(unsigned char*, struct ___skinny_ctrl*, unsigned char* CNT, unsigned char* T, const unsigned char* K); +} skinny_ctrl; + +extern void skinny_128_384_enc123_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); +extern void skinny_128_384_enc12_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); +extern void skinny_128_384_enc1_1 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule2.c b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule2.c new file mode 100644 index 0000000..1315e83 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule2.c @@ -0,0 +1,2163 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * load * AC(c0 c1) ^ TK3 + * calc AC(c0 c1) ^ TK2 -> store + * ART(TK2) + * + * number of rounds : 40 + */ + +__attribute__((aligned(4))) +void RunEncryptionKeyScheduleTK2(unsigned char *roundKeys) +{ + // r0 : points to roundKeys(& masterKey) + // r1-r4 : key state + // r5-r6 : temp use + // r7 : constant(0xfefefefe) + // r8 : constant(0x01010101) + // r9 : temp use + // r10 : temp use + asm volatile( + "stmdb sp!, {r4-r10} \n\t" + "ldr.w r1, [r0,#16] \n\t" // load master key + "ldr.w r2, [r0,#20] \n\t" // load master key + "ldr.w r3, [r0,#24] \n\t" // load master key + "ldr.w r4, [r0,#28] \n\t" // load master key + "mov.w r7, #0xfefefefe \n\t" + "mov.w r8, #0x01010101 \n\t" + + // round 1 + + "ldr.w r9, [r0,#384] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#388] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#64] \n\t" + "str.w r10, [r0,#68] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 2 + + "ldr.w r9, [r0,#392] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#396] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#72] \n\t" + "str.w r10, [r0,#76] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 3 + + "ldr.w r9, [r0,#400] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#404] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#80] \n\t" + "str.w r10, [r0,#84] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 4 + + "ldr.w r9, [r0,#408] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#412] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#88] \n\t" + "str.w r10, [r0,#92] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 5 + + "ldr.w r9, [r0,#416] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#420] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#96] \n\t" + "str.w r10, [r0,#100] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 6 + + "ldr.w r9, [r0,#424] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#428] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#104] \n\t" + "str.w r10, [r0,#108] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 7 + + "ldr.w r9, [r0,#432] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#436] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#112] \n\t" + "str.w r10, [r0,#116] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 8 + + "ldr.w r9, [r0,#440] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#444] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#120] \n\t" + "str.w r10, [r0,#124] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 9 + + "ldr.w r9, [r0,#448] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#452] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#128] \n\t" + "str.w r10, [r0,#132] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 10 + + "ldr.w r9, [r0,#456] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#460] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#136] \n\t" + "str.w r10, [r0,#140] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 11 + + "ldr.w r9, [r0,#464] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#468] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#144] \n\t" + "str.w r10, [r0,#148] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 12 + + "ldr.w r9, [r0,#472] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#476] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#152] \n\t" + "str.w r10, [r0,#156] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 13 + + "ldr.w r9, [r0,#480] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#484] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#160] \n\t" + "str.w r10, [r0,#164] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 14 + + "ldr.w r9, [r0,#488] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#492] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#168] \n\t" + "str.w r10, [r0,#172] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 15 + + "ldr.w r9, [r0,#496] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#500] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#176] \n\t" + "str.w r10, [r0,#180] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 16 + + "ldr.w r9, [r0,#504] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#508] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#184] \n\t" + "str.w r10, [r0,#188] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 17 + + "ldr.w r9, [r0,#512] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#516] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#192] \n\t" + "str.w r10, [r0,#196] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 18 + + "ldr.w r9, [r0,#520] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#524] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#200] \n\t" + "str.w r10, [r0,#204] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 19 + + "ldr.w r9, [r0,#528] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#532] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#208] \n\t" + "str.w r10, [r0,#212] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 20 + + "ldr.w r9, [r0,#536] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#540] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#216] \n\t" + "str.w r10, [r0,#220] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 21 + + "ldr.w r9, [r0,#544] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#548] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#224] \n\t" + "str.w r10, [r0,#228] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 22 + + "ldr.w r9, [r0,#552] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#556] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#232] \n\t" + "str.w r10, [r0,#236] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 23 + + "ldr.w r9, [r0,#560] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#564] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#240] \n\t" + "str.w r10, [r0,#244] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 24 + + "ldr.w r9, [r0,#568] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#572] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#248] \n\t" + "str.w r10, [r0,#252] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 25 + + "ldr.w r9, [r0,#576] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#580] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#256] \n\t" + "str.w r10, [r0,#260] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 26 + + "ldr.w r9, [r0,#584] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#588] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#264] \n\t" + "str.w r10, [r0,#268] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 27 + + "ldr.w r9, [r0,#592] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#596] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#272] \n\t" + "str.w r10, [r0,#276] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 28 + + "ldr.w r9, [r0,#600] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#604] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#280] \n\t" + "str.w r10, [r0,#284] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 29 + + "ldr.w r9, [r0,#608] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#612] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#288] \n\t" + "str.w r10, [r0,#292] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 30 + + "ldr.w r9, [r0,#616] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#620] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#296] \n\t" + "str.w r10, [r0,#300] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 31 + + "ldr.w r9, [r0,#624] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#628] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#304] \n\t" + "str.w r10, [r0,#308] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 32 + + "ldr.w r9, [r0,#632] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#636] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#312] \n\t" + "str.w r10, [r0,#316] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 33 + + "ldr.w r9, [r0,#640] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#644] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#320] \n\t" + "str.w r10, [r0,#324] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 34 + + "ldr.w r9, [r0,#648] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#652] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#328] \n\t" + "str.w r10, [r0,#332] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 35 + + "ldr.w r9, [r0,#656] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#660] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#336] \n\t" + "str.w r10, [r0,#340] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 36 + + "ldr.w r9, [r0,#664] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#668] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#344] \n\t" + "str.w r10, [r0,#348] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 37 + + "ldr.w r9, [r0,#672] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#676] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#352] \n\t" + "str.w r10, [r0,#356] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 38 + + "ldr.w r9, [r0,#680] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#684] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#360] \n\t" + "str.w r10, [r0,#364] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 39 + + "ldr.w r9, [r0,#688] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#692] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#368] \n\t" + "str.w r10, [r0,#372] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 40 + + "ldr.w r9, [r0,#696] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#700] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#376] \n\t" + "str.w r10, [r0,#380] \n\t" + + // permutation + + // not need to calculate (not used) + + "ldmia.w sp!, {r4-r10} \n\t" + : + : [roundKeys] "r" (roundKeys) + : "cc"); +} diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule3.c b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule3.c new file mode 100644 index 0000000..0b8f83b --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_key_schedule3.c @@ -0,0 +1,2201 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * AC(c0 c1) ^ TK3 -> store + * ART(TK3) + * + * number of rounds : 40 + */ + +__attribute__((aligned(4))) +void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) +{ + // r0 : points to roundKeys(& masterKey) + // r1 : points to RC + // r2-r5 : key state + // r6-r7 : temp use + // r8 : constant(0x7f7f7f7f) + // r9 : constant(0x80808080) + asm volatile( + "stmdb sp!, {r4-r9} \n\t" + "ldr.w r2, [r0,#32] \n\t" // load master key + "ldr.w r3, [r0,#36] \n\t" // load master key + "ldr.w r4, [r0,#40] \n\t" // load master key + "ldr.w r5, [r0,#44] \n\t" // load master key + "mov.w r8, #0x7f7f7f7f \n\t" + "mov.w r9, #0x80808080 \n\t" + + // round 1 + + // AC(c0 c1) + "ldrb.w r6, [r1,#0] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#384] \n\t" + "str.w r7, [r0,#388] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 2 + + // AC(c0 c1) + "ldrb.w r6, [r1,#1] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#392] \n\t" + "str.w r7, [r0,#396] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 3 + + // AC(c0 c1) + "ldrb.w r6, [r1,#2] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#400] \n\t" + "str.w r7, [r0,#404] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 4 + + // AC(c0 c1) + "ldrb.w r6, [r1,#3] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#408] \n\t" + "str.w r7, [r0,#412] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 5 + + // AC(c0 c1) + "ldrb.w r6, [r1,#4] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#416] \n\t" + "str.w r7, [r0,#420] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 6 + + // AC(c0 c1) + "ldrb.w r6, [r1,#5] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#424] \n\t" + "str.w r7, [r0,#428] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 7 + + // AC(c0 c1) + "ldrb.w r6, [r1,#6] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#432] \n\t" + "str.w r7, [r0,#436] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 8 + + // AC(c0 c1) + "ldrb.w r6, [r1,#7] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#440] \n\t" + "str.w r7, [r0,#444] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 9 + + // AC(c0 c1) + "ldrb.w r6, [r1,#8] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#448] \n\t" + "str.w r7, [r0,#452] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 10 + + // AC(c0 c1) + "ldrb.w r6, [r1,#9] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#456] \n\t" + "str.w r7, [r0,#460] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 11 + + // AC(c0 c1) + "ldrb.w r6, [r1,#10] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#464] \n\t" + "str.w r7, [r0,#468] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 12 + + // AC(c0 c1) + "ldrb.w r6, [r1,#11] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#472] \n\t" + "str.w r7, [r0,#476] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 13 + + // AC(c0 c1) + "ldrb.w r6, [r1,#12] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#480] \n\t" + "str.w r7, [r0,#484] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 14 + + // AC(c0 c1) + "ldrb.w r6, [r1,#13] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#488] \n\t" + "str.w r7, [r0,#492] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 15 + + // AC(c0 c1) + "ldrb.w r6, [r1,#14] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#496] \n\t" + "str.w r7, [r0,#500] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 16 + + // AC(c0 c1) + "ldrb.w r6, [r1,#15] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#504] \n\t" + "str.w r7, [r0,#508] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 17 + + // AC(c0 c1) + "ldrb.w r6, [r1,#16] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#512] \n\t" + "str.w r7, [r0,#516] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 18 + + // AC(c0 c1) + "ldrb.w r6, [r1,#17] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#520] \n\t" + "str.w r7, [r0,#524] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 19 + + // AC(c0 c1) + "ldrb.w r6, [r1,#18] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#528] \n\t" + "str.w r7, [r0,#532] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 20 + + // AC(c0 c1) + "ldrb.w r6, [r1,#19] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#536] \n\t" + "str.w r7, [r0,#540] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 21 + + // AC(c0 c1) + "ldrb.w r6, [r1,#20] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#544] \n\t" + "str.w r7, [r0,#548] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 22 + + // AC(c0 c1) + "ldrb.w r6, [r1,#21] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#552] \n\t" + "str.w r7, [r0,#556] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 23 + + // AC(c0 c1) + "ldrb.w r6, [r1,#22] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#560] \n\t" + "str.w r7, [r0,#564] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 24 + + // AC(c0 c1) + "ldrb.w r6, [r1,#23] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#568] \n\t" + "str.w r7, [r0,#572] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 25 + + // AC(c0 c1) + "ldrb.w r6, [r1,#24] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#576] \n\t" + "str.w r7, [r0,#580] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 26 + + // AC(c0 c1) + "ldrb.w r6, [r1,#25] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#584] \n\t" + "str.w r7, [r0,#588] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 27 + + // AC(c0 c1) + "ldrb.w r6, [r1,#26] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#592] \n\t" + "str.w r7, [r0,#596] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 28 + + // AC(c0 c1) + "ldrb.w r6, [r1,#27] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#600] \n\t" + "str.w r7, [r0,#604] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 29 + + // AC(c0 c1) + "ldrb.w r6, [r1,#28] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#608] \n\t" + "str.w r7, [r0,#612] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 30 + + // AC(c0 c1) + "ldrb.w r6, [r1,#29] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#616] \n\t" + "str.w r7, [r0,#620] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 31 + + // AC(c0 c1) + "ldrb.w r6, [r1,#30] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#624] \n\t" + "str.w r7, [r0,#628] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 32 + + // AC(c0 c1) + "ldrb.w r6, [r1,#31] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#632] \n\t" + "str.w r7, [r0,#636] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 33 + + // AC(c0 c1) + "ldrb.w r6, [r1,#32] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#640] \n\t" + "str.w r7, [r0,#644] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 34 + + // AC(c0 c1) + "ldrb.w r6, [r1,#33] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#648] \n\t" + "str.w r7, [r0,#652] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 35 + + // AC(c0 c1) + "ldrb.w r6, [r1,#34] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#656] \n\t" + "str.w r7, [r0,#660] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 36 + + // AC(c0 c1) + "ldrb.w r6, [r1,#35] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#664] \n\t" + "str.w r7, [r0,#668] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 37 + + // AC(c0 c1) + "ldrb.w r6, [r1,#36] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#672] \n\t" + "str.w r7, [r0,#676] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 38 + + // AC(c0 c1) + "ldrb.w r6, [r1,#37] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#680] \n\t" + "str.w r7, [r0,#684] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 39 + + // AC(c0 c1) + "ldrb.w r6, [r1,#38] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#688] \n\t" + "str.w r7, [r0,#692] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 40 + + // AC(c0 c1) + "ldrb.w r6, [r1,#39] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#696] \n\t" + "str.w r7, [r0,#700] \n\t" + + // permutation + + // not need to calculate (not used) + + "ldmia.w sp!, {r4-r9} \n\t" + : + : [roundKeys] "r" (roundKeys), [pRC] "r" (pRC) + : "cc"); +} diff --git a/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_main.c b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_main.c new file mode 100644 index 0000000..e266958 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1+v13/armsrc_NEC/skinny_main.c @@ -0,0 +1,3462 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * ART(TK1) -> store + * load AC(c0 c1) ^ TK3 ^ TK2 + * load TK1 + * calc AC(c0 c1) ^ TK3 ^ TK2 ^ TK1 -> use at (AC->ART) + * SC->SR->(AC->ART)->MC + * + * number of rounds : 40 + */ + +#include "skinny.h" + +/* + * S-BOX + */ +unsigned char SBOX[512] += { + // Original + 0x65, 0x4c, 0x6a, 0x42, 0x4b, 0x63, 0x43, 0x6b, 0x55, 0x75, 0x5a, 0x7a, 0x53, 0x73, 0x5b, 0x7b, + 0x35, 0x8c, 0x3a, 0x81, 0x89, 0x33, 0x80, 0x3b, 0x95, 0x25, 0x98, 0x2a, 0x90, 0x23, 0x99, 0x2b, + 0xe5, 0xcc, 0xe8, 0xc1, 0xc9, 0xe0, 0xc0, 0xe9, 0xd5, 0xf5, 0xd8, 0xf8, 0xd0, 0xf0, 0xd9, 0xf9, + 0xa5, 0x1c, 0xa8, 0x12, 0x1b, 0xa0, 0x13, 0xa9, 0x05, 0xb5, 0x0a, 0xb8, 0x03, 0xb0, 0x0b, 0xb9, + 0x32, 0x88, 0x3c, 0x85, 0x8d, 0x34, 0x84, 0x3d, 0x91, 0x22, 0x9c, 0x2c, 0x94, 0x24, 0x9d, 0x2d, + 0x62, 0x4a, 0x6c, 0x45, 0x4d, 0x64, 0x44, 0x6d, 0x52, 0x72, 0x5c, 0x7c, 0x54, 0x74, 0x5d, 0x7d, + 0xa1, 0x1a, 0xac, 0x15, 0x1d, 0xa4, 0x14, 0xad, 0x02, 0xb1, 0x0c, 0xbc, 0x04, 0xb4, 0x0d, 0xbd, + 0xe1, 0xc8, 0xec, 0xc5, 0xcd, 0xe4, 0xc4, 0xed, 0xd1, 0xf1, 0xdc, 0xfc, 0xd4, 0xf4, 0xdd, 0xfd, + 0x36, 0x8e, 0x38, 0x82, 0x8b, 0x30, 0x83, 0x39, 0x96, 0x26, 0x9a, 0x28, 0x93, 0x20, 0x9b, 0x29, + 0x66, 0x4e, 0x68, 0x41, 0x49, 0x60, 0x40, 0x69, 0x56, 0x76, 0x58, 0x78, 0x50, 0x70, 0x59, 0x79, + 0xa6, 0x1e, 0xaa, 0x11, 0x19, 0xa3, 0x10, 0xab, 0x06, 0xb6, 0x08, 0xba, 0x00, 0xb3, 0x09, 0xbb, + 0xe6, 0xce, 0xea, 0xc2, 0xcb, 0xe3, 0xc3, 0xeb, 0xd6, 0xf6, 0xda, 0xfa, 0xd3, 0xf3, 0xdb, 0xfb, + 0x31, 0x8a, 0x3e, 0x86, 0x8f, 0x37, 0x87, 0x3f, 0x92, 0x21, 0x9e, 0x2e, 0x97, 0x27, 0x9f, 0x2f, + 0x61, 0x48, 0x6e, 0x46, 0x4f, 0x67, 0x47, 0x6f, 0x51, 0x71, 0x5e, 0x7e, 0x57, 0x77, 0x5f, 0x7f, + 0xa2, 0x18, 0xae, 0x16, 0x1f, 0xa7, 0x17, 0xaf, 0x01, 0xb2, 0x0e, 0xbe, 0x07, 0xb7, 0x0f, 0xbf, + 0xe2, 0xca, 0xee, 0xc6, 0xcf, 0xe7, 0xc7, 0xef, 0xd2, 0xf2, 0xde, 0xfe, 0xd7, 0xf7, 0xdf, 0xff, + + // Original ^ c2(0x02) + 0x67, 0x4e, 0x68, 0x40, 0x49, 0x61, 0x41, 0x69, 0x57, 0x77, 0x58, 0x78, 0x51, 0x71, 0x59, 0x79, + 0x37, 0x8e, 0x38, 0x83, 0x8b, 0x31, 0x82, 0x39, 0x97, 0x27, 0x9a, 0x28, 0x92, 0x21, 0x9b, 0x29, + 0xe7, 0xce, 0xea, 0xc3, 0xcb, 0xe2, 0xc2, 0xeb, 0xd7, 0xf7, 0xda, 0xfa, 0xd2, 0xf2, 0xdb, 0xfb, + 0xa7, 0x1e, 0xaa, 0x10, 0x19, 0xa2, 0x11, 0xab, 0x07, 0xb7, 0x08, 0xba, 0x01, 0xb2, 0x09, 0xbb, + 0x30, 0x8a, 0x3e, 0x87, 0x8f, 0x36, 0x86, 0x3f, 0x93, 0x20, 0x9e, 0x2e, 0x96, 0x26, 0x9f, 0x2f, + 0x60, 0x48, 0x6e, 0x47, 0x4f, 0x66, 0x46, 0x6f, 0x50, 0x70, 0x5e, 0x7e, 0x56, 0x76, 0x5f, 0x7f, + 0xa3, 0x18, 0xae, 0x17, 0x1f, 0xa6, 0x16, 0xaf, 0x00, 0xb3, 0x0e, 0xbe, 0x06, 0xb6, 0x0f, 0xbf, + 0xe3, 0xca, 0xee, 0xc7, 0xcf, 0xe6, 0xc6, 0xef, 0xd3, 0xf3, 0xde, 0xfe, 0xd6, 0xf6, 0xdf, 0xff, + 0x34, 0x8c, 0x3a, 0x80, 0x89, 0x32, 0x81, 0x3b, 0x94, 0x24, 0x98, 0x2a, 0x91, 0x22, 0x99, 0x2b, + 0x64, 0x4c, 0x6a, 0x43, 0x4b, 0x62, 0x42, 0x6b, 0x54, 0x74, 0x5a, 0x7a, 0x52, 0x72, 0x5b, 0x7b, + 0xa4, 0x1c, 0xa8, 0x13, 0x1b, 0xa1, 0x12, 0xa9, 0x04, 0xb4, 0x0a, 0xb8, 0x02, 0xb1, 0x0b, 0xb9, + 0xe4, 0xcc, 0xe8, 0xc0, 0xc9, 0xe1, 0xc1, 0xe9, 0xd4, 0xf4, 0xd8, 0xf8, 0xd1, 0xf1, 0xd9, 0xf9, + 0x33, 0x88, 0x3c, 0x84, 0x8d, 0x35, 0x85, 0x3d, 0x90, 0x23, 0x9c, 0x2c, 0x95, 0x25, 0x9d, 0x2d, + 0x63, 0x4a, 0x6c, 0x44, 0x4d, 0x65, 0x45, 0x6d, 0x53, 0x73, 0x5c, 0x7c, 0x55, 0x75, 0x5d, 0x7d, + 0xa0, 0x1a, 0xac, 0x14, 0x1d, 0xa5, 0x15, 0xad, 0x03, 0xb0, 0x0c, 0xbc, 0x05, 0xb5, 0x0d, 0xbd, + 0xe0, 0xc8, 0xec, 0xc4, 0xcd, 0xe5, 0xc5, 0xed, 0xd0, 0xf0, 0xdc, 0xfc, 0xd5, 0xf5, 0xdd, 0xfd, +}; + +/* + * Round Constants + */ +unsigned char RC[56] += { + 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3E, 0x3D, 0x3B, + 0x37, 0x2F, 0x1E, 0x3C, 0x39, 0x33, 0x27, 0x0E, + 0x1D, 0x3A, 0x35, 0x2B, 0x16, 0x2C, 0x18, 0x30, + 0x21, 0x02, 0x05, 0x0B, 0x17, 0x2E, 0x1C, 0x38, + 0x31, 0x23, 0x06, 0x0D, 0x1B, 0x36, 0x2D, 0x1A, + 0x34, 0x29, 0x12, 0x24, 0x08, 0x11, 0x22, 0x04, + 0x09, 0x13, 0x26, 0x0c, 0x19, 0x32, 0x25, 0x0a,}; + +extern void Encrypt(unsigned char *block, unsigned char *roundKeys, unsigned char *pSBOX) __attribute__((noinline)); +extern void RunEncryptionKeyScheduleTK2(unsigned char *roundKeys) __attribute__((noinline)); +extern void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) __attribute__((noinline)); + +void skinny_128_384_enc123_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[16]) = *((unsigned int *)&T[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[20]) = *((unsigned int *)&T[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[24]) = *((unsigned int *)&T[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[28]) = *((unsigned int *)&T[12]); + *((unsigned int *)&pskinny_ctrl->roundKeys[32]) = *((unsigned int *)&K[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[36]) = *((unsigned int *)&K[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[40]) = *((unsigned int *)&K[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[44]) = *((unsigned int *)&K[12]); + + RunEncryptionKeyScheduleTK3(pskinny_ctrl->roundKeys, RC); + RunEncryptionKeyScheduleTK2(pskinny_ctrl->roundKeys); + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); + + pskinny_ctrl->func_skinny_128_384_enc = skinny_128_384_enc12_12; +} + +void skinny_128_384_enc12_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + (void)K; + + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[16]) = *((unsigned int *)&T[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[20]) = *((unsigned int *)&T[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[24]) = *((unsigned int *)&T[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[28]) = *((unsigned int *)&T[12]); + + RunEncryptionKeyScheduleTK2(pskinny_ctrl->roundKeys); + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); +} + +extern void skinny_128_384_enc1_1 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + (void)T; + (void)K; + + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); +} + +__attribute__((aligned(4))) +void Encrypt(unsigned char *block, unsigned char *roundKeys, unsigned char *pSBOX) +{ + // r0 : ponits to plaintext + // r1 : points to roundKeys(& masterKey) + // r2 : points to SBOX + // r3-r6 : cipher state + // r7-r12: temp use + // r14 : temp use + asm volatile( + "stmdb sp!, {r4-r12,r14} \n\t" + "stmdb.w sp!, {r0} \n\t" // push store pointer + +// ART(TK1) + + "ldm.w r1, {r3-r4} \n\t" // load master key + + // round 1-2 + +// // round key store(do not need) +// "str.w r3, [r1,#0] \n\t" +// "str.w r4, [r1,#4] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 3-4 + + // round key store + "str.w r5, [r1,#8] \n\t" + "str.w r6, [r1,#12] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 5-6 + + // round key store + "str.w r3, [r1,#16] \n\t" + "str.w r4, [r1,#20] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 7-8 + + // round key store + "str.w r5, [r1,#24] \n\t" + "str.w r6, [r1,#28] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 9-10 + + // round key store + "str.w r3, [r1,#32] \n\t" + "str.w r4, [r1,#36] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 11-12 + + // round key store + "str.w r5, [r1,#40] \n\t" + "str.w r6, [r1,#44] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 13-14 + + // round key store + "str.w r3, [r1,#48] \n\t" + "str.w r4, [r1,#52] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 15-16 + + // round key store + "str.w r5, [r1,#56] \n\t" + "str.w r6, [r1,#60] \n\t" + + // premutation + + // not need to calculate (not used) + +// SC->(AC->ART)->SR->MC + + "add.w r14, r2, #256 \n\t" // point to SBOX ^ c2(0x02) + + "ldm.w r0, {r3-r6} \n\t" // load plaintext + // r0 now free to overwrite + + // round 1 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#64] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#68] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 2 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#72] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#76] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 3 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#80] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#84] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 4 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#88] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#92] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 5 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#96] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#100] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 6 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#104] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#108] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 7 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#112] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#116] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 8 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#120] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#124] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 9 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#32] \n\t" // load TK1 + "ldr.w r10, [r1,#36] \n\t" // load TK1 + "ldr.w r11, [r1,#128] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#132] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 10 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#136] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#140] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 11 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#40] \n\t" // load TK1 + "ldr.w r10, [r1,#44] \n\t" // load TK1 + "ldr.w r11, [r1,#144] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#148] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 12 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#152] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#156] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 13 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#48] \n\t" // load TK1 + "ldr.w r10, [r1,#52] \n\t" // load TK1 + "ldr.w r11, [r1,#160] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#164] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 14 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#168] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#172] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 15 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#56] \n\t" // load TK1 + "ldr.w r10, [r1,#60] \n\t" // load TK1 + "ldr.w r11, [r1,#176] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#180] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 16 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#184] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#188] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 17 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#192] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#196] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 18 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#200] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#204] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 19 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#208] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#212] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 20 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#216] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#220] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 21 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#224] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#228] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 22 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#232] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#236] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 23 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#240] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#244] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 24 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#248] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#252] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 25 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#32] \n\t" // load TK1 + "ldr.w r10, [r1,#36] \n\t" // load TK1 + "ldr.w r11, [r1,#256] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#260] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 26 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#264] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#268] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 27 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#40] \n\t" // load TK1 + "ldr.w r10, [r1,#44] \n\t" // load TK1 + "ldr.w r11, [r1,#272] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#276] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 28 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#280] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#284] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 29 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#48] \n\t" // load TK1 + "ldr.w r10, [r1,#52] \n\t" // load TK1 + "ldr.w r11, [r1,#288] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#292] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 30 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#296] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#300] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 31 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#56] \n\t" // load TK1 + "ldr.w r10, [r1,#60] \n\t" // load TK1 + "ldr.w r11, [r1,#304] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#308] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 32 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#312] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#316] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 33 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#320] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#324] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 34 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#328] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#332] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 35 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#336] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#340] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 36 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#344] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#348] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 37 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#352] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#356] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 38 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#360] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#364] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 39 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#368] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#372] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 40 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#376] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#380] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + + "ldmia.w sp!, {r0} \n\t" // pop store pointer + // r0 reload + + "str.w r3, [r0,#0] \n\t" // store ciphertext + "str.w r4, [r0,#4] \n\t" // store ciphertext + "str.w r5, [r0,#8] \n\t" // store ciphertext + "str.w r6, [r0,#12] \n\t" // store ciphertext + + "ldmia.w sp!, {r4-r12,r14} \n\t" + : + : [block] "r" (block), [roundKeys] "r" (roundKeys), [pSBOX] "" (pSBOX) + : "cc"); +} + diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/api.h b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/api.h new file mode 100644 index 0000000..a4aa567 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/api.h @@ -0,0 +1,5 @@ +#define CRYPTO_KEYBYTES 16 +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 16 +#define CRYPTO_ABYTES 16 +#define CRYPTO_NOOVERLAP 1 diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/crypto_aead.h b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/crypto_aead.h new file mode 100644 index 0000000..cfc09d6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/crypto_aead.h @@ -0,0 +1,11 @@ +int crypto_aead_encrypt(unsigned char *c, unsigned long long *clen, + const unsigned char *m, unsigned long long mlen, + const unsigned char *ad, unsigned long long adlen, + const unsigned char *nsec, const unsigned char *npub, + const unsigned char *k); + +int crypto_aead_decrypt(unsigned char *m, unsigned long long *outputmlen, + unsigned char *nsec, + const unsigned char *c, unsigned long long clen, + const unsigned char *ad, unsigned long long adlen, + const unsigned char *npub, const unsigned char *k); diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/encrypt.c b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/encrypt.c new file mode 100644 index 0000000..5a7d0e0 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/encrypt.c @@ -0,0 +1,541 @@ +/* + * Date: 29 November 2018 + * Contact: Thomas Peyrin - thomas.peyrin@gmail.com + * Mustafa Khairallah - mustafam001@e.ntu.edu.sg + */ + +#include "crypto_aead.h" +#include "api.h" +#include "skinny.h" +#include +#include + +void pad (const unsigned char* m, unsigned char* mp, int l, int len8) { + int i; + + for (i = 0; i < l; i++) { + if (i < len8) { + mp[i] = m[i]; + } + else if (i == l - 1) { + mp[i] = (len8 & 0x0f); + } + else { + mp[i] = 0x00; + } + } + +} + +void g8A (unsigned char* s, unsigned char* c) { + unsigned int tmps[4]; + unsigned int tmpc[4]; + + tmps[0] = *((unsigned int *)&s[0]); + tmps[1] = *((unsigned int *)&s[4]); + tmps[2] = *((unsigned int *)&s[8]); + tmps[3] = *((unsigned int *)&s[12]); + + // c[i] = (s[i] >> 1) ^ (s[i] & 0x80) ^ ((s[i] & 0x01) << 7); + // + // (s[i] >> 1) -> ((s[i]>>1)&0x7f) + // (s[i] & 0x80) -> (s[i])&0x80) not changed + // ((s[i] & 0x01) << 7) -> ((s[i]<<7)&0x80) + + // use word access because of speeding up + tmpc[0] = ((tmps[0]>>1) & 0x7f7f7f7f) ^ (tmps[0] & 0x80808080) ^ ((tmps[0]<<7) & 0x80808080); + tmpc[1] = ((tmps[1]>>1) & 0x7f7f7f7f) ^ (tmps[1] & 0x80808080) ^ ((tmps[1]<<7) & 0x80808080); + tmpc[2] = ((tmps[2]>>1) & 0x7f7f7f7f) ^ (tmps[2] & 0x80808080) ^ ((tmps[2]<<7) & 0x80808080); + tmpc[3] = ((tmps[3]>>1) & 0x7f7f7f7f) ^ (tmps[3] & 0x80808080) ^ ((tmps[3]<<7) & 0x80808080); + + *((unsigned int *)&c[0]) = tmpc[0]; + *((unsigned int *)&c[4]) = tmpc[1]; + *((unsigned int *)&c[8]) = tmpc[2]; + *((unsigned int *)&c[12]) = tmpc[3]; +} + +void g8A_for_Tag_Generation (unsigned char* s, unsigned char* c) { + unsigned int tmps[4]; + unsigned int tmpc[4]; + + tmps[0] = *((unsigned int *)&s[0]); + tmps[1] = *((unsigned int *)&s[4]); + tmps[2] = *((unsigned int *)&s[8]); + tmps[3] = *((unsigned int *)&s[12]); + + // c[i] = (s[i] >> 1) ^ (s[i] & 0x80) ^ ((s[i] & 0x01) << 7); + // + // (s[i] >> 1) -> ((s[i]>>1)&0x7f) + // (s[i] & 0x80) -> (s[i])&0x80) not changed + // ((s[i] & 0x01) << 7) -> ((s[i]<<7)&0x80) + + // use word access because of speeding up + tmpc[0] = ((tmps[0]>>1) & 0x7f7f7f7f) ^ (tmps[0] & 0x80808080) ^ ((tmps[0]<<7) & 0x80808080); + tmpc[1] = ((tmps[1]>>1) & 0x7f7f7f7f) ^ (tmps[1] & 0x80808080) ^ ((tmps[1]<<7) & 0x80808080); + tmpc[2] = ((tmps[2]>>1) & 0x7f7f7f7f) ^ (tmps[2] & 0x80808080) ^ ((tmps[2]<<7) & 0x80808080); + tmpc[3] = ((tmps[3]>>1) & 0x7f7f7f7f) ^ (tmps[3] & 0x80808080) ^ ((tmps[3]<<7) & 0x80808080); + + // use byte access because of memory alignment. + // c is not always in word(4 byte) alignment. + c[0] = tmpc[0] &0xFF; + c[1] = (tmpc[0]>>8) &0xFF; + c[2] = (tmpc[0]>>16)&0xFF; + c[3] = (tmpc[0]>>24)&0xFF; + c[4] = tmpc[1] &0xFF; + c[5] = (tmpc[1]>>8) &0xFF; + c[6] = (tmpc[1]>>16)&0xFF; + c[7] = (tmpc[1]>>24)&0xFF; + c[8] = tmpc[2] &0xFF; + c[9] = (tmpc[2]>>8) &0xFF; + c[10] = (tmpc[2]>>16)&0xFF; + c[11] = (tmpc[2]>>24)&0xFF; + c[12] = tmpc[3] &0xFF; + c[13] = (tmpc[3]>>8) &0xFF; + c[14] = (tmpc[3]>>16)&0xFF; + c[15] = (tmpc[3]>>24)&0xFF; +} + +void rho_ad_eqov16 (const unsigned char* m, + unsigned char* s) { + *((unsigned int *)&s[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&m[12]); +} + +void rho_ad_ud16 (const unsigned char* m, + unsigned char* s, + int len8) { + unsigned char mp [16]; + + pad(m,mp,16,len8); + *((unsigned int *)&s[0]) ^= *((unsigned int *)&mp[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&mp[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&mp[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&mp[12]); +} + +void rho_eqov16 (const unsigned char* m, + unsigned char* c, + unsigned char* s) { + g8A(s,c); + + *((unsigned int *)&s[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&m[12]); + + *((unsigned int *)&c[0]) ^= *((unsigned int *)&m[0]); + *((unsigned int *)&c[4]) ^= *((unsigned int *)&m[4]); + *((unsigned int *)&c[8]) ^= *((unsigned int *)&m[8]); + *((unsigned int *)&c[12]) ^= *((unsigned int *)&m[12]); +} + +void rho_ud16 (const unsigned char* m, + unsigned char* c, + unsigned char* s, + int len8, + int ver) { + int i; + unsigned char mp [16]; + + pad(m,mp,ver,len8); + + g8A(s,c); + *((unsigned int *)&s[0]) ^= *((unsigned int *)&mp[0]); + *((unsigned int *)&s[4]) ^= *((unsigned int *)&mp[4]); + *((unsigned int *)&s[8]) ^= *((unsigned int *)&mp[8]); + *((unsigned int *)&s[12]) ^= *((unsigned int *)&mp[12]); + for (i = 0; i < ver; i++) { + if (i < len8) { + c[i] = c[i] ^ mp[i]; + } + else { + c[i] = 0; + } + } +} + +void irho (unsigned char* m, + const unsigned char* c, + unsigned char* s, + int len8, + int ver) { + int i; + unsigned char cp [16]; + + pad(c,cp,ver,len8); + + g8A(s,m); + for (i = 0; i < ver; i++) { + if (i < len8) { + s[i] = s[i] ^ cp[i] ^ m[i]; + } + else { + s[i] = s[i] ^ cp[i]; + } + if (i < len8) { + m[i] = m[i] ^ cp[i]; + } + else { + m[i] = 0; + } + } +} + +void reset_lfsr_gf56 (unsigned char* CNT) { + *((unsigned int *)&CNT[0]) = 0x00000001; + *((unsigned int *)&CNT[4]) = 0x00000000; +} + +void lfsr_gf56 (unsigned char* CNT) { + unsigned int tmpCNT[2]; + unsigned int fb0; + + tmpCNT[0] = *((unsigned int *)&CNT[0]); // CNT3 CNT2 CNT1 CNT0 + tmpCNT[1] = *((unsigned int *)&CNT[4]); // CNT7 CNT6 CNT5 CNT4 + + fb0 = 0; + if ((tmpCNT[1] >> 23)&0x01) { + fb0 = 0x95; + } + + tmpCNT[1] = tmpCNT[1] << 1 | tmpCNT[0] >> 31; + tmpCNT[0] = tmpCNT[0] << 1 ^ fb0; + + *((unsigned int *)&CNT[0]) = tmpCNT[0]; + *((unsigned int *)&CNT[4]) = tmpCNT[1]; +} + +void block_cipher(unsigned char* s, + const unsigned char* k, unsigned char* T, + unsigned char* CNT, + skinny_ctrl* p_skinny_ctrl) { + p_skinny_ctrl->func_skinny_128_384_enc (s,p_skinny_ctrl,CNT,T,k); +} + +void nonce_encryption (const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + skinny_ctrl* p_skinny_ctrl) { + unsigned char T [16]; + + *((unsigned int *)&T[0]) = *((unsigned int *)&N[0]); + *((unsigned int *)&T[4]) = *((unsigned int *)&N[4]); + *((unsigned int *)&T[8]) = *((unsigned int *)&N[8]); + *((unsigned int *)&T[12]) = *((unsigned int *)&N[12]); + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + +} + +void generate_tag (unsigned char** c, unsigned char* s, + int n, unsigned long long* clen) { + g8A_for_Tag_Generation(s, *c); + *c = *c + n; + *c = *c - *clen; +} + +unsigned long long msg_encryption_eqov16 (const unsigned char** M, unsigned char** c, + const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long mlen, + skinny_ctrl* p_skinny_ctrl) { + rho_eqov16(*M, *c, s); + *c = *c + 16; + *M = *M + 16; + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,D,p_skinny_ctrl); + return mlen - 16; +} + +unsigned long long msg_encryption_ud16 (const unsigned char** M, unsigned char** c, + const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long mlen, + skinny_ctrl* p_skinny_ctrl) { + rho_ud16(*M, *c, s, mlen, 16); + *c = *c + mlen; + *M = *M + mlen; + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,D,p_skinny_ctrl); + return 0; +} + +unsigned long long msg_decryption (unsigned char** M, const unsigned char** c, + const unsigned char* N, + unsigned char* CNT, + unsigned char*s, const unsigned char* k, + unsigned char D, + unsigned long long clen, + skinny_ctrl* p_skinny_ctrl) { + int len8; + + if (clen >= 16) { + len8 = 16; + clen = clen - 16; + } + else { + len8 = clen; + clen = 0; + } + irho(*M, *c, s, len8, 16); + *c = *c + len8; + *M = *M + len8; + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,D,p_skinny_ctrl); + return clen; +} + +unsigned long long ad_encryption_eqov32 (const unsigned char** A, unsigned char* s, + const unsigned char* k, unsigned long long adlen, + unsigned char* CNT, + unsigned char D, + skinny_ctrl* p_skinny_ctrl) { + + unsigned char T [16]; + + rho_ad_eqov16(*A, s); + *A = *A + 16; + lfsr_gf56(CNT); + + //pad(*A, T, 16, 16); + *((unsigned int *)&T[0]) = *((unsigned int *)&(*A)[0]); + *((unsigned int *)&T[4]) = *((unsigned int *)&(*A)[4]); + *((unsigned int *)&T[8]) = *((unsigned int *)&(*A)[8]); + *((unsigned int *)&T[12]) = *((unsigned int *)&(*A)[12]); + *A = *A + 16; + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + lfsr_gf56(CNT); + + return adlen - 32; +} + +unsigned long long ad_encryption_ov16 (const unsigned char** A, unsigned char* s, + const unsigned char* k, unsigned long long adlen, + unsigned char* CNT, + unsigned char D, + skinny_ctrl* p_skinny_ctrl) { + + unsigned char T [16]; + + adlen = adlen - 16; + rho_ad_eqov16(*A, s); + *A = *A + 16; + lfsr_gf56(CNT); + + pad(*A, T, 16, adlen); + *A = *A + adlen; + CNT[7] = D; + block_cipher(s,k,T,CNT,p_skinny_ctrl); + lfsr_gf56(CNT); + + return 0; +} + +unsigned long long ad_encryption_eq16 (const unsigned char** A, unsigned char* s, + unsigned char* CNT) { + + rho_ad_eqov16(*A, s); + *A = *A + 16; + lfsr_gf56(CNT); + + return 0; +} + +unsigned long long ad_encryption_ud16 (const unsigned char** A, unsigned char* s, + unsigned long long adlen, + unsigned char* CNT) { + + rho_ad_ud16(*A, s, adlen); + *A = *A + adlen; + lfsr_gf56(CNT); + + return 0; +} + +int crypto_aead_encrypt ( + unsigned char* c, unsigned long long* clen, + const unsigned char* m, unsigned long long mlen, + const unsigned char* ad, unsigned long long adlen, + const unsigned char* nsec, + const unsigned char* npub, + const unsigned char* k + ) +{ + unsigned char s[16]; + // size 7 -> 8 for word access + unsigned char CNT[8]; + const unsigned char* A; + const unsigned char* M; + const unsigned char* N; + + skinny_ctrl l_skinny_ctrl; + + (void) nsec; + A = ad; + M = m; + N = npub; + + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc123_12; + + *((unsigned int *)&s[0]) = 0x00000000; + *((unsigned int *)&s[4]) = 0x00000000; + *((unsigned int *)&s[8]) = 0x00000000; + *((unsigned int *)&s[12]) = 0x00000000; + reset_lfsr_gf56(CNT); + + if (adlen == 0) { // AD is an empty string + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else while (adlen > 0) { + if (adlen < 16) { // The last block of AD is odd and incomplete + adlen = ad_encryption_ud16(&A,s,adlen,CNT); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else if (adlen == 16) { // The last block of AD is odd and complete + adlen = ad_encryption_eq16(&A,s,CNT); + nonce_encryption(N,CNT,s,k,0x18,&l_skinny_ctrl); + } + else if (adlen < (32)) { // The last block of AD is even and incomplete + adlen = ad_encryption_ov16(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else if (adlen == (32)) { // The last block of AD is even and complete + adlen = ad_encryption_eqov32(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + nonce_encryption(N,CNT,s,k,0x18,&l_skinny_ctrl); + } + else { // A normal full pair of blocks of AD + adlen = ad_encryption_eqov32(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + } + } + + // because, nonce_encryption is called at the last block of AD encryption + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc1_1; + + reset_lfsr_gf56(CNT); + + *clen = mlen + 16; + + if (mlen == 0) { // M is an empty string + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,0x15,&l_skinny_ctrl); + } + else while (mlen > 0) { + if (mlen < 16) { // The last block of M is incomplete + mlen = msg_encryption_ud16(&M,&c,N,CNT,s,k,0x15,mlen,&l_skinny_ctrl); + } + else if (mlen == 16) { // The last block of M is complete + mlen = msg_encryption_eqov16(&M,&c,N,CNT,s,k,0x14,mlen,&l_skinny_ctrl); + } + else { // A normal full message block + mlen = msg_encryption_eqov16(&M,&c,N,CNT,s,k,0x04,mlen,&l_skinny_ctrl); + } + } + + // Tag generation + generate_tag(&c,s,16,clen); + + return 0; +} + +int crypto_aead_decrypt( +unsigned char *m,unsigned long long *mlen, +unsigned char *nsec, +const unsigned char *c,unsigned long long clen, +const unsigned char *ad,unsigned long long adlen, +const unsigned char *npub, +const unsigned char *k +) +{ + + unsigned char s[16]; + unsigned char T[16]; + // size 7 -> 8 for word access + unsigned char CNT[8]; + const unsigned char* A; + unsigned char* M; + const unsigned char* N; + unsigned int i; + + skinny_ctrl l_skinny_ctrl; + + (void) nsec; + A = ad; + M = m; + N = npub; + + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc123_12; + + for (i = 0; i < 16; i++) { + s[i] = 0; + } + reset_lfsr_gf56(CNT); + + if (adlen == 0) { // AD is an empty string + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else while (adlen > 0) { + if (adlen < 16) { // The last block of AD is odd and incomplete + adlen = ad_encryption_ud16(&A,s,adlen,CNT); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else if (adlen == 16) { // The last block of AD is odd and complete + adlen = ad_encryption_eq16(&A,s,CNT); + nonce_encryption(N,CNT,s,k,0x18,&l_skinny_ctrl); + } + else if (adlen < (32)) { // The last block of AD is even and incomplete + adlen = ad_encryption_ov16(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + nonce_encryption(N,CNT,s,k,0x1a,&l_skinny_ctrl); + } + else if (adlen == (32)) { // The last block of AD is even and complete + adlen = ad_encryption_eqov32(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + nonce_encryption(N,CNT,s,k,0x18,&l_skinny_ctrl); + } + else { // A normal full pair of blocks of AD + adlen = ad_encryption_eqov32(&A,s,k,adlen,CNT,0x08,&l_skinny_ctrl); + } + } + + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc1_1; + reset_lfsr_gf56(CNT); + + clen = clen - 16; + *mlen = clen; + + if (clen == 0) { // C is an empty string + lfsr_gf56(CNT); + nonce_encryption(N,CNT,s,k,0x15,&l_skinny_ctrl); + } + else while (clen > 0) { + if (clen < 16) { // The last block of C is incomplete + clen = msg_decryption(&M,&c,N,CNT,s,k,0x15,clen,&l_skinny_ctrl); + } + else if (clen == 16) { // The last block of C is complete + clen = msg_decryption(&M,&c,N,CNT,s,k,0x14,clen,&l_skinny_ctrl); + } + else { // A normal full message block + clen = msg_decryption(&M,&c,N,CNT,s,k,0x04,clen,&l_skinny_ctrl); + } + } + + // Tag generation + g8A_for_Tag_Generation(s, T); + for (i = 0; i < 16; i++) { + if (T[i] != (*(c+i))) { + return -1; + } + } + + return 0; +} + + diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny.h b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny.h new file mode 100644 index 0000000..2da62ae --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny.h @@ -0,0 +1,8 @@ +typedef struct ___skinny_ctrl { + unsigned char roundKeys[704]; // number of round : 40 + void (*func_skinny_128_384_enc)(unsigned char*, struct ___skinny_ctrl*, unsigned char* CNT, unsigned char* T, const unsigned char* K); +} skinny_ctrl; + +extern void skinny_128_384_enc123_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); +extern void skinny_128_384_enc12_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); +extern void skinny_128_384_enc1_1 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K); diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule2.c b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule2.c new file mode 100644 index 0000000..1315e83 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule2.c @@ -0,0 +1,2163 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * load * AC(c0 c1) ^ TK3 + * calc AC(c0 c1) ^ TK2 -> store + * ART(TK2) + * + * number of rounds : 40 + */ + +__attribute__((aligned(4))) +void RunEncryptionKeyScheduleTK2(unsigned char *roundKeys) +{ + // r0 : points to roundKeys(& masterKey) + // r1-r4 : key state + // r5-r6 : temp use + // r7 : constant(0xfefefefe) + // r8 : constant(0x01010101) + // r9 : temp use + // r10 : temp use + asm volatile( + "stmdb sp!, {r4-r10} \n\t" + "ldr.w r1, [r0,#16] \n\t" // load master key + "ldr.w r2, [r0,#20] \n\t" // load master key + "ldr.w r3, [r0,#24] \n\t" // load master key + "ldr.w r4, [r0,#28] \n\t" // load master key + "mov.w r7, #0xfefefefe \n\t" + "mov.w r8, #0x01010101 \n\t" + + // round 1 + + "ldr.w r9, [r0,#384] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#388] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#64] \n\t" + "str.w r10, [r0,#68] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 2 + + "ldr.w r9, [r0,#392] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#396] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#72] \n\t" + "str.w r10, [r0,#76] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 3 + + "ldr.w r9, [r0,#400] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#404] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#80] \n\t" + "str.w r10, [r0,#84] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 4 + + "ldr.w r9, [r0,#408] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#412] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#88] \n\t" + "str.w r10, [r0,#92] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 5 + + "ldr.w r9, [r0,#416] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#420] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#96] \n\t" + "str.w r10, [r0,#100] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 6 + + "ldr.w r9, [r0,#424] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#428] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#104] \n\t" + "str.w r10, [r0,#108] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 7 + + "ldr.w r9, [r0,#432] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#436] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#112] \n\t" + "str.w r10, [r0,#116] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 8 + + "ldr.w r9, [r0,#440] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#444] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#120] \n\t" + "str.w r10, [r0,#124] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 9 + + "ldr.w r9, [r0,#448] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#452] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#128] \n\t" + "str.w r10, [r0,#132] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 10 + + "ldr.w r9, [r0,#456] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#460] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#136] \n\t" + "str.w r10, [r0,#140] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 11 + + "ldr.w r9, [r0,#464] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#468] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#144] \n\t" + "str.w r10, [r0,#148] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 12 + + "ldr.w r9, [r0,#472] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#476] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#152] \n\t" + "str.w r10, [r0,#156] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 13 + + "ldr.w r9, [r0,#480] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#484] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#160] \n\t" + "str.w r10, [r0,#164] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 14 + + "ldr.w r9, [r0,#488] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#492] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#168] \n\t" + "str.w r10, [r0,#172] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 15 + + "ldr.w r9, [r0,#496] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#500] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#176] \n\t" + "str.w r10, [r0,#180] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 16 + + "ldr.w r9, [r0,#504] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#508] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#184] \n\t" + "str.w r10, [r0,#188] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 17 + + "ldr.w r9, [r0,#512] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#516] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#192] \n\t" + "str.w r10, [r0,#196] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 18 + + "ldr.w r9, [r0,#520] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#524] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#200] \n\t" + "str.w r10, [r0,#204] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 19 + + "ldr.w r9, [r0,#528] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#532] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#208] \n\t" + "str.w r10, [r0,#212] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 20 + + "ldr.w r9, [r0,#536] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#540] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#216] \n\t" + "str.w r10, [r0,#220] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 21 + + "ldr.w r9, [r0,#544] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#548] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#224] \n\t" + "str.w r10, [r0,#228] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 22 + + "ldr.w r9, [r0,#552] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#556] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#232] \n\t" + "str.w r10, [r0,#236] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 23 + + "ldr.w r9, [r0,#560] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#564] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#240] \n\t" + "str.w r10, [r0,#244] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 24 + + "ldr.w r9, [r0,#568] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#572] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#248] \n\t" + "str.w r10, [r0,#252] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 25 + + "ldr.w r9, [r0,#576] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#580] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#256] \n\t" + "str.w r10, [r0,#260] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 26 + + "ldr.w r9, [r0,#584] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#588] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#264] \n\t" + "str.w r10, [r0,#268] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 27 + + "ldr.w r9, [r0,#592] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#596] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#272] \n\t" + "str.w r10, [r0,#276] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 28 + + "ldr.w r9, [r0,#600] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#604] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#280] \n\t" + "str.w r10, [r0,#284] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 29 + + "ldr.w r9, [r0,#608] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#612] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#288] \n\t" + "str.w r10, [r0,#292] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 30 + + "ldr.w r9, [r0,#616] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#620] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#296] \n\t" + "str.w r10, [r0,#300] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 31 + + "ldr.w r9, [r0,#624] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#628] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#304] \n\t" + "str.w r10, [r0,#308] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 32 + + "ldr.w r9, [r0,#632] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#636] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#312] \n\t" + "str.w r10, [r0,#316] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 33 + + "ldr.w r9, [r0,#640] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#644] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#320] \n\t" + "str.w r10, [r0,#324] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 34 + + "ldr.w r9, [r0,#648] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#652] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#328] \n\t" + "str.w r10, [r0,#332] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 35 + + "ldr.w r9, [r0,#656] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#660] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#336] \n\t" + "str.w r10, [r0,#340] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 36 + + "ldr.w r9, [r0,#664] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#668] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#344] \n\t" + "str.w r10, [r0,#348] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 37 + + "ldr.w r9, [r0,#672] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#676] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#352] \n\t" + "str.w r10, [r0,#356] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 38 + + "ldr.w r9, [r0,#680] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#684] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#360] \n\t" + "str.w r10, [r0,#364] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 39 + + "ldr.w r9, [r0,#688] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#692] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#368] \n\t" + "str.w r10, [r0,#372] \n\t" + + // permutation + // r1 (k3 k2 k1 k0) k13 k8 k15 k9 + // r2 (k7 k6 k5 k4) k11 k12 k14 k10 + // r3 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r4 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r5, r3 \n\t" // r5(k11 k10 k9 k8 ) + "mov r6, r4 \n\t" // r6(k15 k14 k13 k12) + "mov r3, r1 \n\t" // r3(k3 k2 k1 k0) + "mov r4, r2 \n\t" // r4(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r1,r6, #16 \n\t" // r1(k13 k12 k15 k14) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 k14) + "pkhtb.w r2,r5, r5, asr #16 \n\t" // r2(k11 k10 k11 k10) + "ror.w r5, #8 \n\t" // r5( k8 k11 k10 k8) + "bfi.w r1,r5, #0,#8 \n\t" // r1(k13 k8 k15 k9) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k11 k10) + "ror.w r6,#16 \n\t" // r6(k13 k12 k15 k14) + "bfi.w r2,r6, #8,#8 \n\t" // r2(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r1, r6 \n\t" // r1(k12 k13 k14 k15) + "lsl.w r1, r1, #8 \n\t" // r1(k13 k14 k15 --) + "bfi.w r1,r5, #16,#8 \n\t" // r1(k13 k8 k15 --) + "lsr.w r5, r5, #8 \n\t" // r5( -- k11 k10 k9) + "bfi.w r1,r5, #0, #8 \n\t" // r1(k13 k8 k15 k9) + "rev16.w r2, r5 \n\t" // r2(k11 -- k9 k10) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k11 k12 k9 k10) + "lsr.w r6, r6, #16 \n\t" // r6(-- -- k15 k14) + "bfi.w r2,r6, #8, #8 \n\t" // r2(k11 k12 k14 k10) +#endif + // LFSR(for TK2) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x6 x5 x4 x3 x2 x1 x0 x7^x6) + "and.w r5, r7, r1, lsl #1 \n\t" + "and.w r6, r8, r1, lsr #7 \n\t" + "and.w r1, r8, r1, lsr #5 \n\t" + "eor.w r1, r6 \n\t" + "eor.w r1, r5 \n\t" + + "and.w r5, r7, r2, lsl #1 \n\t" + "and.w r6, r8, r2, lsr #7 \n\t" + "and.w r2, r8, r2, lsr #5 \n\t" + "eor.w r2, r6 \n\t" + "eor.w r2, r5 \n\t" + + // round 40 + + "ldr.w r9, [r0,#696] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#700] \n\t" // load TK3 ^ AC(c0 c1) + + "eor.w r9, r1 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r10, r2 \n\t" // TK2 ^ TK3 ^ AC(c0 c1) + + // round key store((TK2 ^ TK3 ^ AC(c0 c1)) + "str.w r9, [r0,#376] \n\t" + "str.w r10, [r0,#380] \n\t" + + // permutation + + // not need to calculate (not used) + + "ldmia.w sp!, {r4-r10} \n\t" + : + : [roundKeys] "r" (roundKeys) + : "cc"); +} diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule3.c b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule3.c new file mode 100644 index 0000000..0b8f83b --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_key_schedule3.c @@ -0,0 +1,2201 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * AC(c0 c1) ^ TK3 -> store + * ART(TK3) + * + * number of rounds : 40 + */ + +__attribute__((aligned(4))) +void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) +{ + // r0 : points to roundKeys(& masterKey) + // r1 : points to RC + // r2-r5 : key state + // r6-r7 : temp use + // r8 : constant(0x7f7f7f7f) + // r9 : constant(0x80808080) + asm volatile( + "stmdb sp!, {r4-r9} \n\t" + "ldr.w r2, [r0,#32] \n\t" // load master key + "ldr.w r3, [r0,#36] \n\t" // load master key + "ldr.w r4, [r0,#40] \n\t" // load master key + "ldr.w r5, [r0,#44] \n\t" // load master key + "mov.w r8, #0x7f7f7f7f \n\t" + "mov.w r9, #0x80808080 \n\t" + + // round 1 + + // AC(c0 c1) + "ldrb.w r6, [r1,#0] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#384] \n\t" + "str.w r7, [r0,#388] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 2 + + // AC(c0 c1) + "ldrb.w r6, [r1,#1] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#392] \n\t" + "str.w r7, [r0,#396] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 3 + + // AC(c0 c1) + "ldrb.w r6, [r1,#2] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#400] \n\t" + "str.w r7, [r0,#404] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 4 + + // AC(c0 c1) + "ldrb.w r6, [r1,#3] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#408] \n\t" + "str.w r7, [r0,#412] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 5 + + // AC(c0 c1) + "ldrb.w r6, [r1,#4] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#416] \n\t" + "str.w r7, [r0,#420] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 6 + + // AC(c0 c1) + "ldrb.w r6, [r1,#5] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#424] \n\t" + "str.w r7, [r0,#428] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 7 + + // AC(c0 c1) + "ldrb.w r6, [r1,#6] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#432] \n\t" + "str.w r7, [r0,#436] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 8 + + // AC(c0 c1) + "ldrb.w r6, [r1,#7] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#440] \n\t" + "str.w r7, [r0,#444] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 9 + + // AC(c0 c1) + "ldrb.w r6, [r1,#8] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#448] \n\t" + "str.w r7, [r0,#452] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 10 + + // AC(c0 c1) + "ldrb.w r6, [r1,#9] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#456] \n\t" + "str.w r7, [r0,#460] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 11 + + // AC(c0 c1) + "ldrb.w r6, [r1,#10] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#464] \n\t" + "str.w r7, [r0,#468] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 12 + + // AC(c0 c1) + "ldrb.w r6, [r1,#11] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#472] \n\t" + "str.w r7, [r0,#476] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 13 + + // AC(c0 c1) + "ldrb.w r6, [r1,#12] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#480] \n\t" + "str.w r7, [r0,#484] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 14 + + // AC(c0 c1) + "ldrb.w r6, [r1,#13] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#488] \n\t" + "str.w r7, [r0,#492] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 15 + + // AC(c0 c1) + "ldrb.w r6, [r1,#14] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#496] \n\t" + "str.w r7, [r0,#500] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 16 + + // AC(c0 c1) + "ldrb.w r6, [r1,#15] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#504] \n\t" + "str.w r7, [r0,#508] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 17 + + // AC(c0 c1) + "ldrb.w r6, [r1,#16] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#512] \n\t" + "str.w r7, [r0,#516] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 18 + + // AC(c0 c1) + "ldrb.w r6, [r1,#17] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#520] \n\t" + "str.w r7, [r0,#524] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 19 + + // AC(c0 c1) + "ldrb.w r6, [r1,#18] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#528] \n\t" + "str.w r7, [r0,#532] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 20 + + // AC(c0 c1) + "ldrb.w r6, [r1,#19] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#536] \n\t" + "str.w r7, [r0,#540] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 21 + + // AC(c0 c1) + "ldrb.w r6, [r1,#20] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#544] \n\t" + "str.w r7, [r0,#548] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 22 + + // AC(c0 c1) + "ldrb.w r6, [r1,#21] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#552] \n\t" + "str.w r7, [r0,#556] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 23 + + // AC(c0 c1) + "ldrb.w r6, [r1,#22] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#560] \n\t" + "str.w r7, [r0,#564] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 24 + + // AC(c0 c1) + "ldrb.w r6, [r1,#23] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#568] \n\t" + "str.w r7, [r0,#572] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 25 + + // AC(c0 c1) + "ldrb.w r6, [r1,#24] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#576] \n\t" + "str.w r7, [r0,#580] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 26 + + // AC(c0 c1) + "ldrb.w r6, [r1,#25] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#584] \n\t" + "str.w r7, [r0,#588] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 27 + + // AC(c0 c1) + "ldrb.w r6, [r1,#26] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#592] \n\t" + "str.w r7, [r0,#596] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 28 + + // AC(c0 c1) + "ldrb.w r6, [r1,#27] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#600] \n\t" + "str.w r7, [r0,#604] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 29 + + // AC(c0 c1) + "ldrb.w r6, [r1,#28] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#608] \n\t" + "str.w r7, [r0,#612] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 30 + + // AC(c0 c1) + "ldrb.w r6, [r1,#29] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#616] \n\t" + "str.w r7, [r0,#620] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 31 + + // AC(c0 c1) + "ldrb.w r6, [r1,#30] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#624] \n\t" + "str.w r7, [r0,#628] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 32 + + // AC(c0 c1) + "ldrb.w r6, [r1,#31] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#632] \n\t" + "str.w r7, [r0,#636] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 33 + + // AC(c0 c1) + "ldrb.w r6, [r1,#32] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#640] \n\t" + "str.w r7, [r0,#644] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 34 + + // AC(c0 c1) + "ldrb.w r6, [r1,#33] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#648] \n\t" + "str.w r7, [r0,#652] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 35 + + // AC(c0 c1) + "ldrb.w r6, [r1,#34] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#656] \n\t" + "str.w r7, [r0,#660] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 36 + + // AC(c0 c1) + "ldrb.w r6, [r1,#35] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#664] \n\t" + "str.w r7, [r0,#668] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 37 + + // AC(c0 c1) + "ldrb.w r6, [r1,#36] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#672] \n\t" + "str.w r7, [r0,#676] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 38 + + // AC(c0 c1) + "ldrb.w r6, [r1,#37] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#680] \n\t" + "str.w r7, [r0,#684] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 39 + + // AC(c0 c1) + "ldrb.w r6, [r1,#38] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#688] \n\t" + "str.w r7, [r0,#692] \n\t" + + // permutation + // r2 (k3 k2 k1 k0) k13 k8 k15 k9 + // r3 (k7 k6 k5 k4) k11 k12 k14 k10 + // r4 (k11 k10 k9 k8) ------> k3 k2 k1 k0 + // r5 (k15 k14 k13 k12) k7 k6 k5 k4 + "mov r6, r4 \n\t" // r6(k11 k10 k9 k8 ) + "mov r7, r5 \n\t" // r7(k15 k14 k13 k12) + "mov r4, r2 \n\t" // r4(k3 k2 k1 k0) + "mov r5, r3 \n\t" // r5(k7 k6 k5 k4) +#ifdef STM32F4 // for Cortex-M4 + "ror.w r2,r7, #16 \n\t" // r2(k13 k12 k15 k14) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 k14) + "pkhtb.w r3,r6, r6, asr #16 \n\t" // r3(k11 k10 k11 k10) + "ror.w r6, #8 \n\t" // r6( k8 k11 k10 k8) + "bfi.w r2,r6, #0,#8 \n\t" // r2(k13 k8 k15 k9) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k11 k10) + "ror.w r7,#16 \n\t" // r7(k13 k12 k15 k14) + "bfi.w r3,r7, #8,#8 \n\t" // r3(k11 k12 k14 k10) +#else // for Cortex-M3 + "rev.w r2, r7 \n\t" // r2(k12 k13 k14 k15) + "lsl.w r2, r2, #8 \n\t" // r2(k13 k14 k15 --) + "bfi.w r2,r6, #16,#8 \n\t" // r2(k13 k8 k15 --) + "lsr.w r6, r6, #8 \n\t" // r6( -- k11 k10 k9) + "bfi.w r2,r6, #0, #8 \n\t" // r2(k13 k8 k15 k9) + "rev16.w r3, r6 \n\t" // r3(k11 -- k9 k10) + "bfi.w r3,r7, #16,#8 \n\t" // r3(k11 k12 k9 k10) + "lsr.w r7, r7, #16 \n\t" // r7 (-- -- k15 k14) + "bfi.w r3,r7, #8, #8 \n\t" // r3(k11 k12 k14 k10) +#endif + // LFSR(for TK3) (x7 x6 x5 x4 x3 x2 x1 x0) -> (x0^x6 x7 x6 x5 x4 x2 x2 x1) + "and.w r6, r8, r2, lsr #1 \n\t" + "and.w r7, r9, r2, lsl #7 \n\t" + "and.w r2, r9, r2, lsl #1 \n\t" + "eor.w r2, r7 \n\t" + "eor.w r2, r6 \n\t" + + "and.w r6, r8, r3, lsr #1 \n\t" + "and.w r7, r9, r3, lsl #7 \n\t" + "and.w r3, r9, r3, lsl #1 \n\t" + "eor.w r3, r7 \n\t" + "eor.w r3, r6 \n\t" + + // round 40 + + // AC(c0 c1) + "ldrb.w r6, [r1,#39] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + + // round key store + "str.w r6, [r0,#696] \n\t" + "str.w r7, [r0,#700] \n\t" + + // permutation + + // not need to calculate (not used) + + "ldmia.w sp!, {r4-r9} \n\t" + : + : [roundKeys] "r" (roundKeys), [pRC] "r" (pRC) + : "cc"); +} diff --git a/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_main.c b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_main.c new file mode 100644 index 0000000..e266958 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1+v13/armsrc_NEC/skinny_main.c @@ -0,0 +1,3462 @@ +/****************************************************************************** + * Copyright (c) 2020, NEC Corporation. + * + * THIS CODE IS FURNISHED TO YOU "AS IS" WITHOUT WARRANTY OF ANY KIND. + * + *****************************************************************************/ + +/* + * SKINNY-128-384 + * + * ART(TK1) -> store + * load AC(c0 c1) ^ TK3 ^ TK2 + * load TK1 + * calc AC(c0 c1) ^ TK3 ^ TK2 ^ TK1 -> use at (AC->ART) + * SC->SR->(AC->ART)->MC + * + * number of rounds : 40 + */ + +#include "skinny.h" + +/* + * S-BOX + */ +unsigned char SBOX[512] += { + // Original + 0x65, 0x4c, 0x6a, 0x42, 0x4b, 0x63, 0x43, 0x6b, 0x55, 0x75, 0x5a, 0x7a, 0x53, 0x73, 0x5b, 0x7b, + 0x35, 0x8c, 0x3a, 0x81, 0x89, 0x33, 0x80, 0x3b, 0x95, 0x25, 0x98, 0x2a, 0x90, 0x23, 0x99, 0x2b, + 0xe5, 0xcc, 0xe8, 0xc1, 0xc9, 0xe0, 0xc0, 0xe9, 0xd5, 0xf5, 0xd8, 0xf8, 0xd0, 0xf0, 0xd9, 0xf9, + 0xa5, 0x1c, 0xa8, 0x12, 0x1b, 0xa0, 0x13, 0xa9, 0x05, 0xb5, 0x0a, 0xb8, 0x03, 0xb0, 0x0b, 0xb9, + 0x32, 0x88, 0x3c, 0x85, 0x8d, 0x34, 0x84, 0x3d, 0x91, 0x22, 0x9c, 0x2c, 0x94, 0x24, 0x9d, 0x2d, + 0x62, 0x4a, 0x6c, 0x45, 0x4d, 0x64, 0x44, 0x6d, 0x52, 0x72, 0x5c, 0x7c, 0x54, 0x74, 0x5d, 0x7d, + 0xa1, 0x1a, 0xac, 0x15, 0x1d, 0xa4, 0x14, 0xad, 0x02, 0xb1, 0x0c, 0xbc, 0x04, 0xb4, 0x0d, 0xbd, + 0xe1, 0xc8, 0xec, 0xc5, 0xcd, 0xe4, 0xc4, 0xed, 0xd1, 0xf1, 0xdc, 0xfc, 0xd4, 0xf4, 0xdd, 0xfd, + 0x36, 0x8e, 0x38, 0x82, 0x8b, 0x30, 0x83, 0x39, 0x96, 0x26, 0x9a, 0x28, 0x93, 0x20, 0x9b, 0x29, + 0x66, 0x4e, 0x68, 0x41, 0x49, 0x60, 0x40, 0x69, 0x56, 0x76, 0x58, 0x78, 0x50, 0x70, 0x59, 0x79, + 0xa6, 0x1e, 0xaa, 0x11, 0x19, 0xa3, 0x10, 0xab, 0x06, 0xb6, 0x08, 0xba, 0x00, 0xb3, 0x09, 0xbb, + 0xe6, 0xce, 0xea, 0xc2, 0xcb, 0xe3, 0xc3, 0xeb, 0xd6, 0xf6, 0xda, 0xfa, 0xd3, 0xf3, 0xdb, 0xfb, + 0x31, 0x8a, 0x3e, 0x86, 0x8f, 0x37, 0x87, 0x3f, 0x92, 0x21, 0x9e, 0x2e, 0x97, 0x27, 0x9f, 0x2f, + 0x61, 0x48, 0x6e, 0x46, 0x4f, 0x67, 0x47, 0x6f, 0x51, 0x71, 0x5e, 0x7e, 0x57, 0x77, 0x5f, 0x7f, + 0xa2, 0x18, 0xae, 0x16, 0x1f, 0xa7, 0x17, 0xaf, 0x01, 0xb2, 0x0e, 0xbe, 0x07, 0xb7, 0x0f, 0xbf, + 0xe2, 0xca, 0xee, 0xc6, 0xcf, 0xe7, 0xc7, 0xef, 0xd2, 0xf2, 0xde, 0xfe, 0xd7, 0xf7, 0xdf, 0xff, + + // Original ^ c2(0x02) + 0x67, 0x4e, 0x68, 0x40, 0x49, 0x61, 0x41, 0x69, 0x57, 0x77, 0x58, 0x78, 0x51, 0x71, 0x59, 0x79, + 0x37, 0x8e, 0x38, 0x83, 0x8b, 0x31, 0x82, 0x39, 0x97, 0x27, 0x9a, 0x28, 0x92, 0x21, 0x9b, 0x29, + 0xe7, 0xce, 0xea, 0xc3, 0xcb, 0xe2, 0xc2, 0xeb, 0xd7, 0xf7, 0xda, 0xfa, 0xd2, 0xf2, 0xdb, 0xfb, + 0xa7, 0x1e, 0xaa, 0x10, 0x19, 0xa2, 0x11, 0xab, 0x07, 0xb7, 0x08, 0xba, 0x01, 0xb2, 0x09, 0xbb, + 0x30, 0x8a, 0x3e, 0x87, 0x8f, 0x36, 0x86, 0x3f, 0x93, 0x20, 0x9e, 0x2e, 0x96, 0x26, 0x9f, 0x2f, + 0x60, 0x48, 0x6e, 0x47, 0x4f, 0x66, 0x46, 0x6f, 0x50, 0x70, 0x5e, 0x7e, 0x56, 0x76, 0x5f, 0x7f, + 0xa3, 0x18, 0xae, 0x17, 0x1f, 0xa6, 0x16, 0xaf, 0x00, 0xb3, 0x0e, 0xbe, 0x06, 0xb6, 0x0f, 0xbf, + 0xe3, 0xca, 0xee, 0xc7, 0xcf, 0xe6, 0xc6, 0xef, 0xd3, 0xf3, 0xde, 0xfe, 0xd6, 0xf6, 0xdf, 0xff, + 0x34, 0x8c, 0x3a, 0x80, 0x89, 0x32, 0x81, 0x3b, 0x94, 0x24, 0x98, 0x2a, 0x91, 0x22, 0x99, 0x2b, + 0x64, 0x4c, 0x6a, 0x43, 0x4b, 0x62, 0x42, 0x6b, 0x54, 0x74, 0x5a, 0x7a, 0x52, 0x72, 0x5b, 0x7b, + 0xa4, 0x1c, 0xa8, 0x13, 0x1b, 0xa1, 0x12, 0xa9, 0x04, 0xb4, 0x0a, 0xb8, 0x02, 0xb1, 0x0b, 0xb9, + 0xe4, 0xcc, 0xe8, 0xc0, 0xc9, 0xe1, 0xc1, 0xe9, 0xd4, 0xf4, 0xd8, 0xf8, 0xd1, 0xf1, 0xd9, 0xf9, + 0x33, 0x88, 0x3c, 0x84, 0x8d, 0x35, 0x85, 0x3d, 0x90, 0x23, 0x9c, 0x2c, 0x95, 0x25, 0x9d, 0x2d, + 0x63, 0x4a, 0x6c, 0x44, 0x4d, 0x65, 0x45, 0x6d, 0x53, 0x73, 0x5c, 0x7c, 0x55, 0x75, 0x5d, 0x7d, + 0xa0, 0x1a, 0xac, 0x14, 0x1d, 0xa5, 0x15, 0xad, 0x03, 0xb0, 0x0c, 0xbc, 0x05, 0xb5, 0x0d, 0xbd, + 0xe0, 0xc8, 0xec, 0xc4, 0xcd, 0xe5, 0xc5, 0xed, 0xd0, 0xf0, 0xdc, 0xfc, 0xd5, 0xf5, 0xdd, 0xfd, +}; + +/* + * Round Constants + */ +unsigned char RC[56] += { + 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3E, 0x3D, 0x3B, + 0x37, 0x2F, 0x1E, 0x3C, 0x39, 0x33, 0x27, 0x0E, + 0x1D, 0x3A, 0x35, 0x2B, 0x16, 0x2C, 0x18, 0x30, + 0x21, 0x02, 0x05, 0x0B, 0x17, 0x2E, 0x1C, 0x38, + 0x31, 0x23, 0x06, 0x0D, 0x1B, 0x36, 0x2D, 0x1A, + 0x34, 0x29, 0x12, 0x24, 0x08, 0x11, 0x22, 0x04, + 0x09, 0x13, 0x26, 0x0c, 0x19, 0x32, 0x25, 0x0a,}; + +extern void Encrypt(unsigned char *block, unsigned char *roundKeys, unsigned char *pSBOX) __attribute__((noinline)); +extern void RunEncryptionKeyScheduleTK2(unsigned char *roundKeys) __attribute__((noinline)); +extern void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) __attribute__((noinline)); + +void skinny_128_384_enc123_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[16]) = *((unsigned int *)&T[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[20]) = *((unsigned int *)&T[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[24]) = *((unsigned int *)&T[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[28]) = *((unsigned int *)&T[12]); + *((unsigned int *)&pskinny_ctrl->roundKeys[32]) = *((unsigned int *)&K[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[36]) = *((unsigned int *)&K[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[40]) = *((unsigned int *)&K[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[44]) = *((unsigned int *)&K[12]); + + RunEncryptionKeyScheduleTK3(pskinny_ctrl->roundKeys, RC); + RunEncryptionKeyScheduleTK2(pskinny_ctrl->roundKeys); + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); + + pskinny_ctrl->func_skinny_128_384_enc = skinny_128_384_enc12_12; +} + +void skinny_128_384_enc12_12 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + (void)K; + + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[16]) = *((unsigned int *)&T[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[20]) = *((unsigned int *)&T[4]); + *((unsigned int *)&pskinny_ctrl->roundKeys[24]) = *((unsigned int *)&T[8]); + *((unsigned int *)&pskinny_ctrl->roundKeys[28]) = *((unsigned int *)&T[12]); + + RunEncryptionKeyScheduleTK2(pskinny_ctrl->roundKeys); + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); +} + +extern void skinny_128_384_enc1_1 (unsigned char* input, skinny_ctrl* pskinny_ctrl, unsigned char* CNT, unsigned char* T, const unsigned char* K) +{ + (void)T; + (void)K; + + *((unsigned int *)&pskinny_ctrl->roundKeys[0] ) = *((unsigned int *)&CNT[0]); + *((unsigned int *)&pskinny_ctrl->roundKeys[4] ) = *((unsigned int *)&CNT[4]); + + Encrypt(input, pskinny_ctrl->roundKeys, SBOX); +} + +__attribute__((aligned(4))) +void Encrypt(unsigned char *block, unsigned char *roundKeys, unsigned char *pSBOX) +{ + // r0 : ponits to plaintext + // r1 : points to roundKeys(& masterKey) + // r2 : points to SBOX + // r3-r6 : cipher state + // r7-r12: temp use + // r14 : temp use + asm volatile( + "stmdb sp!, {r4-r12,r14} \n\t" + "stmdb.w sp!, {r0} \n\t" // push store pointer + +// ART(TK1) + + "ldm.w r1, {r3-r4} \n\t" // load master key + + // round 1-2 + +// // round key store(do not need) +// "str.w r3, [r1,#0] \n\t" +// "str.w r4, [r1,#4] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 3-4 + + // round key store + "str.w r5, [r1,#8] \n\t" + "str.w r6, [r1,#12] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 5-6 + + // round key store + "str.w r3, [r1,#16] \n\t" + "str.w r4, [r1,#20] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 7-8 + + // round key store + "str.w r5, [r1,#24] \n\t" + "str.w r6, [r1,#28] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 9-10 + + // round key store + "str.w r3, [r1,#32] \n\t" + "str.w r4, [r1,#36] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 11-12 + + // round key store + "str.w r5, [r1,#40] \n\t" + "str.w r6, [r1,#44] \n\t" + + // premutation + + // r3 (--- --- --- ---) k5 k0 k7 k1 + // r4 (--- --- --- ---) k3 k4 k6 k2 + // r5 ( k3 k2 k1 k0) -----> --- --- --- --- + // r6 ( k7 k6 k5 k4) --- --- --- --- +#ifdef STM32F4 // for Cortex-M4 + "ror.w r3,r6, #16 \n\t" // r3( k5 k4 k7 k6) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 k6) + "pkhtb.w r4,r5, r5, asr #16 \n\t" // r4( k3 k2 k3 k2) + "ror.w r5, #8 \n\t" // r5( k0 k3 k2 k1) + "bfi.w r3,r5, #0,#8 \n\t" // r3( k5 k4 k2 k6) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k3 k2) + "ror.w r6,#16 \n\t" // r6( k5 k4 k7 k6) + "bfi.w r4,r6, #8,#8 \n\t" // r4( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r3, r6 \n\t" // r3( k4 k5 k6 k7) + "lsl.w r3, r3, #8 \n\t" // r3( k5 k6 k7 ---) + "bfi.w r3,r5, #16,#8 \n\t" // r3( k5 k0 k7 ---) + "lsr.w r5, r5, #8 \n\t" // r5(--- k3 k2 k1) + "bfi.w r3,r5, #0, #8 \n\t" // r3( k5 k0 k7 k1) + "rev16.w r4, r5 \n\t" // r4( k3 --- k1 k2) + "bfi.w r4,r6, #16,#8 \n\t" // r4( k3 k4 k1 k2) + "lsr.w r6, r6, #16 \n\t" // r6(-- --- k7 k6) + "bfi.w r4,r6, #8, #8 \n\t" // r4( k3 k4 k6 k2) +#endif + + // round 13-14 + + // round key store + "str.w r3, [r1,#48] \n\t" + "str.w r4, [r1,#52] \n\t" + + // premutation + + // r3 ( k3 k2 k1 k0) --- --- --- --- + // r4 ( k7 k6 k5 k4) --- --- --- --- + // r5 (--- --- --- ---) -----> k5 k0 k7 k1 + // r6 (--- --- --- ---) k3 k4 k6 k2 +#ifdef STM32F4 // for Cortex-M4 + "ror.w r5,r4, #16 \n\t" // r5( k5 k4 k7 k6) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 k6) + "pkhtb.w r6,r3, r3, asr #16 \n\t" // r6( k3 k2 k3 k2) + "ror.w r3, #8 \n\t" // r3( k0 k3 k2 k1) + "bfi.w r5,r3, #0,#8 \n\t" // r5( k5 k4 k2 k6) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k3 k2) + "ror.w r4,#16 \n\t" // r4( k5 k4 k7 k6) + "bfi.w r6,r4, #8,#8 \n\t" // r6( k3 k4 k6 k2) +#else // for Cortex-M3 + "rev.w r5, r4 \n\t" // r5( k4 k5 k6 k7) + "lsl.w r5, r5, #8 \n\t" // r5( k5 k6 k7 ---) + "bfi.w r5,r3, #16,#8 \n\t" // r5( k5 k0 k7 ---) + "lsr.w r3, r3, #8 \n\t" // r3(--- k3 k2 k1) + "bfi.w r5,r3, #0, #8 \n\t" // r5( k5 k0 k7 k1) + "rev16.w r6, r3 \n\t" // r6( k3 --- k1 k2) + "bfi.w r6,r4, #16,#8 \n\t" // r6( k3 k4 k1 k2) + "lsr.w r4, r4, #16 \n\t" // r4(-- --- k7 k6) + "bfi.w r6,r4, #8, #8 \n\t" // r6( k3 k4 k6 k2) +#endif + // round 15-16 + + // round key store + "str.w r5, [r1,#56] \n\t" + "str.w r6, [r1,#60] \n\t" + + // premutation + + // not need to calculate (not used) + +// SC->(AC->ART)->SR->MC + + "add.w r14, r2, #256 \n\t" // point to SBOX ^ c2(0x02) + + "ldm.w r0, {r3-r6} \n\t" // load plaintext + // r0 now free to overwrite + + // round 1 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#64] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#68] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 2 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#72] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#76] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 3 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#80] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#84] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 4 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#88] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#92] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 5 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#96] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#100] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 6 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#104] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#108] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 7 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#112] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#116] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 8 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#120] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#124] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 9 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#32] \n\t" // load TK1 + "ldr.w r10, [r1,#36] \n\t" // load TK1 + "ldr.w r11, [r1,#128] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#132] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 10 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#136] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#140] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 11 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#40] \n\t" // load TK1 + "ldr.w r10, [r1,#44] \n\t" // load TK1 + "ldr.w r11, [r1,#144] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#148] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 12 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#152] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#156] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 13 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#48] \n\t" // load TK1 + "ldr.w r10, [r1,#52] \n\t" // load TK1 + "ldr.w r11, [r1,#160] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#164] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 14 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#168] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#172] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 15 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#56] \n\t" // load TK1 + "ldr.w r10, [r1,#60] \n\t" // load TK1 + "ldr.w r11, [r1,#176] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#180] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 16 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#184] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#188] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 17 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#192] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#196] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 18 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#200] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#204] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 19 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#208] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#212] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 20 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#216] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#220] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 21 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#224] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#228] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 22 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#232] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#236] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 23 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#240] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#244] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 24 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#248] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#252] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 25 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#32] \n\t" // load TK1 + "ldr.w r10, [r1,#36] \n\t" // load TK1 + "ldr.w r11, [r1,#256] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#260] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 26 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#264] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#268] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 27 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#40] \n\t" // load TK1 + "ldr.w r10, [r1,#44] \n\t" // load TK1 + "ldr.w r11, [r1,#272] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#276] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 28 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#280] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#284] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 29 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#48] \n\t" // load TK1 + "ldr.w r10, [r1,#52] \n\t" // load TK1 + "ldr.w r11, [r1,#288] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#292] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 30 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#296] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#300] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 31 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#56] \n\t" // load TK1 + "ldr.w r10, [r1,#60] \n\t" // load TK1 + "ldr.w r11, [r1,#304] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#308] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 32 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#312] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#316] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 33 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#0] \n\t" // load TK1 + "ldr.w r10, [r1,#4] \n\t" // load TK1 + "ldr.w r11, [r1,#320] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#324] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 34 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#328] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#332] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 35 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#8] \n\t" // load TK1 + "ldr.w r10, [r1,#12] \n\t" // load TK1 + "ldr.w r11, [r1,#336] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#340] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 36 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#344] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#348] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 37 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#16] \n\t" // load TK1 + "ldr.w r10, [r1,#20] \n\t" // load TK1 + "ldr.w r11, [r1,#352] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#356] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 38 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#360] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#364] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + // round 39 + + // SubCell+ShiftRow+AC(c2) + // r3 (s3 s2 s1 s0) + // r4 (s7 s6 s5 s4) + // r5 (s11 s10 s9 s8) + // r6 (s15 s14 s13 s12) + + // 1st-2nd line + // r3(s3 s2 s1 s0) + "uxtb.w r9, r3, ror #24 \n\t" // s3 + "uxtb.w r8, r3, ror #16 \n\t" // s2 + "uxtb.w r7, r3, ror #8 \n\t" // s1 + "uxtb.w r3, r3 \n\t" // s0 + // r4(s6 s5 s4 s7) + "uxtb.w r12, r4, ror #16 \n\t" // s6 + "uxtb.w r11, r4, ror #8 \n\t" // s5 + "uxtb.w r10, r4 \n\t" // s4 + "uxtb.w r4, r4, ror #24 \n\t" // s7 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "eor.w r3, r3, r7, lsl #8 \n\t" + "eor.w r3, r3, r8, lsl #16 \n\t" + "eor.w r3, r3, r9, lsl #24 \n\t" + "eor.w r4, r4, r10, lsl #8 \n\t" + "eor.w r4, r4, r11, lsl #16 \n\t" + "eor.w r4, r4, r12, lsl #24 \n\t" + + // 3rd-4th line + // r5(s9 s8 s11 s10) + "uxtb.w r9, r5, ror #8 \n\t" // s9 + "uxtb.w r8, r5 \n\t" // s8 + "uxtb.w r7, r5, ror #24 \n\t" // s11 + "uxtb.w r5, r5, ror #16 \n\t" // s10 + // r6(s12 s15 s14 s13) + "uxtb.w r12, r6 \n\t" // s12 + "uxtb.w r11, r6, ror #24 \n\t" // s15 + "uxtb.w r10, r6, ror #16 \n\t" // s14 + "uxtb.w r6, r6, ror #8 \n\t" // s13 + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r8, [r14,r8] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "eor.w r5, r5, r7, lsl #8 \n\t" + "eor.w r5, r5, r8, lsl #16 \n\t" + "eor.w r5, r5, r9, lsl #24 \n\t" + "eor.w r6, r6, r10, lsl #8 \n\t" + "eor.w r6, r6, r11, lsl #16 \n\t" + "eor.w r6, r6, r12, lsl #24 \n\t" + + // AddRoundKey and AddRoundConst(from roundKeys) + "ldr.w r9, [r1,#24] \n\t" // load TK1 + "ldr.w r10, [r1,#28] \n\t" // load TK1 + "ldr.w r11, [r1,#368] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#372] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r11, r9 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r12, r10 \n\t" // TK1 ^ TK2 ^ TK3 ^ AC(c0 c1) + + "eor.w r8, r3, r11 \n\t" // r3 eor r11 -----------------> r8( s3 s2 s1 s0) + "eor.w r7, r4, r12, ror 24 \n\t" // r4 eor (r12 ror 24) --------> r7( s6 s5 s4 s7) + // r8( s9 s8 s11 s10) + // r6(s12 s14 s14 s13) + + // MixColumn + "eor.w r10, r8, r5 \n\t" // r8 eor r5 ---------> r10 + "eor.w r9, r7, r5 \n\t" // r7 eor r5 ---------> r9 + "eor.w r7, r6, r10 \n\t" // r6 eor r10 --------> r7 + // r8 ----------------> r8 + + // round 40 + + // SubCell+ShiftRow+AC(c2) + // r7 (s3 s2 s1 s0) + // r8 (s7 s6 s5 s4) + // r9 (s11 s10 s9 s8) + // r10(s15 s14 s13 s12) + + // 1st-2nd line + // r7(s3 s2 s1 s0) + "uxtb.w r5, r7, ror #24 \n\t" // s3 + "uxtb.w r4, r7, ror #16 \n\t" // s2 + "uxtb.w r3, r7, ror #8 \n\t" // s1 + "uxtb.w r7, r7 \n\t" // s0 + // r8(s6 s5 s4 s7) + "uxtb.w r12, r8, ror #16 \n\t" // s6 + "uxtb.w r11, r8, ror #8 \n\t" // s5 + "uxtb.w r6, r8 \n\t" // s4 + "uxtb.w r8, r8, ror #24 \n\t" // s7 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r4, [r2,r4] \n\t" + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r7, [r2,r7] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r8, [r2,r8] \n\t" + "ldr.w r0, [r1,#376] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r7, r7, r3, lsl #8 \n\t" + "eor.w r7, r7, r4, lsl #16 \n\t" + "eor.w r7, r7, r5, lsl #24 \n\t" + "eor.w r8, r8, r6, lsl #8 \n\t" + "eor.w r8, r8, r11, lsl #16 \n\t" + "eor.w r8, r8, r12, lsl #24 \n\t" + "eor.w r4, r7, r0 \n\t" // r7 eor r0 -----------------> r4( s3 s2 s1 s0) + + // 3rd-4th line + // r9(s9 s8 s11 s10) + "uxtb.w r5, r9, ror #8 \n\t" // s9 + "uxtb.w r7, r9 \n\t" // s8 + "uxtb.w r3, r9, ror #24 \n\t" // s11 + "uxtb.w r9, r9, ror #16 \n\t" // s10 + // r10(s12 s15 s14 s13) + "uxtb.w r12, r10 \n\t" // s12 + "uxtb.w r11, r10, ror #24 \n\t" // s15 + "uxtb.w r6, r10, ror #16 \n\t" // s14 + "uxtb.w r10, r10, ror #8 \n\t" // s13 + "ldrb.w r5, [r2,r5] \n\t" + "ldrb.w r7, [r14,r7] \n\t" // load from SBOX ^ c2(0x02) + "ldrb.w r3, [r2,r3] \n\t" + "ldrb.w r9, [r2,r9] \n\t" + "ldrb.w r12, [r2,r12] \n\t" + "ldrb.w r11, [r2,r11] \n\t" + "ldrb.w r6, [r2,r6] \n\t" + "ldrb.w r10, [r2,r10] \n\t" + "ldr.w r0, [r1,#380] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "eor.w r9, r9, r3, lsl #8 \n\t" + "eor.w r9, r9, r7, lsl #16 \n\t" + "eor.w r9, r9, r5, lsl #24 \n\t" + "eor.w r10, r10, r6, lsl #8 \n\t" + "eor.w r10, r10, r11, lsl #16 \n\t" + "eor.w r10, r10, r12, lsl #24 \n\t" + "eor.w r3, r8, r0, ror 24 \n\t" // r8 eor (r0 ror 24) --------> r3( s6 s5 s4 s7) + + // AddRoundKey and AddRoundConst(from roundKeys) + + // r9( s9 s8 s11 s10) + // r10(s12 s14 s14 s13) + + // MixColumn + "eor.w r6, r4, r9 \n\t" // r4 eor r9 --------> r6 + "eor.w r5, r3, r9 \n\t" // r3 eor r9 --------> r5 + "eor.w r3, r10, r6 \n\t" // r10 eor r6 --------> r3 + // r4 ----------------> r4 + + "ldmia.w sp!, {r0} \n\t" // pop store pointer + // r0 reload + + "str.w r3, [r0,#0] \n\t" // store ciphertext + "str.w r4, [r0,#4] \n\t" // store ciphertext + "str.w r5, [r0,#8] \n\t" // store ciphertext + "str.w r6, [r0,#12] \n\t" // store ciphertext + + "ldmia.w sp!, {r4-r12,r14} \n\t" + : + : [block] "r" (block), [roundKeys] "r" (roundKeys), [pSBOX] "" (pSBOX) + : "cc"); +} + diff --git a/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/encrypt.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/encrypt.c index e953677..5a7d0e0 100644 --- a/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/encrypt.c +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/encrypt.c @@ -505,6 +505,7 @@ const unsigned char *k } } + l_skinny_ctrl.func_skinny_128_384_enc = skinny_128_384_enc1_1; reset_lfsr_gf56(CNT); clen = clen - 16; diff --git a/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/skinny_key_schedule3.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/skinny_key_schedule3.c index 81c4406..d8a4f30 100644 --- a/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/skinny_key_schedule3.c +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc_NEC/skinny_key_schedule3.c @@ -35,11 +35,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 1 // AC(c0 c1) - "eor.w r6, r2, #0x1 \n\t" // k0^rc + "ldrb.w r6, [r1,#0] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#512] \n\t" - "str.w r3, [r0,#516] \n\t" + "str.w r7, [r0,#516] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -86,11 +90,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 2 // AC(c0 c1) - "eor.w r6, r2, #0x3 \n\t" // k0^rc + "ldrb.w r6, [r1,#1] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#520] \n\t" - "str.w r3, [r0,#524] \n\t" + "str.w r7, [r0,#524] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -137,11 +145,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 3 // AC(c0 c1) - "eor.w r6, r2, #0x7 \n\t" // k0^rc + "ldrb.w r6, [r1,#2] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#528] \n\t" - "str.w r3, [r0,#532] \n\t" + "str.w r7, [r0,#532] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -188,11 +200,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 4 // AC(c0 c1) - "eor.w r6, r2, #0xf \n\t" // k0^rc + "ldrb.w r6, [r1,#3] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#536] \n\t" - "str.w r3, [r0,#540] \n\t" + "str.w r7, [r0,#540] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -239,8 +255,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 5 // AC(c0 c1) - "eor.w r6, r2, #0xf \n\t" // k0^rc - "eor.w r7, r3, #0x1 \n\t" // k0^rc + "ldrb.w r6, [r1,#4] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#544] \n\t" @@ -291,8 +310,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 6 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0xe \n\t" // k0^rc + "ldrb.w r6, [r1,#5] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#552] \n\t" @@ -343,9 +365,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 7 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0xd \n\t" // k0^rc + "ldrb.w r6, [r1,#6] \n\t" // load RC + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#560] \n\t" @@ -396,8 +420,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 8 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0xb \n\t" // k0^rc + "ldrb.w r6, [r1,#7] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#568] \n\t" @@ -448,8 +475,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 9 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x7 \n\t" // k0^rc + "ldrb.w r6, [r1,#8] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#576] \n\t" @@ -500,8 +530,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 10 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0xf \n\t" // k0^rc + "ldrb.w r6, [r1,#9] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#584] \n\t" @@ -552,8 +585,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 11 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0xe \n\t" // k0^rc + "ldrb.w r6, [r1,#10] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#592] \n\t" @@ -604,8 +640,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 12 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0xc \n\t" // k0^rc + "ldrb.w r6, [r1,#11] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#600] \n\t" @@ -656,8 +695,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 13 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x9 \n\t" // k0^rc + "ldrb.w r6, [r1,#12] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#608] \n\t" @@ -708,8 +750,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 14 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x3 \n\t" // k0^rc + "ldrb.w r6, [r1,#13] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#616] \n\t" @@ -760,8 +805,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 15 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x7 \n\t" // k0^rc + "ldrb.w r6, [r1,#14] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#624] \n\t" @@ -812,11 +860,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 16 // AC(c0 c1) - "eor.w r6, r2, #0xe \n\t" // k0^rc + "ldrb.w r6, [r1,#15] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#632] \n\t" - "str.w r3, [r0,#636] \n\t" + "str.w r7, [r0,#636] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -863,8 +915,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 17 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0xd \n\t" // k0^rc + "ldrb.w r6, [r1,#16] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#640] \n\t" @@ -915,8 +970,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 18 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0xa \n\t" // k0^rc + "ldrb.w r6, [r1,#17] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#648] \n\t" @@ -967,8 +1025,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 19 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x5 \n\t" // k0^rc + "ldrb.w r6, [r1,#18] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#656] \n\t" @@ -1019,8 +1080,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 20 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0xb \n\t" // k0^rc + "ldrb.w r6, [r1,#19] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#664] \n\t" @@ -1071,8 +1135,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 21 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x6 \n\t" // k0^rc + "ldrb.w r6, [r1,#20] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#672] \n\t" @@ -1123,8 +1190,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 22 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0xc \n\t" // k0^rc + "ldrb.w r6, [r1,#21] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#680] \n\t" @@ -1175,8 +1245,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 23 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x8 \n\t" // k0^rc + "ldrb.w r6, [r1,#22] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#688] \n\t" @@ -1227,8 +1300,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 24 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x0 \n\t" // k0^rc + "ldrb.w r6, [r1,#23] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#696] \n\t" @@ -1279,8 +1355,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 25 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x1 \n\t" // k0^rc + "ldrb.w r6, [r1,#24] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#704] \n\t" @@ -1331,11 +1410,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 26 // AC(c0 c1) - "eor.w r6, r2, #0x2 \n\t" // k0^rc + "ldrb.w r6, [r1,#25] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#712] \n\t" - "str.w r3, [r0,#716] \n\t" + "str.w r7, [r0,#716] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -1382,11 +1465,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 27 // AC(c0 c1) - "eor.w r6, r2, #0x5 \n\t" // k0^rc + "ldrb.w r6, [r1,#26] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#720] \n\t" - "str.w r3, [r0,#724] \n\t" + "str.w r7, [r0,#724] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -1433,11 +1520,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 28 // AC(c0 c1) - "eor.w r6, r2, #0xb \n\t" // k0^rc + "ldrb.w r6, [r1,#27] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#728] \n\t" - "str.w r3, [r0,#732] \n\t" + "str.w r7, [r0,#732] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -1484,8 +1575,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 29 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x7 \n\t" // k0^rc + "ldrb.w r6, [r1,#28] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#736] \n\t" @@ -1536,8 +1630,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 30 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0xe \n\t" // k0^rc + "ldrb.w r6, [r1,#29] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#744] \n\t" @@ -1588,8 +1685,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 31 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0xc \n\t" // k0^rc + "ldrb.w r6, [r1,#30] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#752] \n\t" @@ -1640,8 +1740,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 32 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x8 \n\t" // k0^rc + "ldrb.w r6, [r1,#31] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#760] \n\t" @@ -1692,8 +1795,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 33 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x1 \n\t" // k0^rc + "ldrb.w r6, [r1,#32] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#768] \n\t" @@ -1744,8 +1850,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 34 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x3 \n\t" // k0^rc + "ldrb.w r6, [r1,#33] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#776] \n\t" @@ -1796,11 +1905,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 35 // AC(c0 c1) - "eor.w r6, r2, #0x6 \n\t" // k0^rc + "ldrb.w r6, [r1,#34] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#784] \n\t" - "str.w r3, [r0,#788] \n\t" + "str.w r7, [r0,#788] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -1847,11 +1960,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 36 // AC(c0 c1) - "eor.w r6, r2, #0xd \n\t" // k0^rc + "ldrb.w r6, [r1,#35] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#792] \n\t" - "str.w r3, [r0,#796] \n\t" + "str.w r7, [r0,#796] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -1898,8 +2015,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 37 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0xb \n\t" // k0^rc + "ldrb.w r6, [r1,#36] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#800] \n\t" @@ -1950,8 +2070,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 38 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x6 \n\t" // k0^rc + "ldrb.w r6, [r1,#37] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#808] \n\t" @@ -2002,8 +2125,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 39 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0xd \n\t" // k0^rc + "ldrb.w r6, [r1,#38] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#816] \n\t" @@ -2054,8 +2180,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 40 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0xa \n\t" // k0^rc + "ldrb.w r6, [r1,#39] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#824] \n\t" @@ -2106,8 +2235,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 41 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x4 \n\t" // k0^rc + "ldrb.w r6, [r1,#40] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#832] \n\t" @@ -2158,8 +2290,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 42 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x9 \n\t" // k0^rc + "ldrb.w r6, [r1,#41] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#840] \n\t" @@ -2210,8 +2345,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 43 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x2 \n\t" // k0^rc + "ldrb.w r6, [r1,#42] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#848] \n\t" @@ -2262,8 +2400,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 44 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x4 \n\t" // k0^rc + "ldrb.w r6, [r1,#43] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#856] \n\t" @@ -2314,11 +2455,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 45 // AC(c0 c1) - "eor.w r6, r2, #0x8 \n\t" // k0^rc + "ldrb.w r6, [r1,#44] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#864] \n\t" - "str.w r3, [r0,#868] \n\t" + "str.w r7, [r0,#868] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -2365,8 +2510,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 46 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x1 \n\t" // k0^rc + "ldrb.w r6, [r1,#45] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#872] \n\t" @@ -2417,8 +2565,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 47 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x2 \n\t" // k0^rc + "ldrb.w r6, [r1,#46] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#880] \n\t" @@ -2469,11 +2620,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 48 // AC(c0 c1) - "eor.w r6, r2, #0x4 \n\t" // k0^rc + "ldrb.w r6, [r1,#47] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#888] \n\t" - "str.w r3, [r0,#892] \n\t" + "str.w r7, [r0,#892] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -2520,11 +2675,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 49 // AC(c0 c1) - "eor.w r6, r2, #0x9 \n\t" // k0^rc + "ldrb.w r6, [r1,#48] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#896] \n\t" - "str.w r3, [r0,#900] \n\t" + "str.w r7, [r0,#900] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -2571,8 +2730,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 50 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x3 \n\t" // k0^rc + "ldrb.w r6, [r1,#49] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#904] \n\t" @@ -2623,8 +2785,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 51 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x6 \n\t" // k0^rc + "ldrb.w r6, [r1,#50] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#912] \n\t" @@ -2675,11 +2840,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 52 // AC(c0 c1) - "eor.w r6, r2, #0xc \n\t" // k0^rc + "ldrb.w r6, [r1,#51] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#920] \n\t" - "str.w r3, [r0,#924] \n\t" + "str.w r7, [r0,#924] \n\t" // permutation // r2 (k3 k2 k1 k0) k13 k8 k15 k9 @@ -2726,8 +2895,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 53 // AC(c0 c1) - "eor.w r7, r3, #0x1 \n\t" // k0^rc - "eor.w r6, r2, #0x9 \n\t" // k0^rc + "ldrb.w r6, [r1,#52] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#928] \n\t" @@ -2778,8 +2950,11 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 54 // AC(c0 c1) - "eor.w r7, r3, #0x3 \n\t" // k0^rc - "eor.w r6, r2, #0x2 \n\t" // k0^rc + "ldrb.w r6, [r1,#53] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#936] \n\t" @@ -2830,8 +3005,12 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 55 // AC(c0 c1) - "eor.w r7, r3, #0x2 \n\t" // k0^rc - "eor.w r6, r2, #0x5 \n\t" // k0^rc + "ldrb.w r6, [r1,#54] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc + // round key store "str.w r6, [r0,#944] \n\t" "str.w r7, [r0,#948] \n\t" @@ -2881,11 +3060,15 @@ void RunEncryptionKeyScheduleTK3(unsigned char *roundKeys, unsigned char *pRC) // round 56 // AC(c0 c1) - "eor.w r6, r2, #0xa \n\t" // k0^rc + "ldrb.w r6, [r1,#55] \n\t" // load RC + + "eor.w r7, r3, r6, lsr #4 \n\t" // k4^rc + "and.w r6, r6, #0xf \n\t" + "eor.w r6, r6, r2 \n\t" // k0^rc // round key store "str.w r6, [r0,#952] \n\t" - "str.w r3, [r0,#956] \n\t" + "str.w r7, [r0,#956] \n\t" // permutation