/**
OFB decrypt
@param ct Ciphertext
@param pt [out] Plaintext
@param len Length of ciphertext (octets)
@param ofb OFB state
@return CRYPT_OK if successful
*/
int ofb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_OFB *ofb)
{
LTC_ARGCHK(pt != NULL);
LTC_ARGCHK(ct != NULL);
LTC_ARGCHK(ofb != NULL);
return ofb_encrypt(ct, pt, len, ofb);
}
static int
EncryptOFB(
int cipher,
int rounds,
int counterMode,
unsigned char *iv,
unsigned char *key,
unsigned long keyLength,
unsigned char *data,
unsigned long dataLength,
unsigned char *dest
)
{
int status;
symmetric_OFB state;
status = ofb_start(cipher, iv, key, keyLength, rounds, &state);
if (status == CRYPT_OK) {
status = ofb_encrypt(data, dest, dataLength, &state);
ofb_done(&state);
}
return status;
}
/*!
* \brief Main application function. \n
* -> Initialize clock \n
* -> Initialize USART for print functions \n
* -> Initialize AES to generate Key schedule for AES-128 \n
* -> Based on the AES mode enabled in conf_example.h file, \n
* execute encryption and decryption of a message and \n
* compare them against input data to check its functionality. \n
* -> The decrypted message can be viewed on the COM port terminal \n
*/
int main(void)
{
/*
* Initialize the System clock
* Note: Clock should be configured in conf_clock.h
*/
system_init();
/* Configure EDBG SERCOM UART to print messages */
configure_usart();
/* Generate key schedule for AES-128 from the Cipher Key */
aes_init(key_vectors);
/* Print status messages */
printf("AES key generated successfully!..\r\n");
/* Print Input message for user */
printf("\n The message to be encrypted is:\r\n");
printf("\n %s \r\n",pText);
/*
* Perform ECB, CFB, OFB, CTR and CBC Encryption and Decryption
* based on the mode enabled in conf_example.h. User can choose
* the mode that he wants to evaluate. By default, all modes are
* enabled.
* The decrypted message is printed to EDBG virtual COM port.
* If the decrypted message is same as the input plain text,
* it ensures the working of each mode.
*/
#if (AES_ECB == true)
//Perform ECB Encryption
ecb_encrypt( pText, cText, sizeof(pText) );
for (volatile int i = 0; i < 1000; i++);
//Perform ECB Decryption
ecb_decrypt( cText, pText1, sizeof(cText));
//Print decrypted message
printf("\n Decrypted message using AES-ECB mode : \r\n");
printf("\n %s \r\n",pText1);
#endif
#if (AES_CFB == true)
//Perform CFB Encryption
cfb_encrypt(pText, cText, init_vector, CFB_MODE_128, sizeof(pText));
for (volatile int i = 0; i < 1000; i++);
//Perform CFB Decryption
cfb_decrypt(cText, pText1, init_vector, CFB_MODE_128, sizeof(cText));
//Print decrypted message
printf("\n Decrypted message using AES-CFB mode : \r\n");
printf("\n %s \r\n",pText1);
#endif
#if (AES_OFB == true)
//Perform OFB Encryption
ofb_encrypt(pText, cText, init_vector, sizeof(pText));
for (volatile int i = 0; i < 1000; i++);
//Perform OFB Decryption
ofb_encrypt(cText, pText1, init_vector, sizeof(cText));
//Print decrytped message
printf("\n Decrypted message using AES-OFB mode : \r\n");
printf("\n %s \r\n",pText1);
#endif
#if (AES_CTR == true)
/* Initialize Counter block with initialization vector,
* nonce and counter value
*/
ctr_blk_t counter_vector = {
.i_vector = AES_CTR_IVECTOR,
.nonce = AES_CTR_NONCE,
.counter = AES_CTR_COUNTER
};
//Perform CTR Encryption
ctr_encrypt_decrypt(pText, cText, &counter_vector, sizeof(pText));
//Send Counter block value to decryptor
for (volatile int i = 0; i < 1000; i++);
counter_vector.i_vector = AES_CTR_IVECTOR;
counter_vector.nonce = AES_CTR_NONCE;
counter_vector.counter = AES_CTR_COUNTER;
//Perform CTR Decryption
ctr_encrypt_decrypt(cText, pText1, &counter_vector, sizeof(pText1));
//Print decrypted message
printf("\n Decrypted message using AES-CTR mode : \r\n");
printf("\n %s \r\n",pText1);
#endif
/*! \warning CBC mode is done at the last as it process input plain text
* during encryption and so the plain text value is not retained.
* For testing purpose, to preserve the input plan text for testing with
* other modes, this mode is added at the last.
*/
#if (AES_CBC == true)
//Perform CBC Encryption
cbc_encrypt(pText, cText, init_vector, sizeof(pText));
for (volatile int i = 0; i < 1000; i++);
//Perform CBC Decryption
cbc_decrypt(cText, pText1, init_vector, sizeof(cText));
//Print decrypted message
printf("\n Decrypted message using AES-CBC mode : \r\n");
printf("\n %s \r\n",pText1);
#endif
/* Forever loop */
while(1);
}
int modes_test(void)
{
unsigned char pt[64], ct[64], tmp[64], key[16], iv[16], iv2[16];
int cipher_idx;
#ifdef LTC_CBC_MODE
symmetric_CBC cbc;
#endif
#ifdef LTC_CFB_MODE
symmetric_CFB cfb;
#endif
#ifdef LTC_OFB_MODE
symmetric_OFB ofb;
#endif
unsigned long l;
/* make a random pt, key and iv */
yarrow_read(pt, 64, &yarrow_prng);
yarrow_read(key, 16, &yarrow_prng);
yarrow_read(iv, 16, &yarrow_prng);
/* get idx of AES handy */
cipher_idx = find_cipher("aes");
if (cipher_idx == -1) {
fprintf(stderr, "test requires AES");
return 1;
}
#ifdef LTC_F8_MODE
DO(f8_test_mode());
#endif
#ifdef LTC_LRW_MODE
DO(lrw_test());
#endif
#ifdef LTC_CBC_MODE
/* test CBC mode */
/* encode the block */
DO(cbc_start(cipher_idx, iv, key, 16, 0, &cbc));
l = sizeof(iv2);
DO(cbc_getiv(iv2, &l, &cbc));
if (l != 16 || memcmp(iv2, iv, 16)) {
fprintf(stderr, "cbc_getiv failed");
return 1;
}
DO(cbc_encrypt(pt, ct, 64, &cbc));
/* decode the block */
DO(cbc_setiv(iv2, l, &cbc));
zeromem(tmp, sizeof(tmp));
DO(cbc_decrypt(ct, tmp, 64, &cbc));
if (memcmp(tmp, pt, 64) != 0) {
fprintf(stderr, "CBC failed");
return 1;
}
#endif
#ifdef LTC_CFB_MODE
/* test CFB mode */
/* encode the block */
DO(cfb_start(cipher_idx, iv, key, 16, 0, &cfb));
l = sizeof(iv2);
DO(cfb_getiv(iv2, &l, &cfb));
/* note we don't memcmp iv2/iv since cfb_start processes the IV for the first block */
if (l != 16) {
fprintf(stderr, "cfb_getiv failed");
return 1;
}
DO(cfb_encrypt(pt, ct, 64, &cfb));
/* decode the block */
DO(cfb_setiv(iv, l, &cfb));
zeromem(tmp, sizeof(tmp));
DO(cfb_decrypt(ct, tmp, 64, &cfb));
if (memcmp(tmp, pt, 64) != 0) {
fprintf(stderr, "CFB failed");
return 1;
}
#endif
#ifdef LTC_OFB_MODE
/* test OFB mode */
/* encode the block */
DO(ofb_start(cipher_idx, iv, key, 16, 0, &ofb));
l = sizeof(iv2);
DO(ofb_getiv(iv2, &l, &ofb));
if (l != 16 || memcmp(iv2, iv, 16)) {
fprintf(stderr, "ofb_getiv failed");
return 1;
}
DO(ofb_encrypt(pt, ct, 64, &ofb));
/* decode the block */
DO(ofb_setiv(iv2, l, &ofb));
zeromem(tmp, sizeof(tmp));
DO(ofb_decrypt(ct, tmp, 64, &ofb));
if (memcmp(tmp, pt, 64) != 0) {
fprintf(stderr, "OFB failed");
return 1;
}
#endif
#ifdef LTC_CTR_MODE
DO(ctr_test());
#endif
return 0;
}
int modes_test(void)
{
unsigned char pt[64], ct[64], tmp[64], key[16], iv[16], iv2[16];
int x, cipher_idx;
symmetric_CBC cbc;
symmetric_CFB cfb;
symmetric_OFB ofb;
symmetric_CTR ctr;
unsigned long l;
/* make a random pt, key and iv */
yarrow_read(pt, 64, &test_yarrow);
yarrow_read(key, 16, &test_yarrow);
yarrow_read(iv, 16, &test_yarrow);
/* get idx of AES handy */
cipher_idx = find_cipher("aes");
if (cipher_idx == -1) {
printf("test requires AES");
return 1;
}
/* test CBC mode */
/* encode the block */
DO(cbc_start(cipher_idx, iv, key, 16, 0, &cbc));
l = sizeof(iv2);
DO(cbc_getiv(iv2, &l, &cbc));
if (l != 16 || memcmp(iv2, iv, 16)) {
printf("cbc_getiv failed");
return 1;
}
for (x = 0; x < 4; x++) {
DO(cbc_encrypt(pt+x*16, ct+x*16, &cbc));
}
/* decode the block */
DO(cbc_setiv(iv2, l, &cbc));
zeromem(tmp, sizeof(tmp));
for (x = 0; x < 4; x++) {
DO(cbc_decrypt(ct+x*16, tmp+x*16, &cbc));
}
if (memcmp(tmp, pt, 64) != 0) {
printf("CBC failed");
return 1;
}
/* test CFB mode */
/* encode the block */
DO(cfb_start(cipher_idx, iv, key, 16, 0, &cfb));
l = sizeof(iv2);
DO(cfb_getiv(iv2, &l, &cfb));
/* note we don't memcmp iv2/iv since cfb_start processes the IV for the first block */
if (l != 16) {
printf("cfb_getiv failed");
return 1;
}
DO(cfb_encrypt(pt, ct, 64, &cfb));
/* decode the block */
DO(cfb_setiv(iv, l, &cfb));
zeromem(tmp, sizeof(tmp));
DO(cfb_decrypt(ct, tmp, 64, &cfb));
if (memcmp(tmp, pt, 64) != 0) {
printf("CFB failed");
return 1;
}
/* test OFB mode */
/* encode the block */
DO(ofb_start(cipher_idx, iv, key, 16, 0, &ofb));
l = sizeof(iv2);
DO(ofb_getiv(iv2, &l, &ofb));
if (l != 16 || memcmp(iv2, iv, 16)) {
printf("ofb_getiv failed");
return 1;
}
DO(ofb_encrypt(pt, ct, 64, &ofb));
/* decode the block */
DO(ofb_setiv(iv2, l, &ofb));
zeromem(tmp, sizeof(tmp));
DO(ofb_decrypt(ct, tmp, 64, &ofb));
if (memcmp(tmp, pt, 64) != 0) {
printf("OFB failed");
return 1;
}
/* test CTR mode */
/* encode the block */
DO(ctr_start(cipher_idx, iv, key, 16, 0, &ctr));
l = sizeof(iv2);
DO(ctr_getiv(iv2, &l, &ctr));
if (l != 16 || memcmp(iv2, iv, 16)) {
printf("ctr_getiv failed");
return 1;
}
DO(ctr_encrypt(pt, ct, 64, &ctr));
/* decode the block */
DO(ctr_setiv(iv2, l, &ctr));
zeromem(tmp, sizeof(tmp));
DO(ctr_decrypt(ct, tmp, 64, &ctr));
if (memcmp(tmp, pt, 64) != 0) {
printf("CTR failed");
return 1;
}
return 0;
}