static int setup_openiboot() {
arm_setup();
mmu_setup();
tasks_setup();
setup_devices();
LeaveCriticalSection();
#ifndef CONFIG_IPHONE_4
clock_set_sdiv(0);
aes_setup();
nor_setup();
syscfg_setup();
images_setup();
nvram_setup();
lcd_setup();
framebuffer_setup();
audiohw_init();
#endif
isMultitouchLoaded = 0;
return 0;
}
/**
Initialize a Pelican state
@param pelmac The Pelican state to initialize
@param cipher The index of the desired cipher, must be AES
@param key The secret key
@param keylen The length of the secret key (octets)
@return CRYPT_OK if successful
*/
int pelican_init(pelican_state *pelmac, int cipher, const unsigned char *key, unsigned long keylen)
{
int index;
int err;
LTC_ARGCHK(pelmac != NULL);
LTC_ARGCHK(key != NULL);
index = find_cipher("aes");
if (cipher != index || index < 0) {
return CRYPT_INVALID_CIPHER;
}
#ifdef LTC_FAST
if (16 % sizeof(LTC_FAST_TYPE)) {
return CRYPT_INVALID_ARG;
}
#endif
if ((err = aes_setup(key, keylen, 0, &pelmac->K)) != CRYPT_OK) {
return err;
}
zeromem(pelmac->state, 16);
aes_ecb_encrypt(pelmac->state, pelmac->state, &pelmac->K);
pelmac->buflen = 0;
return CRYPT_OK;
}
static int setup_openiboot() {
arm_setup();
mmu_setup();
tasks_setup();
setup_devices();
LeaveCriticalSection();
clock_set_sdiv(0);
aes_setup();
nor_setup();
images_setup();
nvram_setup();
lcd_setup();
framebuffer_setup();
audiohw_init();
camera_setup();
return 0;
}
void platform_init()
{
arm_setup();
mmu_setup();
tasks_setup();
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
wdt_setup();
// Other devices
// uart_setup();
i2c_setup();
// dma_setup();
spi_setup();
LeaveCriticalSection();
aes_setup();
nor_setup();
syscfg_setup();
images_setup();
nvram_setup();
// lcd_setup();
framebuffer_hook(); // TODO: Remove once LCD implemented
framebuffer_setup();
// audiohw_init();
framebuffer_setdisplaytext(TRUE);
gpio_register_interrupt(BUTTONS_HOLD_IRQ, BUTTONS_HOLD_IRQTYPE, BUTTONS_HOLD_IRQLEVEL, BUTTONS_HOLD_IRQAUTOFLIP, gpio_test_handler, 0);
gpio_interrupt_enable(BUTTONS_HOLD_IRQ);
gpio_register_interrupt(BUTTONS_HOME_IRQ, BUTTONS_HOME_IRQTYPE, BUTTONS_HOME_IRQLEVEL, BUTTONS_HOME_IRQAUTOFLIP, gpio_test_handler, 1);
gpio_interrupt_enable(BUTTONS_HOME_IRQ);
gpio_register_interrupt(BUTTONS_VOLUP_IRQ, BUTTONS_VOLUP_IRQTYPE, BUTTONS_VOLUP_IRQLEVEL, BUTTONS_VOLUP_IRQAUTOFLIP, gpio_test_handler, 2);
gpio_interrupt_enable(BUTTONS_VOLUP_IRQ);
gpio_register_interrupt(BUTTONS_VOLDOWN_IRQ, BUTTONS_VOLDOWN_IRQTYPE, BUTTONS_VOLDOWN_IRQLEVEL, BUTTONS_VOLDOWN_IRQAUTOFLIP, gpio_test_handler, 3);
gpio_interrupt_enable(BUTTONS_VOLDOWN_IRQ);
}
static void run_tomcrypt_aes128(uint8_t *output,
const uint8_t *input, unsigned size)
{
symmetric_key aes;
unsigned i;
aes_setup(hardcoded_key, 16, 0, &aes);
size -= 15;
for (i = 0; i < size; i += 16)
aes_ecb_encrypt(input + i, output + i, &aes);
}
/*****************************************************************
* This function calculates the hash for the application.
* When this function returns successfully, the hash
* is written to hashOutput.
*
* Returns false if the operation failed. In this case
* the value of hashOutput should be ignored.
*****************************************************************/
bool calculateHash(uint8_t *startAddr, int length, uint8_t *hashOutput)
{
// Helper variables
int cryptError, i, j;
// This variable will always point to the current block
// to be decrypted
uint8_t *curBlock;
// Calculate the number of AES blocks
int aesBlocks = length / AES_BLOCKSIZE;
// Input buffer used to hold the input block to the
// encryption routine
uint8_t inputBlock[AES_BLOCKSIZE];
// Initialize key
symmetric_key skey;
cryptError = aes_setup(hashKey, HASH_KEY_SIZE, 0, &skey);
if ( cryptError != CRYPT_OK ) {
fprintf(stderr, "Error initializing crypto library\n");
return false;
}
// hashOutput will always contain the last encrypted block
// Initialize with the init vector for the first iteration
memcpy(hashOutput, hashInitVector, AES_BLOCKSIZE);
// Loop over all blocks
for ( i=0; i<aesBlocks; i++ ) {
// Get address of the current AES block
curBlock = startAddr + i * AES_BLOCKSIZE;
// XOR current block with previous cipher
for ( j=0; j<AES_BLOCKSIZE; j++ ) {
inputBlock[j] = curBlock[j] ^ hashOutput[j];
}
// Encrypt a block. Result is stored in hashOutput
cryptError = aes_ecb_encrypt(inputBlock, hashOutput, &skey);
if ( cryptError != CRYPT_OK ) {
fprintf(stderr, "Error during hash calculation\n");
return false;
}
}
// Success
return true;
}
/*****************************************************************
* Encrypt the entire firmware image (including header) with AES
* in CBC mode. The image is encrypted in place,
* when this function returns the buffer array will contain the
* encrypted image.
*****************************************************************/
bool encrypt(void)
{
// Helper variables
int cryptError, i, j;
// Compute number of AES blocks to encrypt
int aesBlocks = encryptedSize / AES_BLOCKSIZE;
// The pointer to the current block to be encrypted
uint8_t *curBlock;
// Pointer to the last encrypted block
// Initialize with the init vector
uint8_t *prevBlock = initVector;
// Initialize key
symmetric_key skey;
cryptError = aes_setup(encryptionKey, AES_KEY_SIZE, 0, &skey);
if ( cryptError != CRYPT_OK ) {
fprintf(stderr, "Error initializing crypto library\n");
return false;
}
// Loop over the entire image
for ( i=0; i<aesBlocks; i++ ) {
// Get address of the current AES block
curBlock = buffer + i * AES_BLOCKSIZE;
// XOR current block with the last encrypted block
for ( j=0; j<AES_BLOCKSIZE; j++ ) {
curBlock[j] = curBlock[j] ^ prevBlock[j];
}
// Encrypt block in place
cryptError = aes_ecb_encrypt(curBlock, curBlock, &skey);
// Store address of current block for next iteration
prevBlock = curBlock;
if ( cryptError != CRYPT_OK ) {
fprintf(stderr, "Error during encryption\n");
return false;
}
}
return true;
}
void platform_init()
{
arm_setup();
mmu_setup();
tasks_setup();
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
wdt_setup();
// Other devices
uart_setup();
i2c_setup();
// dma_setup();
spi_setup();
LeaveCriticalSection();
aes_setup();
displaypipe_init();
framebuffer_setup();
framebuffer_setdisplaytext(TRUE);
lcd_set_backlight_level(186);
// audiohw_init();
//TODO: remove
task_init(&iboot_loader_task, "iboot loader", TASK_DEFAULT_STACK_SIZE);
task_start(&iboot_loader_task, &iboot_loader_run, NULL);
}
static int load_root_pre(struct disk_root_sector *root, struct mem_tpm_mgr *dst)
{
int rc;
aes_setup(&dst->tm_key_e, &dst->tm_key);
rc = disk_read_crypt_sector(root, sizeof(*root), root_loc(dst), dst);
if (rc) {
vtpmloginfo(VTPM_LOG_VTPM, "root cmac verify failed in slot %d\n", dst->active_root);
return 2;
}
dst->root_seals_valid = 1 + dst->active_root;
dst->sequence = be64_native(root->v.sequence);
return 0;
}
void platform_init()
{
arm_setup();
mmu_setup();
tasks_setup();
// Basic prerequisites for everything else
miu_setup();
power_setup();
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
wdt_setup();
// Other devices
uart_setup();
i2c_setup();
dma_setup();
spi_setup();
LeaveCriticalSection();
clock_set_sdiv(0);
aes_setup();
lcd_setup();
framebuffer_setup();
audiohw_init();
framebuffer_setdisplaytext(TRUE);
}
int main(void)
{
uint8_t command;
serial_init();
trigger_setup();
aes_setup();
#ifdef DELAYS
random_setup();
#endif
while(1) {
command = usart_recv_byte();
switch(command) {
case 'e':
fill_buf();
random_setup();
encrypt();
send_buf();
break;
case 'd':
fill_buf();
random_setup();
decrypt();
send_buf();
break;
default:
continue;
}
}
return 0;
}
void platform_init()
{
arm_setup();
mmu_setup();
tasks_setup();
// Basic prerequisites for everything else
miu_setup();
power_setup();
//framebuffer_hook(); // TODO: Remove once LCD implemented -- Ricky26
//framebuffer_setdisplaytext(TRUE);
clock_setup();
// Need interrupts for everything afterwards
interrupt_setup();
gpio_setup();
// For scheduling/sleeping niceties
timer_setup();
event_setup();
// Other devices
dma_setup();
//usb_shutdown();
uart_setup();
i2c_setup();
spi_setup();
LeaveCriticalSection();
aes_setup();
}
void aes_key_wrap(UWORD8 *text, UWORD8 *key, UWORD32 n)
{
UWORD32 t = 0;
UWORD32 i = 0;
UWORD32 j = 0;
UWORD32 k = 0;
UWORD32 c = 0;
UWORD32 idx = 0;
UWORD16 curr_idx = 0;
UWORD8 *A = 0; //[8];
UWORD8 *B = 0; //[16];
UWORD8 *R[8] = {0}; //[8][100];
UWORD8 *Rbuff = NULL;
aes_context_t ctx = {{0},};
/* Save the current scratch memory index */
curr_idx = get_scratch_mem_idx();
/* Allocate scratch memory for the temporary variables */
A = (UWORD8 *)scratch_mem_alloc(8);
if(A == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return;
}
B = (UWORD8 *)scratch_mem_alloc(16);
if(B == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return;
}
Rbuff = (UWORD8 *)scratch_mem_alloc(8*100);
if(Rbuff == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return;
}
for(i = 0; i < 8; i ++)
{
R[i] = Rbuff + i*100;
}
/* AES initialization - Key scheduling */
ctx.nrounds = NUM_ROUNDS;
aes_setup(&ctx, 16, key);
/* 1) Initialize variables */
/* Set A = IV */
/* For i = 1 to n */
/* R[i] = P[i] */
for(k = 0; k < 8; k++)
A[k] = g_iv[k];
for(i = 0, idx = 0; i < n; i++)
for(k = 0; k < 8; k++)
R[k][i] = text[idx++];
/* 2) Compute intermediate values */
/* For j = 5 to 0 */
/* For i = 1 to n */
/* B = AES(K, A | R[i]) */
/* A = MSB(64, B) ^ t where t = (n*j)+i */
/* R[i] = LSB(64, B) */
for(j = 0; j <= 5; j++)
{
for(i = 0; i < n; i++)
{
UWORD8 temp128[16];
/* A | R[i] */
for(k = 0; k < 8; k ++)
temp128[k] = A[k];
for(k = 8, c = 0; k < 16 && c < 8; k++, c++)
temp128[k] = R[c][i];
/* B = AES(K, A | R[i] */
aes_encrypt(&ctx, temp128, B);
/* MSB(64, B) */
for(k = 0; k < 8; k++)
A[k] = B[k];
/* t does not need to be greater than 32 bits for allowed data */
/* lengths. Verify this. */
t = (n * j) + (i + 1);
/* A = MSB(64, B) ^ t where t = (n*j)+i */
for(k = 0; k < 4; k ++)
{
UWORD8 ptr = (UWORD8)(t >> (k << 3));
A[7 - k] = A[7 - k] ^ ptr;
}
/* R[i] = LSB(64, B) */
for(k = 0; k < 8; k++)
R[k][i] = B[k + 8];
}
}
/* 3) Output Results */
/* C[0] = A */
/* For i = 1 to n */
/* C[i] = R[i] */
for(k = 0; k < 8; k ++)
text[k] = A[k];
idx = 8;
for(i = 0; i < n; i++)
for(k = 0; k < 8; k ++)
text[idx++] = R[k][i];
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
}
static int load_root_post(struct mem_tpm_mgr *dst, const struct disk_root_sector *root)
{
int rc, i, j;
uint32_t nr_disk_rbs = be32_native(root->nr_rb_macs);
rc = TPM_disk_check_counter(dst->counter_index, dst->counter_auth,
root->v.tpm_counter_value);
if (rc)
return 2;
dst->counter_value = root->v.tpm_counter_value;
dst->nr_groups = be32_native(root->v.nr_groups);
dst->groups = calloc(sizeof(dst->groups[0]), dst->nr_groups);
if (!dst->groups) {
vtpmlogerror(VTPM_LOG_VTPM, "load_root_post alloc %x\n", dst->nr_groups);
return 2;
}
rc = load_verify_group_itree(dst, 0, dst->nr_groups,
root->v.group_hash, root->group_loc, NR_ENTRIES_PER_ROOT);
if (rc)
return rc;
/* Sanity check: group0 must be open */
if (!dst->groups[0].v) {
printk("Error opening group 0\n");
return 2;
}
/* TODO support for spilling rollback list */
if (nr_disk_rbs > NR_RB_MACS_PER_ROOT)
return 3;
i = 0;
j = 0;
while (i < dst->nr_groups) {
aes_context key_e;
struct mem_group_hdr *group = &dst->groups[i];
struct mem_group *groupv = group->v;
const struct disk_rb_mac_entry *ent = &root->rb_macs[j];
if (!groupv) {
i++;
// this group is not open - no need to verify now
continue;
}
if (be32_native(ent->id) < i) {
// this entry is for a group that is not open
j++;
continue;
}
if (j >= nr_disk_rbs || be32_native(ent->id) != i) {
// TODO allow delegation
if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) {
groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED;
group->disk_loc.value = 0;
}
i++;
continue;
}
aes_setup(&key_e, &groupv->rollback_mac_key);
if (aes_cmac_verify(&ent->mac, &root->v, sizeof(root->v), &key_e)) {
if (!(groupv->details.flags.value & FLAG_ROLLBACK_DETECTED)) {
groupv->details.flags.value |= FLAG_ROLLBACK_DETECTED;
group->disk_loc.value = 0;
}
}
i++; j++;
}
return 0;
}
/* Load and verify one group's data structure, including its vTPMs.
*/
static int load_verify_group(struct mem_group_hdr *dst, const struct mem_tpm_mgr *mgr)
{
struct mem_group *group;
struct disk_group_sector disk;
int rc;
aes_context key_e;
aes_context *opened_key = NULL;
disk_set_used(dst->disk_loc, mgr);
rc = disk_read_crypt_sector(&disk, sizeof(disk), dst->disk_loc, mgr);
if (rc) {
printk("Malformed sector %d\n", be32_native(dst->disk_loc));
return rc;
}
rc = sha256_verify(&dst->disk_hash, &disk.v, sizeof(disk.v) + sizeof(disk.group_mac));
if (rc) {
printk("Hash mismatch in sector %d\n", be32_native(dst->disk_loc));
return rc;
}
dst->v = group = calloc(1, sizeof(*group));
rc = find_group_key(group, &disk, mgr);
if (rc == 0) {
opened_key = &key_e;
/* Verify the group with the group's own key */
aes_setup(opened_key, &group->group_key);
if (aes_cmac_verify(&disk.group_mac, &disk.v, sizeof(disk.v), opened_key)) {
printk("Group CMAC failed\n");
return 2;
}
memcpy(&group->id_data, &disk.v.id_data, sizeof(group->id_data));
memcpy(&group->details, &disk.v.details, sizeof(group->details));
} else if (rc == 1) {
// still need to walk the vtpm list
rc = 0;
} else {
printk("Group key unsealing failed\n");
return rc;
}
group->nr_vtpms = be32_native(disk.v.nr_vtpms);
group->nr_pages = (group->nr_vtpms + VTPMS_PER_SECTOR - 1) / VTPMS_PER_SECTOR;
group->data = calloc(group->nr_pages, sizeof(group->data[0]));
rc = load_verify_vtpm_itree(dst, 0, group->nr_pages, disk.v.vtpm_hash,
disk.vtpm_location, NR_ENTRIES_PER_GROUP_BASE, mgr, opened_key);
if (!opened_key) {
/* remove the struct */
free(group->data);
free(group->seals);
free(group);
dst->v = NULL;
}
return rc;
}
int
main(int argc, char **argv)
{
symmetric_key skey;
int err;
/* Build the nonse */
uint8_t nonse[13];
uint8_t *ptr = nonse;
memcpy(ptr, addr, 8);
ptr += 8;
memcpy(ptr, (uint8_t *)&frame_ctr, 4);
ptr += 4;
memcpy(ptr, &sec_level, 1);
/* build the message */
memset(msg, 0, sizeof(msg));
msg[0] = 0xaa;
printf("VARIABLES\n");
printf("key: ");
print_buffer(key, sizeof(key));
printf("\n");
printf("nonse: ");
print_buffer(nonse, sizeof(nonse));
printf("\n");
printf("a: ");
print_buffer(hdr, sizeof(hdr));
printf("\n");
printf("\n");
register_cipher(&aes_desc);
err = aes_setup(key, 16, 0, &skey);
if (err != CRYPT_OK)
{
printf("setup failed with error %s\n", error_to_string(err));
return -1;
}
err = ccm_memory(find_cipher("aes"),
NULL, 0,
&skey,
nonse, 13,
hdr, sizeof(hdr),
msg, 2,
ct,
tag, &tag_len,
CCM_ENCRYPT);
if (err != CRYPT_OK)
{
printf("encryption failed with error %s\n", error_to_string(err));
return -1;
}
printf("ENCRYPTED\n");
printf("input: ");
print_buffer(msg, sizeof(msg));
printf("\n");
printf("output: ");
print_buffer(ct, sizeof(ct));
printf("\n");
printf("tag: ");
print_buffer(tag, tag_len);
printf("\n");
printf("\n");
memset(msg, 0xff, sizeof(msg));
memset(tag, 0xff, sizeof(tag));
memset(ct+2, 0x00, sizeof(ct)-2);
err = ccm_memory(find_cipher("aes"),
NULL, 0,
&skey,
nonse, 13,
hdr, sizeof(hdr),
msg, 2,
ct,
tag, &tag_len,
CCM_DECRYPT);
if (err != CRYPT_OK)
{
printf("encryption failed with error %s\n", error_to_string(err));
return -1;
}
printf("DECRYPTED\n");
printf("input: ");
print_buffer(ct, sizeof(ct));
printf("\n");
printf("output: ");
print_buffer(msg, sizeof(msg));
printf("\n");
printf("tag: ");
print_buffer(tag, tag_len);
printf("\n");
aes_done(&skey);
return 0;
}
BOOL_T aes_key_unwrap(UWORD8 *text, UWORD8 *key, UWORD32 n)
{
BOOL_T ret_val = BFALSE;
UWORD32 t = 0;
UWORD32 i = 0;
UWORD32 j = 0;
UWORD32 k = 0;
UWORD32 c = 0;
UWORD32 idx = 0;
UWORD16 curr_idx = 0;
UWORD8 *A = 0; //[8];
UWORD8 *B = 0; //[16];
UWORD8 *R[8] = {0}; //[8][100];
UWORD8 *Rbuff = NULL;
aes_context_t ctx = {{0},};
/* Save the current scratch memory index */
curr_idx = get_scratch_mem_idx();
/* Allocate scratch memory for the temporary variables */
A = (UWORD8 *)scratch_mem_alloc(8);
if(A == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return ret_val;
}
B = (UWORD8 *)scratch_mem_alloc(16);
if(B == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return ret_val;
}
Rbuff = (UWORD8 *)scratch_mem_alloc(8*100);
if(Rbuff == NULL)
{
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return ret_val;
}
for(i = 0; i < 8; i++)
{
R[i] = Rbuff + i*100;
}
/* AES initialization - Key scheduling */
ctx.nrounds = NUM_ROUNDS;
aes_setup(&ctx, 16, key);
/* 1) Initialize variables */
/* Set A = C[0] */
/* For i = 1 to n */
/* R[i] = C[i] */
idx = 0;
for(k = 0; k < 8; k++)
A[k] = text[idx++];
for(i = 0; i < n; i++)
for(k = 0; k < 8; k++)
R[k][i] = text[idx++];
/* 2) Compute intermediate values */
/* For j = 5 to 0 */
/* For i = n to 1 */
/* B = AES-1(K, (A ^ t) | R[i]) where t = n*j+i */
/* A = MSB(64, B) */
/* R[i] = LSB(64, B) */
for(j = 6; j > 0; j--)
{
for(i = n; i > 0; i--)
{
UWORD8 temp128[16];
/* t does not need to be greater than 32 bits for allowed data */
/* lengths. Verify this. */
t = (n * (j - 1)) + i;
/* (A ^ t) */
for(k = 0; k < 4; k ++)
{
UWORD8 ptr = (UWORD8)(t >> (k << 3));
A[7 - k] = A[7 - k] ^ ptr;
}
/* (A ^ t) | R[i] */
for(k = 0; k < 8; k ++)
temp128[k] = A[k];
for(k = 8, c = 0; k < 16 && c < 8; k++, c++)
temp128[k] = R[c][i - 1];
/* B = AES-1(K, (A ^ t) | R[i]) where t = n*j+i */
aes_decrypt(&ctx, temp128, B);
/* A = MSB(64, B) */
for(k = 0; k < 8; k++)
A[k] = B[k];
/* R[i] = LSB(64, B) */
for(k = 0; k < 8; k++)
R[k][i - 1] = B[k + 8];
}
}
/* 3) Output Results */
/* If A is an appropriate initial value, */
/* Then */
/* For i = 1 to n */
/* P[i] = R[i] */
/* Else */
/* Return an error */
if(memcmp(g_iv, A, 8) == 0)
{
idx = 0;
for(i = 1; i <= n; i++)
for(k = 0; k < 8; k ++)
text[idx++] = R[k][i - 1];
ret_val = BTRUE;
}
else
{
ret_val = BFALSE;
}
/* Restore the saved scratch memory index */
restore_scratch_mem_idx(curr_idx);
return ret_val;
}
int main(){
unsigned char key128[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
unsigned char key192[24] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17};
unsigned char key256[32] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
unsigned char ct[16];
unsigned char vt[16];
unsigned char pt[16] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
symmetric_key skey128;
symmetric_key skey192;
symmetric_key skey256;
/* AES 128 */
if (aes_setup(key128, 16, 10, &skey128) != CRYPT_OK){
printf("ERROR: in %s, unable to setup AES 128 key\n", __func__);
return 0;
}
if (aes_ecb_encrypt(pt, ct, &skey128) != CRYPT_OK){
printf("ERROR: in %s, unable to encrypt AES 128\n", __func__);
}
printf("Plaintext: ");
fprintBuffer_raw(stdout, (char*)pt, 16);
printf("\nKey 128: ");
fprintBuffer_raw(stdout, (char*)key128, 16);
printf("\nCiphertext 128: ");
fprintBuffer_raw(stdout, (char*)ct, 16);
if (aes_ecb_decrypt(ct, vt, &skey128) != CRYPT_OK){
printf("ERROR: in %s, unable to decrypt AES 128\n", __func__);
}
if (!memcmp(vt, pt, 16)){
printf("\nRecovery 128: OK\n");
}
else{
printf("\nRecovery 128: FAIL\n");
}
aes_done(&skey128);
/* AES 192 */
if (aes_setup(key192, 24, 12, &skey192) != CRYPT_OK){
printf("ERROR: in %s, unable to setup AES 192 key\n", __func__);
return 0;
}
if (aes_ecb_encrypt(pt, ct, &skey192) != CRYPT_OK){
printf("ERROR: in %s, unable to encrypt AES 192\n", __func__);
}
printf("Key 192: ");
fprintBuffer_raw(stdout, (char*)key192, 24);
printf("\nCiphertext 192: ");
fprintBuffer_raw(stdout, (char*)ct, 16);
if (aes_ecb_decrypt(ct, vt, &skey192) != CRYPT_OK){
printf("ERROR: in %s, unable to decrypt AES 192\n", __func__);
}
if (!memcmp(vt, pt, 16)){
printf("\nRecovery 192: OK\n");
}
else{
printf("\nRecovery 192: FAIL\n");
}
aes_done(&skey192);
/* AES 256 */
if (aes_setup(key256, 32, 14, &skey256) != CRYPT_OK){
printf("ERROR: in %s, unable to setup AES 256 key\n", __func__);
return 0;
}
if (aes_ecb_encrypt(pt, ct, &skey256) != CRYPT_OK){
printf("ERROR: in %s, unable to encrypt AES 256\n", __func__);
}
printf("Key 256: ");
fprintBuffer_raw(stdout, (char*)key256, 32);
printf("\nCiphertext 256: ");
fprintBuffer_raw(stdout, (char*)ct, 16);
if (aes_ecb_decrypt(ct, vt, &skey256) != CRYPT_OK){
printf("ERROR: in %s, unable to decrypt AES 256\n", __func__);
}
if (!memcmp(vt, pt, 16)){
printf("\nRecovery 256: OK\n");
}
else{
printf("\nRecovery 256: FAIL\n");
}
aes_done(&skey256);
return 0;
}
