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); }
int aes_setup_decrypt(unsigned char *key, unsigned char *round_keys, int keybits) { if(keybits != 128) panic(0, "AES doesn't support non-128 keylength"); #if CONFIG_ARCH == TYPE_ARCH_X86_64 if(has_intel_aes) { unsigned char tmp_round_keys[RKBYTES(keybits)]; aes_x86_128_key_expand(key, tmp_round_keys); aes_x86_128_key_inv_transform(tmp_round_keys, round_keys); return 10; } #endif return rijndaelSetupDecrypt((uint32_t *)round_keys, key, keybits); }
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_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); }
void aes_pre_dec(uint32 bits, byte *key, byte *chain) { nrounds = rijndaelSetupDecrypt(rk, key, bits); memset(chain, 0, 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; }