#include <types.h>
Go to the source code of this file.
Functions | |
void | hal_init (void) |
Initializes the HAL. More... | |
bool | hal_eeprom_read (iu8 *dst, iu16 src, iu8 len) |
Read data from EEPROM. More... | |
bool | hal_eeprom_write (iu16 dst, iu8 *src, iu8 len) |
Write data to EEPROM. More... | |
void | hal_io_sendByteT0 (iu8 b) |
Send a byte with T=0 error detection and recovery. More... | |
iu8 | hal_io_recByteT0 (void) |
Receive a byte with T=0 error detection and recovery. More... | |
bool | hal_rnd_addEntropy (void) |
Adds entropy to the random number generator state. More... | |
bool | hal_rnd_getBlock (iu8 *dst) |
Returns 8 random bytes. More... | |
bool | hal_led (char set) |
Sets the LEDs on Jupiter 2 cards. More... |
|
Read data from EEPROM. The internal EEPROM begins at address 0, the external EEPROM is located subsequently.
|
|
Write data to EEPROM. The internal EEPROM begins at address 0, the external EEPROM is located subsequently.
|
|
Initializes the HAL. Must be called after each reset. |
|
Receive a byte with T=0 error detection and recovery. Currently only 9600 bps at 3.58MHz with direct convention is supported.
|
|
Send a byte with T=0 error detection and recovery. Currently only 9600 bps at 3.58MHz with direct convention is supported.
|
|
Sets the LEDs on Jupiter 2 cards. This can be used for example for debugging to show some state or to get a Nightrider feeling.
|
|
Adds entropy to the random number generator state.
The idea: Adding real randomness to the RAND_STATE via random events and a high speed timer.
The implementation: Timer 0 is started at the beginning and incremented every clock cycle, i.e. normally 3.58 million times per second. The timer is read at the beginning and at the end of the execution of every command. After every 8 timer values gathered in this way, RAND_STATE is read and encrypted with RAND_STATE and timer values as key. The result is written back to RAND_STATE.
The analysis: The analysis has been done by calculating the difference of each consecutive timer value pair. From these value two distributions are build. The first is the frequency for the timer value differences within the command and the second is the frequency for the timer value differences outside the command, i.e. while communicating with the terminal. The command used for this evaluation is the Read EEPROM command (80 04 18 00 10), which should have a relatively constant execution time and does not receive bytes from the terminal.
Terminal randomness: As expected the randomness of the distribution depends on the external system, i.e. card reader and host. Different distributions have been seen e.g. for Towitoko Chipdrive and Intertext IX2. This randomness can increas the randomness in the RAND_STATE buffer, when the card is in the hand of the owner of the card. By this, it changes RAND_STATE in a non-deterministic way for the institution writing the starting value of RAND_STATE
Command randomness: Because there is no obvious possibility for different runtimes, the expected result would be to have exactly the same delta values for all command runs, but this is not the case. The result is a 9 - 10 ticks wide curved distribution. The reason for this might be the I2C routine communicating with the external EEPROM, because Get Response and Read EE in the internal EEPROM area have the expected result with a single delta value. Independed of the source of the clock tick variations, there is probably not much non-determinism for a skilled attacker, because he can count the clocks a command has executed.
|
|
Returns 8 random bytes. The current AVR implementation does not produce real random numbers, but pseudo random numbers. These are produced by a X9.17 generator modified to use a counter instead of a timer. The state of this PRNG is held at RAND_STATE_ADDR. The start value (at least the key) at this address should be unique for every card.
|