void rijndael256Encrypt(const char *plaindata, unsigned char password[KEYLENGTH(KEYBITS)], unsigned char cipherdata[]) { unsigned long rk[RKLENGTH(KEYBITS)]; unsigned char key[KEYLENGTH(KEYBITS)]; int nrounds; for (int i = 0; i < sizeof(key); i++) key[i] = *password != 0 ? *password++ : 0; // Add PKCS7 padding. unsigned long data_len = strlen(plaindata); unsigned char new_plaindata[data_len]; memcpy(new_plaindata, plaindata, data_len); unsigned int pad = 16 - (data_len%16); int y = 0; for (; y < pad; new_plaindata[data_len + y++] = (char)pad); new_plaindata[data_len + y + 1] = 0; data_len = data_len + y; nrounds = rijndaelSetupEncrypt(rk, key, KEYBITS); unsigned char iv[16]; for (int i = 0; i < sizeof(iv); i++) { iv[i] = 0; } for (int i = 0; i < data_len/16; i++) { unsigned char plainblock[16]; unsigned char cipherblock[16]; for (int j = 0; j < sizeof(plainblock); j++) { plainblock[j] = new_plaindata[i*16+j] ^ iv[j]; } rijndaelEncrypt(rk, nrounds, plainblock, cipherblock); for (int k = 0; k < sizeof(cipherblock); k++) { cipherdata[i*16+k] = iv[k] = cipherblock[k]; } } }
int main(int argc, char **argv) { unsigned long rk[RKLENGTH(KEYBITS)]; unsigned char key[KEYLENGTH(KEYBITS)]; int i; int nrounds; char *password; FILE *input; if (argc < 3) { fputs("Missing argument", stderr); return 1; } password = argv[1]; for (i = 0; i < sizeof(key); i++) key[i] = *password != 0 ? *password++ : 0; input = fopen(argv[2], "rb"); if (input == NULL) { fputs("File read error", stderr); return 1; } nrounds = rijndaelSetupDecrypt(rk, key, 256); while (1) { unsigned char plaintext[16]; unsigned char ciphertext[16]; int j; if (fread(ciphertext, sizeof(ciphertext), 1, input) != 1) break; rijndaelDecrypt(rk, nrounds, ciphertext, plaintext); fwrite(plaintext, sizeof(plaintext), 1, stdout); } fclose(input); }
void Crypt::DecryptAES128ECB(unsigned char * key, unsigned char const* cipherTextIn, unsigned char* plainTextOut) { unsigned long rk[RKLENGTH(KEYBITS)]; int nrounds; nrounds = rijndaelSetupDecrypt(rk, key, KEYBITS); rijndaelDecrypt(rk, nrounds, cipherTextIn, plainTextOut); }
rijndaelcbc *rijndaelcbc_init(unsigned char *key, int keybits, unsigned char *iv, int decrypt) { rijndaelcbc *ret = (rijndaelcbc *)malloc(sizeof(rijndaelcbc) + RKLENGTH(keybits) * sizeof(unsigned long)); if(!ret) return NULL; memcpy(ret->prevblock, iv, 16); if(decrypt) { ret->nrounds = rijndaelSetupDecrypt(ret->rk, key, keybits); } else { ret->nrounds = rijndaelSetupEncrypt(ret->rk, key, keybits); } return ret; }
char *snippet_encrypt(const char *plain_text, const char *password) { unsigned long rk[RKLENGTH(KEYBITS)]; unsigned char key[KEYLENGTH(KEYBITS)]; int i; int nrounds; for (i = 0; i < sizeof(key); i++) { key[i] = *password != 0 ? *password++ : 0; } nrounds = rijndaelSetupEncrypt(rk, key, KEYBITS); char **blocks = __snippet_split_to_blocks(plain_text); __snippet_encrypt_blocks(rk, nrounds, blocks); return NULL; }
char *snippet_decrypt(const char *cipher_text, const char *password) { unsigned long rk[RKLENGTH(KEYBITS)]; unsigned char key[KEYLENGTH(KEYBITS)]; int i; int nrounds; for (i = 0; i < sizeof(key); i++) { key[i] = *password != 0 ? *password++ : 0; } nrounds = rijndaelSetupDecrypt(rk, key, KEYBITS); char *plain_text = (char *)malloc(sizeof(char) * strlen(cipher_text)); rijndaelDecrypt(rk, nrounds, cipher_text, plain_text); return plain_text; }
void rijndael256Decrypt(const char *cipherdata, unsigned char password[KEYLENGTH(KEYBITS)], unsigned char plaindata[]) { unsigned long rk[RKLENGTH(KEYBITS)]; unsigned char key[KEYLENGTH(KEYBITS)]; int nrounds; for (int i = 0; i < sizeof(key); i++) key[i] = *password != 0 ? *password++ : 0; unsigned long data_len = strlen(cipherdata); nrounds = rijndaelSetupDecrypt(rk, key, KEYBITS); unsigned char iv[16]; for (int i = 0; i < sizeof(iv); i++) { iv[i] = 0; } unsigned char tmp_plaindata[data_len]; for (int i = 0; i < data_len/16; i++) { unsigned char plainblock[16]; unsigned char cipherblock[16]; for (int j = 0; j < sizeof(cipherblock); j++) { cipherblock[j] = cipherdata[i*16+j]; } rijndaelDecrypt(rk, nrounds, cipherblock, plainblock); for (int k = 0; k < sizeof(plainblock); k++) { tmp_plaindata[i*16+k] = plainblock[k] ^ iv[k]; iv[k] = cipherblock[k]; } } // Strip PKCS7 padding. unsigned int padding = 1; unsigned int pad = tmp_plaindata[data_len - 1]; for (int i = 0; i < pad; i++) { if ((unsigned int)tmp_plaindata[data_len - i - 1] != pad) { padding = 0; break; } } if (padding == 1) { data_len = data_len - pad; } memcpy(plaindata, tmp_plaindata, data_len); plaindata[data_len] = 0; }
void CAES::setKey(const char *pszKey, const unsigned int uiKeyType) { size_t iRKLens(RKLENGTH(uiKeyType)); size_t iKeyLens(KEYLENGTH(uiKeyType)); m_pEncodeRK = new(std::nothrow) unsigned long[iRKLens + 1]; H_ASSERT(NULL != m_pEncodeRK, "malloc memory error."); H_Zero(m_pEncodeRK, iRKLens + 1); m_pDecodeRK = new(std::nothrow) unsigned long[iRKLens + 1]; H_ASSERT(NULL != m_pDecodeRK, "malloc memory error."); H_Zero(m_pDecodeRK, iRKLens + 1); unsigned char * pKey = new(std::nothrow) unsigned char[iKeyLens + 1]; H_ASSERT(NULL != pKey, "malloc memory error."); H_Zero(pKey, iKeyLens + 1); memcpy(pKey, pszKey, strlen(pszKey) > iKeyLens ? iKeyLens : strlen(pszKey)); m_iEncodeRounds = rijndaelSetupEncrypt(m_pEncodeRK, pKey, uiKeyType); m_iDecodeRounds = rijndaelSetupDecrypt(m_pDecodeRK, pKey, uiKeyType); H_SafeDelArray(pKey); }
static void sm_s1(key_t k, key_t r1, key_t r2, key_t s1){ key_t r_prime; memcpy(&r_prime[0], r2, 8); memcpy(&r_prime[8], r1, 8); key_t r_flipped; swap128(r_prime, r_flipped); printf("r': "); hexdump(r_flipped, 16); key_t tk_flipped; swap128(sm_tk, tk_flipped); printf("tk' "); hexdump(tk_flipped, 16); // setup aes decryption unsigned long rk[RKLENGTH(KEYBITS)]; int nrounds = rijndaelSetupEncrypt(rk, &tk_flipped[0], KEYBITS); key_t s1_flipped; rijndaelEncrypt(rk, nrounds, r_flipped, s1_flipped); printf("s1' "); hexdump(s1_flipped, 16); swap128(s1_flipped, s1); printf("s1: "); hexdump(s1, 16); }
void aes128_calc_cyphertext(uint8_t key[16], uint8_t plaintext[16], uint8_t cyphertext[16]){ uint32_t rk[RKLENGTH(KEYBITS)]; int nrounds = rijndaelSetupEncrypt(rk, &key[0], KEYBITS); rijndaelEncrypt(rk, nrounds, plaintext, cyphertext); }
128-bit key "00010203050607080A0B0C0D0F101112", and an input "506812A45F08C889B97F5980038B8359", the cipher should be "D8F532538289EF7D06B506A4FD5BE9C9". */ static params_t params; int read_ticks; int write_ticks; int aes_enc_ticks; int encrypt_ticks; int encrypt_bytes; int total_ticks; int nrounds; unsigned long rk[RKLENGTH(AESBITS)]; void aes_pre_enc(uint32 bits, byte *key, byte *chain) { int ms; ms = ticks; nrounds = rijndaelSetupEncrypt(rk, key, bits); memset(chain, 0, 16); aes_enc_ticks += ticks-ms; } void aes_enc(byte chain[16], int iolen, byte *plain) {
static void sm_c1(key_t k, key_t r, uint8_t preq[7], uint8_t pres[7], uint8_t iat, uint8_t rat, bd_addr_t ia, bd_addr_t ra, key_t c1){ // p1 = pres || preq || rat’ || iat’ // "The octet of iat’ becomes the least significant octet of p1 and the most signifi- // cant octet of pres becomes the most significant octet of p1. // For example, if the 8-bit iat’ is 0x01, the 8-bit rat’ is 0x00, the 56-bit preq // is 0x07071000000101 and the 56 bit pres is 0x05000800000302 then // p1 is 0x05000800000302070710000001010001." key_t p1_flipped; swap56(pres, &p1_flipped[0]); swap56(preq, &p1_flipped[7]); p1_flipped[14] = rat; p1_flipped[15] = iat; printf("p1' "); hexdump(p1_flipped, 16); // p2 = padding || ia || ra // "The least significant octet of ra becomes the least significant octet of p2 and // the most significant octet of padding becomes the most significant octet of p2. // For example, if 48-bit ia is 0xA1A2A3A4A5A6 and the 48-bit ra is // 0xB1B2B3B4B5B6 then p2 is 0x00000000A1A2A3A4A5A6B1B2B3B4B5B6. key_t p2_flipped; memset(p2_flipped, 0, 16); memcpy(&p2_flipped[4], ia, 6); memcpy(&p2_flipped[10], ra, 6); printf("p2' "); hexdump(p2_flipped, 16); // t1 = r xor p1 int i; key_t t1_flipped; for (i=0;i<16;i++){ t1_flipped[i] = r[15-i] ^ p1_flipped[i]; } printf("t1' "); hexdump(t1_flipped, 16); key_t tk_flipped; swap128(sm_tk, tk_flipped); printf("tk' "); hexdump(tk_flipped, 16); // setup aes decryption unsigned long rk[RKLENGTH(KEYBITS)]; int nrounds = rijndaelSetupEncrypt(rk, &tk_flipped[0], KEYBITS); // t2 = e(k, r_xor_p1) key_t t2_flipped; rijndaelEncrypt(rk, nrounds, t1_flipped, t2_flipped); printf("t2' "); hexdump(t2_flipped, 16); key_t t3_flipped; for (i=0;i<16;i++){ t3_flipped[i] = t2_flipped[i] ^ p2_flipped[i]; } printf("t3' "); hexdump(t3_flipped, 16); key_t c1_flipped; rijndaelEncrypt(rk, nrounds, t3_flipped, c1_flipped); printf("c1' "); hexdump(c1_flipped, 16); swap128(c1_flipped, c1); printf("c1: "); hexdump(c1, 16); }
crypto_cstring aesDecrypt(const char *data, const unsigned long dataLength, const char* password, unsigned long passwordLength) { assert(passwordLength == AES_KEYBYTE); int n = 0; if (dataLength / AES_BLOCKBYTE == dataLength * 1.0 / AES_BLOCKBYTE) n = dataLength / AES_BLOCKBYTE; else n = dataLength / AES_BLOCKBYTE + 1; crypto_cstring answer; answer.length = n * AES_BLOCKBYTE; answer.context = malloc(sizeof(char) * (answer.length) + 100); memcpy(answer.context, data, sizeof(char) * dataLength); unsigned long longi; for (longi = dataLength ; longi < (answer.length) ; ++longi) answer.context[longi] = '\0'; unsigned long rk[RKLENGTH(AES_KEYBIT)]; unsigned char key[KEYLENGTH(AES_KEYBIT)]; int i = 0; for (i = 0; i < sizeof(key); i++) key[i] = password != 0 ? *password++ : 0; int nrounds = rijndaelSetupDecrypt(rk, key, AES_KEYBIT); int index = 0; int lastIndex; while (1) { lastIndex = index; unsigned char plaintext[32]; unsigned char ciphertext[32]; int j; for (j = 0; j < 16; j++) { if (index >= answer.length) break; plaintext[j] = answer.context[index++]; } if (j == 0) break; for (; j < sizeof(plaintext); j++) plaintext[j] = '\0'; rijndaelDecrypt(rk, nrounds, plaintext, ciphertext); memcpy(answer.context + lastIndex, ciphertext, AES_BLOCKBYTE); } answer.length = ((uint64_t*) answer.context)[LENGTHPOSITION(answer.length)]; for (longi = dataLength - 1 ; i >= (answer.length) ; --i) answer.context[i] = '\0'; return answer; }