u32 BuildPasswordSafeKey_u32 (void)
{
u8 Key_au8[AES_KEYSIZE_256_BIT];
CI_TickLocalPrintf ("BuildPasswordSafeKey_u32\r\n");
RestartSmartcard ();
// LA_RestartSmartcard_u8 ();
// Get a random number for the master key
if (FALSE == getRandomNumber (AES_KEYSIZE_256_BIT / 2, Key_au8))
{
CI_LocalPrintf ("GetRandomNumber fails 1\n\r");
return (FALSE);
}
// Get a random number for the master key
if (FALSE == getRandomNumber (AES_KEYSIZE_256_BIT / 2, &Key_au8[AES_KEYSIZE_256_BIT / 2]))
{
CI_LocalPrintf ("GetRandomNumber fails 2\n\r");
return (FALSE);
}
WritePasswordSafeKey (Key_au8);
// Old Key is invalid
DecryptedPasswordSafeKey_u8 = FALSE;
return (TRUE);
}
u8 GetHiddenVolumeKeyFromUserpassword (u8 * Userpassword_pu8, u8 * DecryptedHiddenVolumeKey_au8)
{
u8 ret_u8;
// Expand user password to 256 bit size
CI_LocalPrintf ("User password : "******"\r\n");
ret_u8 = GetHiddenVolumeDataKeyFromUserpassword (Userpassword_pu8, DecryptedHiddenVolumeKey_au8);
if (HIDDEN_VOLUME_OUTPUT_STATUS_OK != ret_u8)
{
return (ret_u8);
}
CI_LocalPrintf ("Uncrypted hidden volume key : ");
HexPrint (AES_KEYSIZE_256_BIT, DecryptedHiddenVolumeKey_au8);
CI_LocalPrintf ("\r\n");
// Clear the critical memory
memset (Userpassword_pu8, 0, strlen ((char *) Userpassword_pu8));
return (ret_u8);
}
u8 PWS_EnableAccess (u8 * password)
{
unsigned short ret;
CI_LocalPrintf ("PWS_EnableAccess: ");
ret = CcidVerifyPin (2, (unsigned char *) password); // 2 = user pw
if (APDU_ANSWER_COMMAND_CORRECT != ret)
{
CI_LocalPrintf (" *** FAIL ***\r\n");
return CMD_STATUS_WRONG_PASSWORD;
}
ret = PWS_DecryptedPasswordSafeKey ();
if (TRUE != ret)
{
CI_LocalPrintf (" *** FAIL ***. Can't decrypt key\r\n");
return CMD_STATUS_AES_DEC_FAILED;
}
CI_LocalPrintf ("OK\r\n");
return CMD_STATUS_OK;
}
void TIME_MEASURING_INT_show_interrupt_table (void)
{
unsigned int int_grp, int_req, IntNamePointer;
IntNamePointer = 0;
// For all interrupt groups,
CI_LocalPrintf ("Grp Nr Addr\n\r");
for (int_grp = 0; int_grp < AVR32_INTC_NUM_INT_GRPS; int_grp++)
{
// For all interrupt request lines of each group,
for (int_req = 0; int_req < _int_handler_table[int_grp].num_irqs; int_req++)
{
if (&_unhandled_interrupt == _int_handler_table[int_grp]._int_line_handler_table[int_req])
{
CI_LocalPrintf ("%3d %3d %4d %-15s : %9d UNHANDLED\n\r", IntNamePointer, int_grp, int_req, INT_NameTable[IntNamePointer],
TIME_MEASURING_INT_IntCount[IntNamePointer]);
}
else
{
CI_LocalPrintf ("%3d %3d %4d %-15s : %9d 0x%08x\n\r", IntNamePointer, int_grp, int_req, INT_NameTable[IntNamePointer],
TIME_MEASURING_INT_IntCount[IntNamePointer], _int_handler_table[int_grp]._int_line_handler_table[int_req]);
}
IntNamePointer++;
DelayMs (50);
}
}
CI_LocalPrintf (" %-15s : %9d\n\r", INT_NameTable[IntNamePointer], TIME_MEASURING_INT_IntCount[IntNamePointer]);
}
void TIME_MEASURING_INT_Infos (unsigned char nParamsGet_u8, unsigned char CMD_u8, unsigned int Param_u32, unsigned char* String_pu8)
{
if (0 == nParamsGet_u8)
{
CI_LocalPrintf ("Interrupt infos\r\n");
CI_LocalPrintf ("\r\n");
CI_LocalPrintf ("0 Show Interrupttable\r\n");
CI_LocalPrintf ("\r\n");
return;
}
switch (CMD_u8)
{
case 0:
TIME_MEASURING_INT_show_interrupt_table ();
break;
case 1:
TIME_MEASURING_INT_show_interrupt_count ();
break;
case 5:
if (0 == Param_u32)
{
}
else
{
}
break;
}
}
u8 InitRamdomBaseForHiddenKey (void)
{
u8 BaseKey_au8[AES_KEYSIZE_256_BIT];
LA_SC_StartSmartcard ();
CI_TickLocalPrintf ("InitRamdomBaseForHiddenKey\r\n");
// Get a random number for the base key
if (FALSE == GetRandomNumber_u32 (AES_KEYSIZE_256_BIT / 2, BaseKey_au8))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
// Get a random number for the storage key
if (FALSE == GetRandomNumber_u32 (AES_KEYSIZE_256_BIT / 2, &BaseKey_au8[AES_KEYSIZE_256_BIT / 2]))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
CI_LocalPrintf ("Base key : ");
HexPrint (AES_KEYSIZE_256_BIT, BaseKey_au8);
CI_LocalPrintf ("\r\n");
// Save base key
WriteHiddenVolumeSlotKey (BaseKey_au8);
// Invalidate hidden volume data
DecryptedHiddenVolumeSlotsActive_u8 = FALSE;
return (TRUE);
}
u8 PWM_PrintMatrix (void)
{
u32 x, y;
CI_LocalPrintf ("\r\n");
for (y = 0; y < 10; y++)
{
for (x = 0; x < 10; x++)
{
if (-1 != PWM_PasswordMatrix_as8[x][y])
{
CI_LocalPrintf ("%2d", PWM_PasswordMatrix_as8[x][y]);
}
else
{
CI_LocalPrintf (" .");
}
}
CI_LocalPrintf ("\r\n");
}
CI_LocalPrintf ("\r\n");
DelayMs (100);
return (TRUE);
}
u8 HV_WriteSlot_u8 (u8 SlotNr_u8, HiddenVolumeKeySlot_tst * SlotData_st, u8 * SlotKey_pu8)
{
u32 i;
u8 Buffer_au8[HV_SLOT_SIZE];
// u8 HiddenVolumeSlotsKey_au8[AES_KEYSIZE_256_BIT];
if (FALSE == DecryptedHiddenVolumeSlotsActive_u8)
{
return (FALSE); // Slot data is not in ram
}
// Fill buffer with random numbers
for (i = 0; i < HV_SLOT_SIZE; i++)
{
Buffer_au8[i] = rand () % 256;
}
// Set magic number
// SlotData_st->MagicNumber_u32 = HV_MAGIC_NUMBER_SLOT_ENTRY;
// Set CRC32
SlotData_st->Crc_u32 = generateCRC_len ((u8 *) SlotData_st, (sizeof (HiddenVolumeKeySlot_tst) / 4) - 1); // -1 for CRC variable
#ifdef DEBUG_KEYS
CI_LocalPrintf ("HV_WriteSlot_u8 %d - CRC 0x%08x\r\n", SlotNr_u8, SlotData_st->Crc_u32);
CI_LocalPrintf ("Decrypted data :\r\n");
HexPrint (sizeof (HiddenVolumeKeySlot_tst), SlotData_st);
CI_LocalPrintf ("\r\n");
#endif
memcpy (Buffer_au8, (u8 *) SlotData_st, sizeof (HiddenVolumeKeySlot_tst));
// Encrypt slot data
AES_KeyEncryption (HV_SLOT_SIZE, Buffer_au8, SlotKey_pu8, AES_PMODE_CIPHER, SlotNr_u8);
// Write encrypted slot data into ram
memcpy ((u8 *) (DecryptedHiddenVolumeSlotsData_au8 + HV_SALT_SIZE + SlotNr_u8 * HV_SLOT_SIZE), Buffer_au8, HV_SLOT_SIZE);
#ifdef DEBUG_KEYS
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SLOT_SIZE, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE + SlotNr_u8 * HV_SLOT_SIZE]);
CI_LocalPrintf ("\r\n");
#endif
// Encrypt all slots data (max 256 byte per encryption)
AES_KeyEncryption (HV_SLOT_COUNT * HV_SLOT_SIZE, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE], DecryptedHiddenVolumeSlotsKey_au8,
AES_PMODE_CIPHER, SlotNr_u8);
// Write ram data to flash
flashc_memcpy ((u8 *) (HV_SALT_START_ADDRESS + HV_SALT_SIZE), &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE], HV_SLOT_SIZE * HV_SLOT_COUNT,
TRUE);
return (TRUE);
}
u8 PWS_ReadSlot (u8 Slot_u8, typePasswordSafeSlot_st * Slot_st)
{
u8* ReadPointer_pu8;
u8* AesKeyPointer_pu8;
if (PWS_SLOT_COUNT <= Slot_u8)
{
CI_LocalPrintf ("PWS_ReadSlot: Wrong slot nr %d\r\n", Slot_u8);
return (FALSE);
}
if (FALSE == PWS_GetDecryptedPasswordSafeKey (&AesKeyPointer_pu8))
{
CI_LocalPrintf ("PWS_ReadSlot: key not decrypted\r\n");
return (FALSE); // Aes key is not decrypted
}
// LED_GreenOn ();
// Get read address
ReadPointer_pu8 = (u8 *) (PWS_FLASH_START_ADDRESS + (PWS_SLOT_LENGTH * Slot_u8));
memcpy (Slot_st, ReadPointer_pu8, PWS_SLOT_LENGTH);
/*
#ifdef ENABLE_IBN_PWS_TESTS_ENCRYPTION CI_LocalPrintf ("PWS_ReadSlot encrypted : "); HexPrint (PWS_SLOT_LENGTH, Slot_st); CI_LocalPrintf
("\n\r"); #endif */
// Decrypt data (max 256 byte per encryption)
unsigned char Slot_st_decrypted[PWS_SLOT_LENGTH];
aes_context aes_ctx;
aes_setkey_dec (&aes_ctx, AesKeyPointer_pu8, 256);
// TODO: Create aes_crypt_ecb with length as parameter and break the
// input internally
int i;
for (i = 0; i < PWS_SLOT_LENGTH; i += 16)
{
aes_crypt_ecb (&aes_ctx, AES_DECRYPT, &(((unsigned char *) (Slot_st))[i]), &(Slot_st_decrypted[i]));
}
memcpy ((unsigned char *) (Slot_st), Slot_st_decrypted, PWS_SLOT_LENGTH);
/*
#ifdef ENABLE_IBN_PWS_TESTS_ENCRYPTION CI_LocalPrintf ("PWS_ReadSlot decrypted : "); HexPrint (PWS_SLOT_LENGTH, Slot_st_decrypted);
CI_LocalPrintf ("\n\r"); #endif */
// LED_GreenOff ();
return (TRUE);
}
void IBN_ListTaskWithinSingleList (xList *pxList, char *pcStatus )
{
volatile tskTCB *pxNextTCB, *pxFirstTCB;
u16 usStackRemaining;
u64 ullTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
u64 ullStatsAsPercentage;
/* Write the details of all the TCB's in pxList into the buffer. */
listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );
do
{
listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );
usStackRemaining = usTaskCheckFreeStackSpace( ( unsigned char * ) pxNextTCB->pxStack );
ullStatsAsPercentage = (u64)0;
if ((u64)0 != ullTotalRunTime)
{
ullStatsAsPercentage = (u64)10000 * (u64)(pxNextTCB->ullRunTimeCounter);
ullStatsAsPercentage /= ullTotalRunTime;
}
CI_LocalPrintf("%-21.21s ", pxNextTCB->pcTaskName);
CI_LocalPrintf("%s ", pcStatus);
CI_LocalPrintf("%u ", ( unsigned int ) pxNextTCB->uxPriority);
CI_LocalPrintf("%5u ", usStackRemaining);
CI_LocalPrintf("%10u ", (u32)(pxNextTCB->ullRunTimeCounter / 60ULL));
CI_LocalPrintf("%s ", TIME_MEASURING_ShortText (pxNextTCB->ullRunTimeCounter / 60ULL));
CI_LocalPrintf("%6.2f %% ",(float)ullStatsAsPercentage/100.0);
CI_LocalPrintf("%7u \r\n", pxNextTCB->ulRunCounter);
// CI_LocalPrintf( ( char * ) "%-21.21s %s %u %5u %9u %6.2f %%\r\n", pxNextTCB->pcTaskName, pcStatus, ( unsigned int ) pxNextTCB->uxPriority, usStackRemaining,pxNextTCB->ullRunTimeCounter/60,(float)ullStatsAsPercentage/100.0);
} while( pxNextTCB != pxFirstTCB );
}
void IBN_Taskdata (u8 i)
{
u64 ullTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
u64 ullStatsAsPercentage;
u16 usStackRemaining;
usStackRemaining = usTaskCheckFreeStackSpace( ( unsigned char * ) IBN_Tasklist_st[i]->pxStack ) * sizeof (portSTACK_TYPE);
ullStatsAsPercentage = (u64)0;
if ((u64)0 != ullTotalRunTime)
{
ullStatsAsPercentage = (u64)10000 * (u64)(IBN_Tasklist_st[i]->ullRunTimeCounter);
ullStatsAsPercentage /= ullTotalRunTime;
}
CI_LocalPrintf( ( char * ) "%-21.21s ", IBN_Tasklist_st[i]->pcTaskName);
CI_LocalPrintf( ( char * ) "%s ", IBN_TaskStates[IBN_TasklistState_u8[i]]);
CI_LocalPrintf( ( char * ) "%u ", ( unsigned int ) IBN_Tasklist_st[i]->uxPriority);
CI_LocalPrintf( ( char * ) "%5u ", usStackRemaining);
// CI_LocalPrintf( ( char * ) "%10u ", (u32)(IBN_Tasklist_st[i]->ullRunTimeCounter / 60ULL));
CI_LocalPrintf("%s ", TIME_MEASURING_ShortText (IBN_Tasklist_st[i]->ullRunTimeCounter / 60ULL));
CI_LocalPrintf( ( char * ) "%6.2f %% ",(float)ullStatsAsPercentage/100.0);
CI_LocalPrintf( ( char * ) "%6.2f %% ",(float)IBN_Tasklist_st[i]->ullRunTimeCounterLastMinute/(10000.0*60.0*60.0)*(float)(configTICK_RATE_HZ)/1000.0);
CI_LocalPrintf( ( char * ) "%8u \r\n", IBN_Tasklist_st[i]->ulRunCounter);
}
u8 PWS_GetAllSlotStatus (u8 * StatusArray_pu8)
{
u32 i;
u8* AesKeyPointer_pu8;
#if (defined __GNUC__) && (defined __AVR32__)
__attribute__ ((__aligned__ (4)))
#elif (defined __ICCAVR32__)
#pragma data_alignment = 4
#endif
typePasswordSafeSlot_st Slot_st;
// Clear the output array
memset (StatusArray_pu8, 0, PWS_SLOT_COUNT);
// Check for user password enable
if (FALSE == PWS_GetDecryptedPasswordSafeKey (&AesKeyPointer_pu8))
{
CI_LocalPrintf ("PWS_ReadSlot: key not decrypted\r\n");
return (FALSE); // Aes key is not decrypted
}
for (i = 0; i < PWS_SLOT_COUNT; i++)
{
if (TRUE == PWS_ReadSlot (i, &Slot_st))
{
if (PWS_SLOT_ACTIV_TOKEN == Slot_st.SlotActiv_u8)
{
StatusArray_pu8[i] = TRUE;
}
}
}
CI_LocalPrintf ("PWS_ReadSlot: Slot status : ");
for (i = 0; i < PWS_SLOT_COUNT; i++)
{
if (TRUE == StatusArray_pu8[i])
{
CI_LocalPrintf ("1");
}
else
{
CI_LocalPrintf ("0");
}
}
CI_LocalPrintf ("\r\n");
return (TRUE);
}
void TIME_MEASURING_PrintIntLine (u8 Entry_u8)
{
CI_LocalPrintf ("%-17s %9ld ", TIME_MEASURING_IntTimerNames_u8[Entry_u8], INT_TIME_MEASURING_st[Entry_u8].Events_u32);
if (0xFFFFFFFF != INT_TIME_MEASURING_st[Entry_u8].LastRuntimeMin_u32)
{
CI_LocalPrintf ("%9ld ", INT_TIME_MEASURING_st[Entry_u8].LastRuntimeMin_u32 / TIME_MEASURING_TICKS_IN_USEC);
}
else
{
CI_LocalPrintf (" ");
}
CI_LocalPrintf ("%9ld ", INT_TIME_MEASURING_st[Entry_u8].LastRuntimeMax_u32 / TIME_MEASURING_TICKS_IN_USEC);
if (0xFFFFFFFF != INT_TIME_MEASURING_st[Entry_u8].LastStoptimeMin_u32)
{
CI_LocalPrintf ("%9ld ", INT_TIME_MEASURING_st[Entry_u8].LastStoptimeMin_u32 / TIME_MEASURING_TICKS_IN_USEC);
}
else
{
CI_LocalPrintf (" ");
}
CI_LocalPrintf ("%10ld ", INT_TIME_MEASURING_st[Entry_u8].LastStoptimeMax_u32 / TIME_MEASURING_TICKS_IN_USEC);
if (1 >= NoTimereset_u8)
{
// CI_LocalPrintf ("%5.3f%%\n\r",(float)(INT_TIME_MEASURING_st[Entry_u8].SumRuntime_u64/TIME_MEASURING_TICKS_IN_USEC)/(float)OS_Time/10);
}
else
{
CI_LocalPrintf ("\n\r");
}
}
u8 PWS_InitKey (void)
{
u32 Ret_u32;
CI_LocalPrintf ("PWS_InitKey\r\n");
Ret_u32 = PWS_DecryptedPasswordSafeKey ();
if (TRUE != Ret_u32)
{
CI_LocalPrintf ("PWS_InitKey: *** FAIL ***\r\n");
return (FALSE);
}
return (TRUE);
}
void TIME_MEASURING_PrintInt (void)
{
u8 i;
CI_LocalPrintf ("Interrupt Runtime-Analyse\n\r");
CI_LocalPrintf (" Interrupt Runtime Stoptime\n\r");
CI_LocalPrintf (" Nr Name Anzahl Min (usec) Max(usec) Min (usec) Max(usec)\n\r");
for (i = 0; i < INT_TIME_MEASURING_MAX_ZEITSCHEIBEN; i++)
{
if (0 != INT_TIME_MEASURING_st[i].Events_u32)
{
TIME_MEASURING_PrintIntLine (i);
}
}
}
u8 HV_InitAllSlotData (void)
{
// u8 RandomCharArray_au8[16];
u32 i;
// Create salt
for (i = 0; i < 2; i++)
{
// Get a random number from smart card
if (FALSE == GetRandomNumber_u32 (16, &DecryptedHiddenVolumeSlotsData_au8[i * 16]))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
}
// Fill hidden volume flash page with random chars
for (i = 0; i < 16; i++)
{
// Get a random number from smart card
if (FALSE == GetRandomNumber_u32 (16, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE + i * 16]))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
}
// Write magic number to flash
DecryptedHiddenVolumeMagicNumber_u32 = HV_MAGIC_NUMBER_INIT;
flashc_memcpy ((u8 *) HV_MAGIC_NUMBER_ADDRESS, &DecryptedHiddenVolumeMagicNumber_u32, HV_MAGIC_NUMBER_SIZE, TRUE);
// Write ram data to flash
flashc_memcpy ((u8 *) HV_SALT_START_ADDRESS, DecryptedHiddenVolumeSlotsData_au8, HV_SALT_SIZE + HV_SLOT_SIZE * HV_SLOT_COUNT, TRUE);
CI_LocalPrintf ("Init hidden volume slot data\r\n");
CI_LocalPrintf ("Salt\r\n");
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SALT_SIZE, DecryptedHiddenVolumeSlotsData_au8);
CI_LocalPrintf ("\r\n\r\n");
for (i = 0; i < HV_SLOT_COUNT; i++)
{
CI_LocalPrintf ("Slot %d\r\n", i);
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SLOT_SIZE, DecryptedHiddenVolumeSlotsData_au8 + HV_SALT_SIZE + i * HV_SLOT_SIZE);
CI_LocalPrintf ("\r\n\r\n");
}
return (TRUE);
}
void TIME_MEASURING_Print (u8 Value_u8)
{
switch (Value_u8)
{
case 1:
TIME_MEASURING_Init (); // Clear counters
return;
case 2:
#ifdef TIME_MEASURING_INT_ENABLE
TIME_MEASURING_PrintInt ();
#else
CI_LocalPrintf ("Interruptzeitmessung nicht aktiv\n\r");
#endif
return;
}
CI_LocalPrintf ("Runtime-Analyse\n\r");
CI_LocalPrintf (" Runtime Stoptime\n\r");
CI_LocalPrintf ("Counter Anzahl Min (usec) Max(usec) Min (usec) Max(usec)\n\r");
TIME_MEASURING_PrintLine (TIME_MEASURING_TIMER_IDF_10MS);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIMER_IW_10MS);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_3);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_4);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_5);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIMER_KEY_10MS);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_SD_ACCESS);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_8);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_9);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_10);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_CCID_USB_GET);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_CCID_USB_SEND);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_MSD_AES_READ);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_MSD_AES_WRITE);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_15);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_16);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_17);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_18);
TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_FOR_ALL);
// TIME_MEASURING_PrintLine (TIME_MEASURING_TIME_20 ); // CMD Laufzeit
}
u8 GetHiddenVolumeDataKeyFromUserpassword (u8 * Userpassword_pu8, u8 * DecryptedHiddenVolumeKey_pu8)
{
u32 i;
u8 HiddenVolumeSlotKey_u8[AES_KEYSIZE_256_BIT];
HiddenVolumeKeySlot_tst SlotData_st;
// Are the hidden volume slots decrypted ?
if (TRUE != DecryptedHiddenVolumeSlotsActive_u8)
{
CI_LocalPrintf ("Slot data not encrypted\r\n");
return (HIDDEN_VOLUME_OUTPUT_STATUS_NO_USER_PASSWORD_UNLOCK); // No
}
GetHiddenVolumeSlotKey (HiddenVolumeSlotKey_u8, Userpassword_pu8, strlen ((char *) Userpassword_pu8), DecryptedHiddenVolumeSlotsData_au8,
HV_SALT_SIZE);
CI_LocalPrintf ("Hidden volume slot key : ");
HexPrint (AES_KEYSIZE_256_BIT, HiddenVolumeSlotKey_u8);
CI_LocalPrintf ("\r\n");
// Test HiddenVolumeKey for each slot
for (i = 0; i < HV_SLOT_COUNT; i++)
{
if (TRUE == HV_ReadSlot_u8 (i, &SlotData_st, HiddenVolumeSlotKey_u8))
{
memcpy (DecryptedHiddenVolumeKey_pu8, SlotData_st.AesKey_au8, AES_KEYSIZE_256_BIT);
SetHiddenVolumeSizes_u32 (SlotData_st.StartBlock_u32, SlotData_st.EndBlock_u32);
CI_LocalPrintf ("Hidden volume key found - slot %d\r\n", i);
CI_LocalPrintf ("Volume size %d MB\r\n", (SlotData_st.EndBlock_u32 - SlotData_st.StartBlock_u32) / 2048);
CI_LocalPrintf ("StartBlock %9d - %5d MB - %03d %%\r\n", SlotData_st.StartBlock_u32, SlotData_st.StartBlock_u32 / 2048,
(u32) ((u64) SlotData_st.StartBlock_u32 * (u64) 100 / (u64) gSdEndOfCard_u32));
CI_LocalPrintf ("EndBlock %9d - %5d MB - %03d %%\r\n", SlotData_st.EndBlock_u32, SlotData_st.EndBlock_u32 / 2048,
(u32) ((u64) (SlotData_st.EndBlock_u32 + 1) * (u64) 100 / (u64) gSdEndOfCard_u32));
return (HIDDEN_VOLUME_OUTPUT_STATUS_OK);
}
}
CI_LocalPrintf ("Can't find slot from password\r\n");
return (HIDDEN_VOLUME_OUTPUT_STATUS_WRONG_PASSWORD);
/*
u32 i,n,i1; u8 pointer_u8; u8 Slot_u8;* // shake it a little bit pointer_u8 = 0; for (i=0;i<1000;i++) { srand (i +
AESKey_pu8[pointer_u8]*119); for (i1=0;i1<n;i1++) { AESKey_pu8[pointer_u8] = (u8)((u16)AESKey_pu8[pointer_u8] + (u16)Userpassword_pu8[i1] +
(u16)(rand () % 256)); pointer_u8 += (u8)((u16)AESKey_pu8[pointer_u8] + (u16)Userpassword_pu8[i1] + (u16)(rand () % 256)); pointer_u8 =
pointer_u8 % AES_KEYSIZE_256_BIT; } }
*/
}
void IBN_HTML_Tests (unsigned char nParamsGet_u8,unsigned char CMD_u8,unsigned int Param_u32,unsigned char *String_pu8)
{
#ifdef HTML_ENABLE_HTML_INTERFACE
if (0 == nParamsGet_u8)
{
CI_LocalPrintf ("HTML test functions\r\n");
CI_LocalPrintf ("\r\n");
CI_LocalPrintf ("0 Write start file\r\n");
CI_LocalPrintf ("\r\n");
return;
}
switch (CMD_u8)
{
case 0 :
HTML_GenerateStartPage ();
break;
}
#else
CI_LocalPrintf ("HTML interface not active\r\n");
#endif
}
u8 PWM_SwapNumber (u8 SwapPosX_u8, u8 BaseLineY_u8)
{
u8 SwapNumber_u8;
u8 PosY_u8;
u8 SwapX2ndPos_u8;
u8 Save_u8;
SwapNumber_u8 = PWM_PasswordMatrix_as8[SwapPosX_u8][BaseLineY_u8];
for (PosY_u8 = 0; PosY_u8 < 10; PosY_u8++)
{
// If the y pos the baseline the goto next y pos
if (PosY_u8 == BaseLineY_u8)
{
continue;
}
// Is the place used, goto next y pos
if (PWM_PasswordMatrix_as8[SwapPosX_u8][PosY_u8] != -1)
{
continue;
}
// We found a pos to swap
// Find the x pos to swap
for (SwapX2ndPos_u8 = 0; SwapX2ndPos_u8 < 10; SwapX2ndPos_u8++)
{
// Is the place not used, goto next y pos
if (PWM_PasswordMatrix_as8[SwapX2ndPos_u8][PosY_u8] != SwapNumber_u8)
{
continue;
}
// Now check the BaseLineY_u8 for an unused place
if (-1 == PWM_PasswordMatrix_as8[SwapX2ndPos_u8][BaseLineY_u8])
{
#ifdef DEBUG_MP_IO_LEVEL_2
CI_LocalPrintf ("\r\nSwap X1 %d Y1 %d - X2 %d Y2 %d\r\n", SwapPosX_u8, BaseLineY_u8, SwapX2ndPos_u8, PosY_u8);
#endif
// Now we can swap
// Swap the baseline
PWM_PasswordMatrix_as8[SwapX2ndPos_u8][BaseLineY_u8] = SwapNumber_u8;
PWM_PasswordMatrix_as8[SwapPosX_u8][BaseLineY_u8] = -1;
// Swap the PosY_u8 line
Save_u8 = PWM_PasswordMatrix_as8[SwapX2ndPos_u8][PosY_u8];
PWM_PasswordMatrix_as8[SwapX2ndPos_u8][PosY_u8] = PWM_PasswordMatrix_as8[SwapPosX_u8][PosY_u8];
PWM_PasswordMatrix_as8[SwapPosX_u8][PosY_u8] = Save_u8;
return (TRUE);
}
}
}
return (FALSE);
}
u8 GetHiddenVolumeSlotKey (u8 * HiddenVolumeKey_pu8, u8 * Password_pu8, u32 PasswordLen_u32, u8 * Salt_pu8, u32 SaltLen_u32)
{
u8 output_au8[64];
#ifdef LOCAL_DEBUG
CI_LocalPrintf ("Password_pu8 : Len %2d -%s-\r\n", PasswordLen_u32, Password_pu8);
CI_LocalPrintf ("Salt : ");
HexPrint (SaltLen_u32, Salt_pu8);
CI_LocalPrintf ("\r\n");
#endif
#ifndef SAVE_FLASH_MEMORY_NO_PBKDF2
pbkdf2 (output_au8, Password_pu8, PasswordLen_u32, Salt_pu8, SaltLen_u32);
memcpy (HiddenVolumeKey_pu8, output_au8, AES_KEYSIZE_256_BIT); // copy 256 bit from the 512 bit output
#else
CI_LocalPrintf ("*** WARNING low security for hidden volumes ***\r\n");
// use the base key as the key
#endif
#ifdef LOCAL_DEBUG
CI_LocalPrintf ("Key : ");
HexPrint (32, HiddenVolumeKey_pu8);
CI_LocalPrintf ("\r\n");
#endif
return (TRUE);
}
static void USB_CCID_GetDataFromUSB (void)
{
int i;
int USB_Datalen_s32;
// Bool cbw_error;
Usb_reset_endpoint_fifo_access (EP_CCID_OUT);
// Get all data from USB
USB_CCID_data_st.CCID_datalen = 0;
while (Is_usb_out_received (EP_CCID_OUT))
{
Usb_reset_endpoint_fifo_access (EP_CCID_OUT);
USB_Datalen_s32 = Usb_byte_count (EP_CCID_OUT);
USB_Log_st.CCID_WriteCalls_u32++;
USB_Log_st.CCID_BytesWrite_u32 += USB_Datalen_s32;
// CI_TickLocalPrintf ("Get CCID USB block %3d byte - %3d\n",USB_Datalen_s32,USB_CCID_data_st.CCID_datalen);
if (CCID_MAX_XFER_LENGTH <= USB_Datalen_s32 + USB_CCID_data_st.CCID_datalen) // Check for oversize
{
CI_LocalPrintf ("*** CCID buffer to small %d ***\n", CCID_MAX_XFER_LENGTH);
Usb_ack_out_received_free (EP_CCID_OUT);
return;
}
for (i = 0; i < USB_Datalen_s32; i++)
{
USB_CCID_data_st.USB_data[USB_CCID_data_st.CCID_datalen] = Usb_read_endpoint_data (EP_CCID_OUT, 8);
USB_CCID_data_st.CCID_datalen++;
}
Usb_ack_out_received_free (EP_CCID_OUT);
DelayMs (1);
}
LED_RedOn ();
// USB_CCID_Datalen_s32 = USB_CCID_data_st.CCID_datalen;
USB_to_CRD_DispatchUSBMessage_v (&USB_CCID_data_st);
// memset (USB_CCID_data_st.USB_data,0,USB_Datalen_s32);
LED_RedOff ();
// Usb_ack_out_received_free(EP_CCID_OUT);
}
void flashc_issue_command (unsigned int command, int page_number)
{
u_avr32_flashc_fcmd_t u_avr32_flashc_fcmd;
flashc_wait_until_ready ();
u_avr32_flashc_fcmd.fcmd = AVR32_FLASHC.fcmd;
u_avr32_flashc_fcmd.FCMD.cmd = command;
if (page_number >= 0)
u_avr32_flashc_fcmd.FCMD.pagen = page_number;
u_avr32_flashc_fcmd.FCMD.key = AVR32_FLASHC_FCMD_KEY_KEY;
AVR32_FLASHC.fcmd = u_avr32_flashc_fcmd.fcmd;
flashc_error_status = flashc_get_error_status ();
flashc_wait_until_ready ();
#ifdef DEBUG_FLASHC
{
unsigned char text[20];
CI_LocalPrintf ("Flash page :");
itoa ((unsigned int) u_avr32_flashc_fcmd.FCMD.pagen, text);
CI_LocalPrintf (text);
CI_LocalPrintf ("\n\r");
}
#endif
}
void TIME_MEASURING_PrintRuntimeSlots (u8 Entry_u8)
{
u8 i;
if (TIME_MEASURING_MAX_ZEITSCHEIBEN <= Entry_u8)
{
CI_LocalPrintf ("ERROR: Entry %d not found. Max slot is %d\n\r", Entry_u8, TIME_MEASURING_MAX_TIME_SLICES - 1);
return;
}
CI_LocalPrintf ("Runtimeslot %s\n\r\n\r", TIME_MEASURING_TimerNames_u8[Entry_u8]);
CI_LocalPrintf ("Runtime (usec) Count\n\r");
for (i = 0; i < TIME_MEASURING_MAX_TIME_SLICES - 1; i++)
{
CI_LocalPrintf (" %5ld - %5ld : %9ld\n\r", TIME_MEASURING_RuntimeSlice_in_ticks_u32 * i / TIME_MEASURING_TICKS_IN_USEC,
TIME_MEASURING_RuntimeSlice_in_ticks_u32 * (i + 1) / TIME_MEASURING_TICKS_IN_USEC,
TIME_MEASURING_st[Entry_u8].RuntimeSliceCount_u32[i]);
}
CI_LocalPrintf (" > %5ld : %9ld\n\r",
TIME_MEASURING_RuntimeSlice_in_ticks_u32 * (TIME_MEASURING_MAX_TIME_SLICES - 1) / TIME_MEASURING_TICKS_IN_USEC,
TIME_MEASURING_st[Entry_u8].RuntimeSliceCount_u32[TIME_MEASURING_MAX_TIME_SLICES - 1]);
}
u8 ClearStickKeysNotInitatedToFlash (void)
{
// If configuration not found then init it
if (FALSE == ReadStickConfigurationFromUserPage ())
{
InitStickConfigurationToUserPage_u8 ();
}
CI_LocalPrintf ("Clear: Stick keys not initiated\r\n");
StickConfiguration_st.StickKeysNotInitiated_u8 = FALSE;
WriteStickConfigurationToUserPage ();
return (TRUE);
}
u8 SetSdCardNotFilledWithRandomCharsToFlash (void)
{
// If configuration not found then init it
if (FALSE == ReadStickConfigurationFromUserPage ())
{
InitStickConfigurationToUserPage_u8 ();
}
CI_LocalPrintf ("Set new SD card *** not *** filled with random chars\r\n");
StickConfiguration_st.SDFillWithRandomChars_u8 &= 0xFE; // Clear the "card with random chars filled" bit
WriteStickConfigurationToUserPage ();
return (TRUE);
}
u8 SetSdCardFilledWithRandomCharsToFlash (void)
{
// If configuration not found then init it
if (FALSE == ReadStickConfigurationFromUserPage ())
{
InitStickConfigurationToUserPage_u8 ();
}
CI_LocalPrintf ("Set new SD card filled with random chars\r\n");
StickConfiguration_st.SDFillWithRandomChars_u8 |= 0x01; // Set the "SD card filled with randoms" bit
WriteStickConfigurationToUserPage ();
return (TRUE);
}
u8 ClearNewSdCardFoundToFlash (void)
{
// If configuration not found then init it
if (FALSE == ReadStickConfigurationFromUserPage ())
{
InitStickConfigurationToUserPage_u8 ();
}
CI_LocalPrintf ("Clear new SD card found\r\n");
StickConfiguration_st.NewSDCardFound_u8 &= 0xFE; // Clear the "new SD card found" bit
WriteStickConfigurationToUserPage ();
return (TRUE);
}
void IBN_LogADInput (u8 nParamsGet_u8,u8 CMD_u8,u32 Param_u32)
{
#ifdef AD_LOGGING_ACTIV
if (0 == nParamsGet_u8)
{
CI_LocalPrintf ("AD Test\r\n");
CI_LocalPrintf ("\r\n");
CI_LocalPrintf ("0 Print AD data\r\n");
CI_LocalPrintf ("1 Start SD log\r\n");
CI_LocalPrintf ("2 Stop SD log\r\n");
CI_LocalPrintf ("3 Init SD log\r\n");
CI_LocalPrintf ("4 Print summary\r\n");
CI_LocalPrintf ("\r\n");
return;
}
switch (CMD_u8)
{
case 0 :
AD_Readdata ();
break;
case 1 :
AD_LOG_Start ();
break;
case 2 :
AD_LOG_Stop ();
break;
case 3 :
AD_LOG_init();
break;
case 4:
AD_PrintSummary ();
break;
case 5 :
AD_FileIO_ReadLocalTime_u32 ();
break;
}
#else
CI_LocalPrintf ("AD Log not active\r\n");
#endif // #ifdef AD_LOGGING_ACTIV
}
u8 InitHiddenSlots (void)
{
CI_LocalPrintf ("InitHiddenSlots: Overwriting all keys\r\n");
if (FALSE == InitRamdomBaseForHiddenKey ())
{
return (FALSE);
}
if (FALSE == HV_InitAllSlotData ())
{
return (FALSE);
}
return (TRUE);
}