/* * Copyright ( c ) 2008 , 2022 , Oracle and / or its affiliates . All rights reserved . * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER . * * This code is free software ; you can redistribute it and / or modify it * under the terms of the GNU General Public License version 2 only , as * published by the Free Software Foundation . * * This code is distributed in the hope that it will be useful , but WITHOUT * ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License * version 2 for more details ( a copy is included in the LICENSE file that * accompanied this code ) . * * You should have received a copy of the GNU General Public License version * 2 along with this work ; if not , write to the Free Software Foundation , * Inc . , 51 Franklin St , Fifth Floor , Boston , MA 02110 - 1301 USA . * * Please contact Oracle , 500 Oracle Parkway , Redwood Shores , CA 94065 USA * or visit www . oracle . com if you need additional information or have any * questions . * #ifdef COMPILE_CRYPTO// The Rijndael S-box and inverted S-box are embedded here for a faster access. // // Note about lookup tables (T1...T4 and T5..T8): // The tables (boxes) combine ahead-of-time precalculated transposition and mixing steps as // an alternative to a runtime calculation. // The tables are statically generated in com/sun/crypto/provider/AESCrypt class. // Only the first table reference is passed to AES methods below. The other 3 tables // in ecryption and decryption are calculated in runtime by rotating the T1 result accordingly. // It is a free operation on ARM with embedded register-shifted-register EOR capability. // The table reference is passed in a form of a last argument on the parameters list. // The tables lookup method proves to perform better than a runtime Galois Field calculation, // due to a lack of HW acceleration for the later. unsigned char * SBox;unsigned char * SInvBox;void aes_init() {const static unsigned char Si[256 ] =0 x52, 0 x09, 0 x6A, 0 xD5, 0 x30, 0 x36, 0 xA5, 0 x38,0 xBF, 0 x40, 0 xA3, 0 x9E, 0 x81, 0 xF3, 0 xD7, 0 xFB,0 x7C, 0 xE3, 0 x39, 0 x82, 0 x9B, 0 x2F, 0 xFF, 0 x87,0 x34, 0 x8E, 0 x43, 0 x44, 0 xC4, 0 xDE, 0 xE9, 0 xCB,0 x54, 0 x7B, 0 x94, 0 x32, 0 xA6, 0 xC2, 0 x23, 0 x3D,0 xEE, 0 x4C, 0 x95, 0 x0B, 0 x42, 0 xFA, 0 xC3, 0 x4E,0 x08, 0 x2E, 0 xA1, 0 x66, 0 x28, 0 xD9, 0 x24, 0 xB2,0 x76, 0 x5B, 0 xA2, 0 x49, 0 x6D, 0 x8B, 0 xD1, 0 x25,0 x72, 0 xF8, 0 xF6, 0 x64, 0 x86, 0 x68, 0 x98, 0 x16,0 xD4, 0 xA4, 0 x5C, 0 xCC, 0 x5D, 0 x65, 0 xB6, 0 x92,0 x6C, 0 x70, 0 x48, 0 x50, 0 xFD, 0 xED, 0 xB9, 0 xDA,0 x5E, 0 x15, 0 x46, 0 x57, 0 xA7, 0 x8D, 0 x9D, 0 x84,0 x90, 0 xD8, 0 xAB, 0 x00, 0 x8C, 0 xBC, 0 xD3, 0 x0A,0 xF7, 0 xE4, 0 x58, 0 x05, 0 xB8, 0 xB3, 0 x45, 0 x06,0 xD0, 0 x2C, 0 x1E, 0 x8F, 0 xCA, 0 x3F, 0 x0F, 0 x02,0 xC1, 0 xAF, 0 xBD, 0 x03, 0 x01, 0 x13, 0 x8A, 0 x6B,0 x3A, 0 x91, 0 x11, 0 x41, 0 x4F, 0 x67, 0 xDC, 0 xEA,0 x97, 0 xF2, 0 xCF, 0 xCE, 0 xF0, 0 xB4, 0 xE6, 0 x73,0 x96, 0 xAC, 0 x74, 0 x22, 0 xE7, 0 xAD, 0 x35, 0 x85,0 xE2, 0 xF9, 0 x37, 0 xE8, 0 x1C, 0 x75, 0 xDF, 0 x6E,0 x47, 0 xF1, 0 x1A, 0 x71, 0 x1D, 0 x29, 0 xC5, 0 x89,0 x6F, 0 xB7, 0 x62, 0 x0E, 0 xAA, 0 x18, 0 xBE, 0 x1B,0 xFC, 0 x56, 0 x3E, 0 x4B, 0 xC6, 0 xD2, 0 x79, 0 x20,0 x9A, 0 xDB, 0 xC0, 0 xFE, 0 x78, 0 xCD, 0 x5A, 0 xF4,0 x1F, 0 xDD, 0 xA8, 0 x33, 0 x88, 0 x07, 0 xC7, 0 x31,0 xB1, 0 x12, 0 x10, 0 x59, 0 x27, 0 x80, 0 xEC, 0 x5F,0 x60, 0 x51, 0 x7F, 0 xA9, 0 x19, 0 xB5, 0 x4A, 0 x0D,0 x2D, 0 xE5, 0 x7A, 0 x9F, 0 x93, 0 xC9, 0 x9C, 0 xEF,0 xA0, 0 xE0, 0 x3B, 0 x4D, 0 xAE, 0 x2A, 0 xF5, 0 xB0,0 xC8, 0 xEB, 0 xBB, 0 x3C, 0 x83, 0 x53, 0 x99, 0 x61,0 x17, 0 x2B, 0 x04, 0 x7E, 0 xBA, 0 x77, 0 xD6, 0 x26,0 xE1, 0 x69, 0 x14, 0 x63, 0 x55, 0 x21, 0 x0C, 0 x7Dstatic const unsigned char S[256 ]={0 x63, 0 x7C, 0 x77, 0 x7B, 0 xF2, 0 x6B, 0 x6F, 0 xC5,0 x30, 0 x01, 0 x67, 0 x2B, 0 xFE, 0 xD7, 0 xAB, 0 x76,0 xCA, 0 x82, 0 xC9, 0 x7D, 0 xFA, 0 x59, 0 x47, 0 xF0,0 xAD, 0 xD4, 0 xA2, 0 xAF, 0 x9C, 0 xA4, 0 x72, 0 xC0,0 xB7, 0 xFD, 0 x93, 0 x26, 0 x36, 0 x3F, 0 xF7, 0 xCC,0 x34, 0 xA5, 0 xE5, 0 xF1, 0 x71, 0 xD8, 0 x31, 0 x15,0 x04, 0 xC7, 0 x23, 0 xC3, 0 x18, 0 x96, 0 x05, 0 x9A,0 x07, 0 x12, 0 x80, 0 xE2, 0 xEB, 0 x27, 0 xB2, 0 x75,0 x09, 0 x83, 0 x2C, 0 x1A, 0 x1B, 0 x6E, 0 x5A, 0 xA0,0 x52, 0 x3B, 0 xD6, 0 xB3, 0 x29, 0 xE3, 0 x2F, 0 x84,0 x53, 0 xD1, 0 x00, 0 xED, 0 x20, 0 xFC, 0 xB1, 0 x5B,0 x6A, 0 xCB, 0 xBE, 0 x39, 0 x4A, 0 x4C, 0 x58, 0 xCF,0 xD0, 0 xEF, 0 xAA, 0 xFB, 0 x43, 0 x4D, 0 x33, 0 x85,0 x45, 0 xF9, 0 x02, 0 x7F, 0 x50, 0 x3C, 0 x9F, 0 xA8,0 x51, 0 xA3, 0 x40, 0 x8F, 0 x92, 0 x9D, 0 x38, 0 xF5,0 xBC, 0 xB6, 0 xDA, 0 x21, 0 x10, 0 xFF, 0 xF3, 0 xD2,0 xCD, 0 x0C, 0 x13, 0 xEC, 0 x5F, 0 x97, 0 x44, 0 x17,0 xC4, 0 xA7, 0 x7E, 0 x3D, 0 x64, 0 x5D, 0 x19, 0 x73,0 x60, 0 x81, 0 x4F, 0 xDC, 0 x22, 0 x2A, 0 x90, 0 x88,0 x46, 0 xEE, 0 xB8, 0 x14, 0 xDE, 0 x5E, 0 x0B, 0 xDB,0 xE0, 0 x32, 0 x3A, 0 x0A, 0 x49, 0 x06, 0 x24, 0 x5C,0 xC2, 0 xD3, 0 xAC, 0 x62, 0 x91, 0 x95, 0 xE4, 0 x79,0 xE7, 0 xC8, 0 x37, 0 x6D, 0 x8D, 0 xD5, 0 x4E, 0 xA9,0 x6C, 0 x56, 0 xF4, 0 xEA, 0 x65, 0 x7A, 0 xAE, 0 x08,0 xBA, 0 x78, 0 x25, 0 x2E, 0 x1C, 0 xA6, 0 xB4, 0 xC6,0 xE8, 0 xDD, 0 x74, 0 x1F, 0 x4B, 0 xBD, 0 x8B, 0 x8A,0 x70, 0 x3E, 0 xB5, 0 x66, 0 x48, 0 x03, 0 xF6, 0 x0E,0 x61, 0 x35, 0 x57, 0 xB9, 0 x86, 0 xC1, 0 x1D, 0 x9E,0 xE1, 0 xF8, 0 x98, 0 x11, 0 x69, 0 xD9, 0 x8E, 0 x94,0 x9B, 0 x1E, 0 x87, 0 xE9, 0 xCE, 0 x55, 0 x28, 0 xDF,0 x8C, 0 xA1, 0 x89, 0 x0D, 0 xBF, 0 xE6, 0 x42, 0 x68,0 x41, 0 x99, 0 x2D, 0 x0F, 0 xB0, 0 x54, 0 xBB, 0 x16unsigned char *)S;unsigned char *)Si;this , "StubRoutines" , "aesencryptBlock" );// Register from = R0; // source byte array // Register to = R1; // destination byte array // Register key = R2; // expanded key array // Register tbox = R3; // transposition box reference 4 ));32 );// preserve TBox references 16 ));// retrieve key length. The length is used to determine the number of subsequent rounds (10, 12 or 14) fset_in_bytes(T_INT)));4 , post_indexed));4 ));4 , post_indexed));8 ));4 , post_indexed));12 ));4 , post_indexed));// Store the key size; However before doing that adjust the key to compensate for the Initial and Last rounds 8 );// load first transporistion box (T1) 16 ));// Utilize a Transposition Box lookup along with subsequent shift and EOR with a round key. // instructions ordering is rearranged to minimize ReadAferWrite dependency. Not that important on A15 target // with register renaming but performs ~10% better on A9. 24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));0 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));// update round count 4 );0 ));// last round - a special case, no MixColumn int )SBox);// output buffer pointer 4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));32 );4 ));return start;this , "StubRoutines" , "aesdecryptBlock" );// Register from = R0; // source byte array // Register to = R1; // destination byte array // Register key = R2; // expanded key array // Register tbox = R3; // transposition box reference 4 ));32 );// retrieve key length fset_in_bytes(T_INT)));// preserve TBox references 16 ));// Preserve the expanded key pointer // The first key round is applied to the last round 16 );4 , post_indexed));4 ));4 , post_indexed));8 ));4 , post_indexed));12 ));4 , post_indexed));// Store the key size; However before doing that adjust the key to compensate for the Initial and Last rounds 8 );// load transporistion box (T5) 16 ));// each sub-block is treated similarly: // combine SubBytes|ShiftRows|MixColumn through a precalculated set of tables // Utilize a Transposition Box lookup along with subsequent shift and EOR with a round key. // instructions ordering is rearranged to minimize ReadAferWrite dependency. Not that important on A15 target // with register renaming but performs ~10% better on A9. 24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));0 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));// update round count 4 );0 ));// last round - a special case, no MixColumn: // Retrieve expanded key pointer int )SInvBox);// output buffer pointer // process each sub-block in a similar manner: // 1. load a corresponding round key 4 , post_indexed));// 2. combine SubBytes and ShiftRows stages 24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));// 3. AddRoundKey stage // 4. convert the result to LE representation // 5. store in the output buffer 4 , post_indexed));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));32 );4 ));return start;// R0 - plain // R1 - cipher // R2 - expanded key // R3 - Initialization Vector (IV) // [sp+0] - cipher len // [sp+4] Transposition Box reference this , "StubRoutines" , "cipherBlockChaining_encryptAESCrypt" );// load cipher length (which is first element on the original calling stack) 40 ));32 );// preserve some arguments // load IV // preserve original source buffer on stack 16 ));40 +32 +4 ));// near call is sufficient since the target is also in the stubs 16 );16 ), gt);16 , gt);16 ), gt);32 );// return cipher len (copied from the original argument) return start;// The CBC decryption could benefit from parallel processing as the blocks could be // decrypted separately from each other. // NEON is utilized (if available) to perform parallel execution on 8 blocks at a time. // Since Transposition Box (tbox) is used the parallel execution will only apply to an // Initial Round and the last round. It's not practical to use NEON for a table lookup // larger than 128 bytes. It also appears to be faster performing tbox lookup // sequentially then execute Galois Field calculation in parallel. this , "StubRoutines" , "cipherBlockChaining_decryptAESCrypt" );// R0 - cipher // R1 - plain // R2 - expanded key // R3 - Initialization Vector (iv) // [sp+0] - cipher len // [sp+4] - Transpotition Box reference // load cipher len: must be modulo 16 40 ));if (VM_Version::has_simd()) {0 x7f);// preserve registers based arguments if (VM_Version::has_simd()) {// preserve args // reload arguments 40 +4 ));// near call is sufficient as the method is part of the StubGenerator // check remaining cipher size (for individual block processing) 16 );if (VM_Version::has_simd()) {0 x7f);// load IV (changes based on a CBC schedule) // load plaintext from the previous block processing // perform IV addition and save the plaintext for good now // adjust pointers for next block processing 16 );16 );if (!VM_Version::has_simd()) {else {// done with single blocks. // check if any 8 block chunks are available for parallel processing 40 ));0 x7f);int quad = 1 ;// Process 8 blocks in parallel 8 ));40 );// record output buffer end address (used as a block counter) 16 );// preserve key pointer 28 );// in decryption the first 16 bytes of expanded key are used in the last round 16 );// Record the end of the key which is used to indicate a last round fset_in_bytes(T_INT)));2 ));// preserve IV 36 );// preserve original source pointer 32 );// Apply ShiftRow for 8 block at once: // use output buffer for a temp storage to preload it into cache 0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);// Local frame map: // sp+20 - output buffer pointer // sp+28 - key pointer // sp+32 - original source // sp+36 - block counter // preserve output buffer pointer 20 );// individual rounds in block processing are executed sequentially . // record end of the output buffer 128 );12 ));// load transporistion box reference (T5) // location of the reference (6th incoming argument, second slot on the stack): // 10 scalar registers on stack // 8 double-precision FP registers // 40 bytes frame size for local storage // 4 bytes offset to the original arguments list 40 +64 +40 +4 ));// load rounds key and compensate for the first and last rounds 32 );// load block data out buffer // Utilize a Transposition Box lookup along with subsequent shift and EOR with a round key. // instructions ordering is rearranged to minimize ReadAferWrite dependency. Not that important on A15 target // with register renaming but performs ~10% better on A9. 24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));0 ));24 ));16 , 8 );2 ));2 ));8 , 8 );8 ));2 ));2 ));4 , post_indexed));16 ));24 ));// see if we reached the key array end // load processed data 0 ));// last round is special // this round could be implemented through vtbl instruction in NEON. However vtbl is limited to a 32-byte wide table (4 vectors), // thus it requires 8 lookup rounds to cover 256-byte wide Si table. On the other hand scalar lookup is independent of the // lookup table size and thus proves to be faster. // cipher counter 12 ));int )SInvBox);24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));24 ));16 , 8 );8 ));8 , 8 );8 ));8 ));4 , post_indexed));// preserve current scratch buffer pointer // go to the next block processing // Perform last round AddRoundKey state on all 8 blocks // load key pointer (remember that [sp+24] points to a byte #32 at the key array) // last round is processed with the key[0 ..3] // retireve original output buffer pointer 128 );// retrieve original cipher (source) pointer // retrieve IV (second argument on stack) 32 , MacroAssembler::VELEM_SIZE_8);// perform last AddRoundKey and IV addition 0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);32 , MacroAssembler::VELEM_SIZE_8);0 , post_indexed), MacroAssembler::VELEM_SIZE_8, MacroAssembler::VLD1_TYPE_2_REGS);// check if we're done 128 -16 );16 );40 );8 ));return start;#endif // USE_CRYPTO
Messung V0.5 in Prozent C=97 H=99 G=97
¤ Dauer der Verarbeitung: 0.14 Sekunden
(vorverarbeitet am 2026-06-10)
¤ *© Formatika GbR, Deutschland
