From dba8d5c7080a02ba3ae8f2c23f3adf534621f28a Mon Sep 17 00:00:00 2001 From: Alexandre Adomnicai Date: Fri, 20 Mar 2020 08:29:32 +0000 Subject: [PATCH] romulus armsrc --- romulus/Implementations/crypto_aead/romulusm1v12/armsrc/api.h | 5 +++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/crypto_aead.h | 11 +++++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/encrypt.c | 738 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/genkat_aead.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny.h | 8 ++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule2.c | 3027 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule3.c | 3081 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_main.c | 4687 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/api.h | 5 +++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/crypto_aead.h | 11 +++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/encrypt.c | 540 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/genkat_aead.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny.h | 8 ++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule2.c | 3027 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule3.c | 3081 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_main.c | 4687 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 16 files changed, 23238 insertions(+) create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/api.h create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/crypto_aead.h create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/encrypt.c create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/genkat_aead.c create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny.h create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule2.c create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule3.c create mode 100644 romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_main.c create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/api.h create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/crypto_aead.h create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/encrypt.c create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/genkat_aead.c create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny.h create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule2.c create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule3.c create mode 100644 romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_main.c diff --git a/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/api.h b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/api.h new file mode 100644 index 0000000..a4aa567 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/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/romulusm1v12/armsrc/crypto_aead.h b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/crypto_aead.h new file mode 100644 index 0000000..cfc09d6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/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/romulusm1v12/armsrc/encrypt.c b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/encrypt.c new file mode 100644 index 0000000..91d0e6e --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/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/romulusm1v12/armsrc/genkat_aead.c b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/genkat_aead.c new file mode 100644 index 0000000..21f840f --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/genkat_aead.c @@ -0,0 +1,161 @@ +// +// NIST-developed software is provided by NIST as a public service. +// You may use, copy and distribute copies of the software in any medium, +// provided that you keep intact this entire notice. You may improve, +// modify and create derivative works of the software or any portion of +// the software, and you may copy and distribute such modifications or +// works. Modified works should carry a notice stating that you changed +// the software and should note the date and nature of any such change. +// Please explicitly acknowledge the National Institute of Standards and +// Technology as the source of the software. +// +// NIST-developed software is expressly provided "AS IS." NIST MAKES NO +// WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION +// OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST +// NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE +// UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST +// DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE +// OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, +// RELIABILITY, OR USEFULNESS OF THE SOFTWARE. +// +// You are solely responsible for determining the appropriateness of using and +// distributing the software and you assume all risks associated with its use, +// including but not limited to the risks and costs of program errors, compliance +// with applicable laws, damage to or loss of data, programs or equipment, and +// the unavailability or interruption of operation. This software is not intended +// to be used in any situation where a failure could cause risk of injury or +// damage to property. The software developed by NIST employees is not subject to +// copyright protection within the United States. +// + +// disable deprecation for sprintf and fopen +#ifdef _MSC_VER +#define _CRT_SECURE_NO_WARNINGS +#endif + +#include +#include + +#include "crypto_aead.h" +#include "api.h" + +#define KAT_SUCCESS 0 +#define KAT_FILE_OPEN_ERROR -1 +#define KAT_DATA_ERROR -3 +#define KAT_CRYPTO_FAILURE -4 + +#define MAX_FILE_NAME 256 +#define MAX_MESSAGE_LENGTH 32 +#define MAX_ASSOCIATED_DATA_LENGTH 32 + +void init_buffer(unsigned char *buffer, unsigned long long numbytes); + +void fprint_bstr(FILE *fp, const char *label, const unsigned char *data, unsigned long long length); + +int generate_test_vectors(); + +int main() +{ + int ret = generate_test_vectors(); + + if (ret != KAT_SUCCESS) { + fprintf(stderr, "test vector generation failed with code %d\n", ret); + } + + return ret; +} + +int generate_test_vectors() +{ + FILE *fp; + char fileName[MAX_FILE_NAME]; + unsigned char key[CRYPTO_KEYBYTES]; + unsigned char nonce[CRYPTO_NPUBBYTES]; + unsigned char msg[MAX_MESSAGE_LENGTH]; + unsigned char msg2[MAX_MESSAGE_LENGTH]; + unsigned char ad[MAX_ASSOCIATED_DATA_LENGTH]; + unsigned char ct[MAX_MESSAGE_LENGTH + CRYPTO_ABYTES]; + unsigned long long clen, mlen2; + int count = 1; + int func_ret, ret_val = KAT_SUCCESS; + + init_buffer(key, sizeof(key)); + init_buffer(nonce, sizeof(nonce)); + init_buffer(msg, sizeof(msg)); + init_buffer(ad, sizeof(ad)); + + sprintf(fileName, "LWC_AEAD_KAT_%d_%d.txt", (CRYPTO_KEYBYTES * 8), (CRYPTO_NPUBBYTES * 8)); + + if ((fp = fopen(fileName, "w")) == NULL) { + fprintf(stderr, "Couldn't open <%s> for write\n", fileName); + return KAT_FILE_OPEN_ERROR; + } + + for (unsigned long long mlen = 0; (mlen <= MAX_MESSAGE_LENGTH) && (ret_val == KAT_SUCCESS); mlen++) { + for (unsigned long long adlen = 0; adlen <= MAX_ASSOCIATED_DATA_LENGTH; adlen++) { + + printf("%0d\n", (int)clen); + + fprintf(fp, "Count = %d\n", count++); + printf("Count = %d\n", count - 1); + + fprint_bstr(fp, "Key = ", key, CRYPTO_KEYBYTES); + + fprint_bstr(fp, "Nonce = ", nonce, CRYPTO_NPUBBYTES); + + fprint_bstr(fp, "PT = ", msg, mlen); + + fprint_bstr(fp, "AD = ", ad, adlen); + + if ((func_ret = crypto_aead_encrypt(ct, &clen, msg, mlen, ad, adlen, NULL, nonce, key)) != 0) { + fprintf(fp, "crypto_aead_encrypt returned <%d>\n", func_ret); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + fprint_bstr(fp, "CT = ", ct, clen); + + fprintf(fp, "\n"); + + if ((func_ret = crypto_aead_decrypt(msg2, &mlen2, NULL, ct, clen, ad, adlen, nonce, key)) != 0) { + fprintf(fp, "crypto_aead_decrypt returned <%d>\n", func_ret); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + if (mlen != mlen2) { + fprintf(fp, "crypto_aead_decrypt returned bad 'mlen': Got <%llu>, expected <%llu>\n", mlen2, mlen); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + if (memcmp(msg, msg2, mlen)) { + fprintf(fp, "crypto_aead_decrypt did not recover the plaintext\n"); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + } + } + + fclose(fp); + + return ret_val; +} + + +void fprint_bstr(FILE *fp, const char *label, const unsigned char *data, unsigned long long length) +{ + fprintf(fp, "%s", label); + + for (unsigned long long i = 0; i < length; i++) + fprintf(fp, "%02X", data[i]); + + fprintf(fp, "\n"); +} + +void init_buffer(unsigned char *buffer, unsigned long long numbytes) +{ + for (unsigned long long i = 0; i < numbytes; i++) + buffer[i] = (unsigned char)i; +} diff --git a/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny.h b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny.h new file mode 100644 index 0000000..6392b0f --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny.h @@ -0,0 +1,8 @@ +typedef struct ___skinny_ctrl { + unsigned char roundKeys[960]; // number of round : 56 + 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/romulusm1v12/armsrc/skinny_key_schedule2.c b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule2.c new file mode 100644 index 0000000..58006f2 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule2.c @@ -0,0 +1,3027 @@ +/****************************************************************************** + * 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 : 56 + */ + +__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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#704] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#708] \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,#712] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#716] \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,#720] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#724] \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,#728] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#732] \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,#736] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#740] \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,#744] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#748] \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,#752] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#756] \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,#760] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#764] \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,#768] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#772] \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,#776] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#780] \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,#784] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#788] \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,#792] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#796] \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,#800] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#804] \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,#808] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#812] \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,#816] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#820] \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,#824] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#828] \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 + // 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 41 + + "ldr.w r9, [r0,#832] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#836] \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,#384] \n\t" + "str.w r10, [r0,#388] \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 42 + + "ldr.w r9, [r0,#840] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#844] \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,#392] \n\t" + "str.w r10, [r0,#396] \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 43 + + "ldr.w r9, [r0,#848] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#852] \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,#400] \n\t" + "str.w r10, [r0,#404] \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 44 + + "ldr.w r9, [r0,#856] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#860] \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,#408] \n\t" + "str.w r10, [r0,#412] \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 45 + + "ldr.w r9, [r0,#864] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#868] \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,#416] \n\t" + "str.w r10, [r0,#420] \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 46 + + "ldr.w r9, [r0,#872] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#876] \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,#424] \n\t" + "str.w r10, [r0,#428] \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 47 + + "ldr.w r9, [r0,#880] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#884] \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,#432] \n\t" + "str.w r10, [r0,#436] \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 48 + + "ldr.w r9, [r0,#888] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#892] \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,#440] \n\t" + "str.w r10, [r0,#444] \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 49 + + "ldr.w r9, [r0,#896] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#900] \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,#448] \n\t" + "str.w r10, [r0,#452] \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 50 + + "ldr.w r9, [r0,#904] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#908] \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,#456] \n\t" + "str.w r10, [r0,#460] \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 51 + + "ldr.w r9, [r0,#912] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#916] \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,#464] \n\t" + "str.w r10, [r0,#468] \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 52 + + "ldr.w r9, [r0,#920] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#924] \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,#472] \n\t" + "str.w r10, [r0,#476] \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 53 + + "ldr.w r9, [r0,#928] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#932] \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,#480] \n\t" + "str.w r10, [r0,#484] \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 54 + + "ldr.w r9, [r0,#936] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#940] \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,#488] \n\t" + "str.w r10, [r0,#492] \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 55 + + "ldr.w r9, [r0,#944] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#948] \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,#496] \n\t" + "str.w r10, [r0,#500] \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 56 + + "ldr.w r9, [r0,#952] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#956] \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,#504] \n\t" + "str.w r10, [r0,#508] \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/romulusm1v12/armsrc/skinny_key_schedule3.c b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule3.c new file mode 100644 index 0000000..d8a4f30 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_key_schedule3.c @@ -0,0 +1,3081 @@ +/****************************************************************************** + * 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 : 56 + */ + +__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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#696] \n\t" + "str.w r7, [r0,#700] \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,#704] \n\t" + "str.w r7, [r0,#708] \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,#712] \n\t" + "str.w r7, [r0,#716] \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,#720] \n\t" + "str.w r7, [r0,#724] \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,#728] \n\t" + "str.w r7, [r0,#732] \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,#736] \n\t" + "str.w r7, [r0,#740] \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,#744] \n\t" + "str.w r7, [r0,#748] \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,#752] \n\t" + "str.w r7, [r0,#756] \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,#760] \n\t" + "str.w r7, [r0,#764] \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,#768] \n\t" + "str.w r7, [r0,#772] \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,#776] \n\t" + "str.w r7, [r0,#780] \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,#784] \n\t" + "str.w r7, [r0,#788] \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,#792] \n\t" + "str.w r7, [r0,#796] \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,#800] \n\t" + "str.w r7, [r0,#804] \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,#808] \n\t" + "str.w r7, [r0,#812] \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,#816] \n\t" + "str.w r7, [r0,#820] \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,#824] \n\t" + "str.w r7, [r0,#828] \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 41 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#836] \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 42 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#844] \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 43 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#852] \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 44 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#860] \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 45 + + // AC(c0 c1) + "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 r7, [r0,#868] \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 46 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#876] \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 47 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#884] \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 48 + + // AC(c0 c1) + "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 r7, [r0,#892] \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 49 + + // AC(c0 c1) + "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 r7, [r0,#900] \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 50 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#908] \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 51 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#916] \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 52 + + // AC(c0 c1) + "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 r7, [r0,#924] \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 53 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#932] \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 54 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#940] \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 55 + + // AC(c0 c1) + "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" + + // 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 56 + + // AC(c0 c1) + "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 r7, [r0,#956] \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/romulusm1v12/armsrc/skinny_main.c b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_main.c new file mode 100644 index 0000000..217b8a6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusm1v12/armsrc/skinny_main.c @@ -0,0 +1,4687 @@ +/****************************************************************************** + * 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 : 56 + */ + +#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 + + // round 41 + + // 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,#384] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#388] \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 42 + + // 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,#392] \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,#396] \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 43 + + // 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,#400] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#404] \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 44 + + // 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,#408] \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,#412] \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 45 + + // 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,#416] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#420] \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 46 + + // 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,#424] \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,#428] \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 47 + + // 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,#432] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#436] \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 48 + + // 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,#440] \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,#444] \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 49 + + // 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,#448] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#452] \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 50 + + // 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,#456] \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,#460] \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 51 + + // 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,#464] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#468] \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 52 + + // 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,#472] \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,#476] \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 53 + + // 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,#480] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#484] \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 54 + + // 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,#488] \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,#492] \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 55 + + // 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,#496] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#500] \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 56 + + // 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,#504] \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,#508] \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/api.h b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/api.h new file mode 100644 index 0000000..a4aa567 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/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/romulusn1v12/armsrc/crypto_aead.h b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/crypto_aead.h new file mode 100644 index 0000000..cfc09d6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/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/romulusn1v12/armsrc/encrypt.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/encrypt.c new file mode 100644 index 0000000..e953677 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/encrypt.c @@ -0,0 +1,540 @@ +/* + * 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); + } + } + + 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/romulusn1v12/armsrc/genkat_aead.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/genkat_aead.c new file mode 100644 index 0000000..21f840f --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/genkat_aead.c @@ -0,0 +1,161 @@ +// +// NIST-developed software is provided by NIST as a public service. +// You may use, copy and distribute copies of the software in any medium, +// provided that you keep intact this entire notice. You may improve, +// modify and create derivative works of the software or any portion of +// the software, and you may copy and distribute such modifications or +// works. Modified works should carry a notice stating that you changed +// the software and should note the date and nature of any such change. +// Please explicitly acknowledge the National Institute of Standards and +// Technology as the source of the software. +// +// NIST-developed software is expressly provided "AS IS." NIST MAKES NO +// WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION +// OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST +// NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE +// UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST +// DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE +// OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, +// RELIABILITY, OR USEFULNESS OF THE SOFTWARE. +// +// You are solely responsible for determining the appropriateness of using and +// distributing the software and you assume all risks associated with its use, +// including but not limited to the risks and costs of program errors, compliance +// with applicable laws, damage to or loss of data, programs or equipment, and +// the unavailability or interruption of operation. This software is not intended +// to be used in any situation where a failure could cause risk of injury or +// damage to property. The software developed by NIST employees is not subject to +// copyright protection within the United States. +// + +// disable deprecation for sprintf and fopen +#ifdef _MSC_VER +#define _CRT_SECURE_NO_WARNINGS +#endif + +#include +#include + +#include "crypto_aead.h" +#include "api.h" + +#define KAT_SUCCESS 0 +#define KAT_FILE_OPEN_ERROR -1 +#define KAT_DATA_ERROR -3 +#define KAT_CRYPTO_FAILURE -4 + +#define MAX_FILE_NAME 256 +#define MAX_MESSAGE_LENGTH 32 +#define MAX_ASSOCIATED_DATA_LENGTH 32 + +void init_buffer(unsigned char *buffer, unsigned long long numbytes); + +void fprint_bstr(FILE *fp, const char *label, const unsigned char *data, unsigned long long length); + +int generate_test_vectors(); + +int main() +{ + int ret = generate_test_vectors(); + + if (ret != KAT_SUCCESS) { + fprintf(stderr, "test vector generation failed with code %d\n", ret); + } + + return ret; +} + +int generate_test_vectors() +{ + FILE *fp; + char fileName[MAX_FILE_NAME]; + unsigned char key[CRYPTO_KEYBYTES]; + unsigned char nonce[CRYPTO_NPUBBYTES]; + unsigned char msg[MAX_MESSAGE_LENGTH]; + unsigned char msg2[MAX_MESSAGE_LENGTH]; + unsigned char ad[MAX_ASSOCIATED_DATA_LENGTH]; + unsigned char ct[MAX_MESSAGE_LENGTH + CRYPTO_ABYTES]; + unsigned long long clen, mlen2; + int count = 1; + int func_ret, ret_val = KAT_SUCCESS; + + init_buffer(key, sizeof(key)); + init_buffer(nonce, sizeof(nonce)); + init_buffer(msg, sizeof(msg)); + init_buffer(ad, sizeof(ad)); + + sprintf(fileName, "LWC_AEAD_KAT_%d_%d.txt", (CRYPTO_KEYBYTES * 8), (CRYPTO_NPUBBYTES * 8)); + + if ((fp = fopen(fileName, "w")) == NULL) { + fprintf(stderr, "Couldn't open <%s> for write\n", fileName); + return KAT_FILE_OPEN_ERROR; + } + + for (unsigned long long mlen = 0; (mlen <= MAX_MESSAGE_LENGTH) && (ret_val == KAT_SUCCESS); mlen++) { + for (unsigned long long adlen = 0; adlen <= MAX_ASSOCIATED_DATA_LENGTH; adlen++) { + + printf("%0d\n", (int)clen); + + fprintf(fp, "Count = %d\n", count++); + printf("Count = %d\n", count - 1); + + fprint_bstr(fp, "Key = ", key, CRYPTO_KEYBYTES); + + fprint_bstr(fp, "Nonce = ", nonce, CRYPTO_NPUBBYTES); + + fprint_bstr(fp, "PT = ", msg, mlen); + + fprint_bstr(fp, "AD = ", ad, adlen); + + if ((func_ret = crypto_aead_encrypt(ct, &clen, msg, mlen, ad, adlen, NULL, nonce, key)) != 0) { + fprintf(fp, "crypto_aead_encrypt returned <%d>\n", func_ret); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + fprint_bstr(fp, "CT = ", ct, clen); + + fprintf(fp, "\n"); + + if ((func_ret = crypto_aead_decrypt(msg2, &mlen2, NULL, ct, clen, ad, adlen, nonce, key)) != 0) { + fprintf(fp, "crypto_aead_decrypt returned <%d>\n", func_ret); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + if (mlen != mlen2) { + fprintf(fp, "crypto_aead_decrypt returned bad 'mlen': Got <%llu>, expected <%llu>\n", mlen2, mlen); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + + if (memcmp(msg, msg2, mlen)) { + fprintf(fp, "crypto_aead_decrypt did not recover the plaintext\n"); + ret_val = KAT_CRYPTO_FAILURE; + break; + } + } + } + + fclose(fp); + + return ret_val; +} + + +void fprint_bstr(FILE *fp, const char *label, const unsigned char *data, unsigned long long length) +{ + fprintf(fp, "%s", label); + + for (unsigned long long i = 0; i < length; i++) + fprintf(fp, "%02X", data[i]); + + fprintf(fp, "\n"); +} + +void init_buffer(unsigned char *buffer, unsigned long long numbytes) +{ + for (unsigned long long i = 0; i < numbytes; i++) + buffer[i] = (unsigned char)i; +} diff --git a/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny.h b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny.h new file mode 100644 index 0000000..6392b0f --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny.h @@ -0,0 +1,8 @@ +typedef struct ___skinny_ctrl { + unsigned char roundKeys[960]; // number of round : 56 + 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/romulusn1v12/armsrc/skinny_key_schedule2.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule2.c new file mode 100644 index 0000000..58006f2 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule2.c @@ -0,0 +1,3027 @@ +/****************************************************************************** + * 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 : 56 + */ + +__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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#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,#704] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#708] \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,#712] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#716] \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,#720] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#724] \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,#728] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#732] \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,#736] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#740] \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,#744] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#748] \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,#752] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#756] \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,#760] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#764] \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,#768] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#772] \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,#776] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#780] \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,#784] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#788] \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,#792] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#796] \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,#800] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#804] \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,#808] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#812] \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,#816] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#820] \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,#824] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#828] \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 + // 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 41 + + "ldr.w r9, [r0,#832] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#836] \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,#384] \n\t" + "str.w r10, [r0,#388] \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 42 + + "ldr.w r9, [r0,#840] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#844] \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,#392] \n\t" + "str.w r10, [r0,#396] \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 43 + + "ldr.w r9, [r0,#848] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#852] \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,#400] \n\t" + "str.w r10, [r0,#404] \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 44 + + "ldr.w r9, [r0,#856] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#860] \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,#408] \n\t" + "str.w r10, [r0,#412] \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 45 + + "ldr.w r9, [r0,#864] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#868] \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,#416] \n\t" + "str.w r10, [r0,#420] \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 46 + + "ldr.w r9, [r0,#872] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#876] \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,#424] \n\t" + "str.w r10, [r0,#428] \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 47 + + "ldr.w r9, [r0,#880] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#884] \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,#432] \n\t" + "str.w r10, [r0,#436] \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 48 + + "ldr.w r9, [r0,#888] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#892] \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,#440] \n\t" + "str.w r10, [r0,#444] \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 49 + + "ldr.w r9, [r0,#896] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#900] \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,#448] \n\t" + "str.w r10, [r0,#452] \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 50 + + "ldr.w r9, [r0,#904] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#908] \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,#456] \n\t" + "str.w r10, [r0,#460] \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 51 + + "ldr.w r9, [r0,#912] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#916] \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,#464] \n\t" + "str.w r10, [r0,#468] \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 52 + + "ldr.w r9, [r0,#920] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#924] \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,#472] \n\t" + "str.w r10, [r0,#476] \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 53 + + "ldr.w r9, [r0,#928] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#932] \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,#480] \n\t" + "str.w r10, [r0,#484] \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 54 + + "ldr.w r9, [r0,#936] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#940] \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,#488] \n\t" + "str.w r10, [r0,#492] \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 55 + + "ldr.w r9, [r0,#944] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#948] \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,#496] \n\t" + "str.w r10, [r0,#500] \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 56 + + "ldr.w r9, [r0,#952] \n\t" // load TK3 ^ AC(c0 c1) + "ldr.w r10, [r0,#956] \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,#504] \n\t" + "str.w r10, [r0,#508] \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/romulusn1v12/armsrc/skinny_key_schedule3.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule3.c new file mode 100644 index 0000000..d8a4f30 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_key_schedule3.c @@ -0,0 +1,3081 @@ +/****************************************************************************** + * 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 : 56 + */ + +__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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#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 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,#696] \n\t" + "str.w r7, [r0,#700] \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,#704] \n\t" + "str.w r7, [r0,#708] \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,#712] \n\t" + "str.w r7, [r0,#716] \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,#720] \n\t" + "str.w r7, [r0,#724] \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,#728] \n\t" + "str.w r7, [r0,#732] \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,#736] \n\t" + "str.w r7, [r0,#740] \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,#744] \n\t" + "str.w r7, [r0,#748] \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,#752] \n\t" + "str.w r7, [r0,#756] \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,#760] \n\t" + "str.w r7, [r0,#764] \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,#768] \n\t" + "str.w r7, [r0,#772] \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,#776] \n\t" + "str.w r7, [r0,#780] \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,#784] \n\t" + "str.w r7, [r0,#788] \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,#792] \n\t" + "str.w r7, [r0,#796] \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,#800] \n\t" + "str.w r7, [r0,#804] \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,#808] \n\t" + "str.w r7, [r0,#812] \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,#816] \n\t" + "str.w r7, [r0,#820] \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,#824] \n\t" + "str.w r7, [r0,#828] \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 41 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#836] \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 42 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#844] \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 43 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#852] \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 44 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#860] \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 45 + + // AC(c0 c1) + "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 r7, [r0,#868] \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 46 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#876] \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 47 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#884] \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 48 + + // AC(c0 c1) + "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 r7, [r0,#892] \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 49 + + // AC(c0 c1) + "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 r7, [r0,#900] \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 50 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#908] \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 51 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#916] \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 52 + + // AC(c0 c1) + "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 r7, [r0,#924] \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 53 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#932] \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 54 + + // AC(c0 c1) + "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" + "str.w r7, [r0,#940] \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 55 + + // AC(c0 c1) + "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" + + // 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 56 + + // AC(c0 c1) + "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 r7, [r0,#956] \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/romulusn1v12/armsrc/skinny_main.c b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_main.c new file mode 100644 index 0000000..217b8a6 --- /dev/null +++ b/romulus/Implementations/crypto_aead/romulusn1v12/armsrc/skinny_main.c @@ -0,0 +1,4687 @@ +/****************************************************************************** + * 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 : 56 + */ + +#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 + + // round 41 + + // 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,#384] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#388] \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 42 + + // 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,#392] \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,#396] \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 43 + + // 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,#400] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#404] \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 44 + + // 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,#408] \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,#412] \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 45 + + // 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,#416] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#420] \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 46 + + // 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,#424] \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,#428] \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 47 + + // 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,#432] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#436] \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 48 + + // 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,#440] \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,#444] \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 49 + + // 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,#448] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#452] \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 50 + + // 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,#456] \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,#460] \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 51 + + // 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,#464] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#468] \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 52 + + // 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,#472] \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,#476] \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 53 + + // 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,#480] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#484] \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 54 + + // 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,#488] \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,#492] \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 55 + + // 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,#496] \n\t" // load TK2 ^ TK3 ^ AC(c0 c1) + "ldr.w r12, [r1,#500] \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 56 + + // 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,#504] \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,#508] \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"); +} + -- libgit2 0.26.0