void process::initialize(float exec_time,int beta) //should not be in constructor... max_pid can be affected
{
p_id=max_pid++;
set_arvl_time();
set_execution_time(exec_time);
set_deadline(beta);// should be called after set_execution_time(---)
}
bool write4 (int fd, enum DATA_ZONE zone, uint8_t addr, uint32_t buf)
{
bool status = false;
uint8_t recv = 0;
uint8_t param2[2] = {0};
uint8_t param1 = set_zone_bits (zone);
param2[0] = addr;
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_WRITE);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, (uint8_t *)&buf, sizeof (buf));
set_execution_time (&c, 0, 4000000);
if (RSP_SUCCESS == process_command (fd, &c, &recv, sizeof (recv)));
{
if (0 == (int) recv)
status = true;
}
return status;
}
struct octet_buffer read32 (int fd, enum DATA_ZONE zone, uint8_t addr)
{
uint8_t param2[2] = {0};
uint8_t param1 = set_zone_bits (zone);
uint8_t READ_32_MASK = 0b10000000;
param1 |= READ_32_MASK;
param2[0] = addr;
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_READ);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, NULL, 0);
set_execution_time (&c, 0, READ_AVG_EXEC);
const unsigned int LENGTH_OF_RESPONSE = 32;
struct octet_buffer buf = make_buffer (LENGTH_OF_RESPONSE);
if (RSP_SUCCESS != process_command (fd, &c, buf.ptr, LENGTH_OF_RESPONSE))
{
free_wipe (buf.ptr, LENGTH_OF_RESPONSE);
buf.ptr = NULL;
buf.len = 0;
}
return buf;
}
bool read4 (int fd, enum DATA_ZONE zone, uint8_t addr, uint32_t *buf)
{
bool result = false;
uint8_t param2[2] = {0};
uint8_t param1 = set_zone_bits (zone);
assert (NULL != buf);
param2[0] = addr;
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_READ);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, NULL, 0);
set_execution_time (&c, 0, 1000000);
if (RSP_SUCCESS == process_command (fd, &c, (uint8_t *)buf, sizeof (uint32_t)))
{
result = true;
}
return result;
}
struct octet_buffer get_random (int fd, bool update_seed)
{
uint8_t *random = NULL;
uint8_t param2[2] = {0};
uint8_t param1 = update_seed ? 0 : 1;
struct octet_buffer buf = {};
random = malloc_wipe (RANDOM_RSP_LENGTH);
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_RANDOM);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, NULL, 0);
set_execution_time (&c, 0, RANDOM_AVG_EXEC);
if (RSP_SUCCESS == process_command (fd, &c, random, RANDOM_RSP_LENGTH))
{
buf.ptr = random;
buf.len = RANDOM_RSP_LENGTH;
}
else
CTX_LOG (DEBUG, "Random command failed");
return buf;
}
bool check_mac (int fd, struct check_mac_encoding cm,
unsigned int data_slot,
struct octet_buffer challenge,
struct octet_buffer challenge_response,
struct octet_buffer other_data)
{
uint8_t response = 0;
bool result = false;
uint8_t param1 = serialize_check_mac_mode (cm);
uint8_t param2[2] = {0};
const unsigned int CHALLENGE_SIZE = 32;
const unsigned int OTHER_DATA_SIZE = 13;
assert (NULL != challenge.ptr);
assert (NULL != challenge_response.ptr);
assert (NULL != other_data.ptr);
assert (CHALLENGE_SIZE == challenge.len);
assert (CHALLENGE_SIZE == challenge_response.len);
assert (OTHER_DATA_SIZE == other_data.len);
assert (data_slot <= MAX_NUM_DATA_SLOTS);
const unsigned int DATA_LEN = CHALLENGE_SIZE * 2 + OTHER_DATA_SIZE;
struct octet_buffer data;
data = make_buffer(DATA_LEN);
memcpy (data.ptr, challenge.ptr, CHALLENGE_SIZE);
memcpy (data.ptr + CHALLENGE_SIZE, challenge_response.ptr, CHALLENGE_SIZE);
memcpy (data.ptr + CHALLENGE_SIZE * 2, other_data.ptr, OTHER_DATA_SIZE);
/* Param 2 is guaranteed to be less than 15 (check above) */
param2[0] = data_slot;
param2[1] = 0;
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_CHECK_MAC);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, data.ptr, data.len);
set_execution_time (&c, 0, CHECK_MAC_AVG_EXEC);
if (RSP_SUCCESS == process_command (fd, &c, &response, sizeof(response)))
{
if (0 == response)
result = true;
}
return result;
}
bool lock (int fd, enum DATA_ZONE zone, uint16_t crc)
{
uint8_t param1 = 0;
uint8_t param2[2];
uint8_t response;
bool result = false;
if (is_locked (fd, zone))
return true;
memcpy (param2, &crc, sizeof (param2));
const uint8_t CONFIG_MASK = 0;
const uint8_t DATA_MASK = 1;
switch (zone)
{
case CONFIG_ZONE:
param1 |= CONFIG_MASK;
break;
case DATA_ZONE:
case OTP_ZONE:
param1 |= DATA_MASK;
break;
default:
assert (false);
}
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_LOCK);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, NULL, 0);
set_execution_time (&c, 0, LOCK_AVG_EXEC);
if (RSP_SUCCESS == process_command (fd, &c, &response, sizeof (response)))
{
if (0 == response)
{
result = true;
CTX_LOG (DEBUG, "Lock Successful");
}
else
{
CTX_LOG (DEBUG, "Lock Failed");
}
}
return result;
}
struct mac_response perform_mac (int fd, struct mac_mode_encoding m,
unsigned int data_slot,
struct octet_buffer challenge)
{
const unsigned int recv_len = 32;
struct mac_response rsp = {0};
rsp.status = false;
uint8_t param1 = serialize_mac_mode (m);
uint8_t param2[2] = {0};
assert (data_slot <= MAX_NUM_DATA_SLOTS);
if (!m.use_second_32_temp_key)
assert (NULL != challenge.ptr && recv_len == challenge.len);
/* Param 2 is guaranteed to be less than 15 (check above) */
param2[0] = data_slot;
param2[1] = 0;
rsp.mac = make_buffer (recv_len);
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_MAC);
set_param1 (&c, param1);
set_param2 (&c, param2);
/* TODO Fix for situations not sending the challlenge */
set_data (&c, challenge.ptr, challenge.len);
set_execution_time (&c, 0, MAC_AVG_EXEC);
if (RSP_SUCCESS == process_command (fd, &c, rsp.mac.ptr, recv_len))
{
/* Perform a check mac to ensure we have the data correct */
rsp.meta = get_check_mac_meta_data (fd, m, data_slot);
struct check_mac_encoding cm = {0};
rsp.status = check_mac (fd, cm, data_slot, challenge, rsp.mac, rsp.meta);
}
else
{
free_octet_buffer (rsp.mac);
}
return rsp;
}
struct octet_buffer gen_nonce (int fd, int seed_update_flag,
struct octet_buffer input)
{
uint8_t *recv = NULL;
uint8_t param1 = seed_update_flag;
uint8_t param2[2] = {0};
unsigned int recv_len = 0;
struct octet_buffer response = {NULL, 0};
assert (1 == seed_update_flag || 0 == seed_update_flag);
assert (NULL != input.ptr);
/* If 32, the nonce is considered a pass through and will be used
directly by the system */
/* If 20, the nonce will be combined with a random number */
assert (32 == input.len || 20 == input.len);
if (32 == input.len)
{
recv_len = 1;
}
else
{
recv_len = 32;
}
recv = malloc (recv_len);
assert (NULL != recv);
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_NONCE);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, input.ptr, input.len);
set_execution_time (&c, 0, 22000000); /* avg. 22 msec */
if (RSP_SUCCESS == process_command (fd, &c, recv, recv_len));
{
response.ptr = recv;
response.len= recv_len;
}
return response;
}
bool write32 (int fd, enum DATA_ZONE zone, uint8_t addr,
struct octet_buffer buf)
{
assert (NULL != buf.ptr);
assert (32 == buf.len);
bool status = false;
uint8_t recv = 0;
uint8_t param2[2] = {0};
uint8_t param1 = set_zone_bits (zone);
/* If writing 32 bytes, this bit must be set in param1 */
uint8_t WRITE_32_MASK = 0b10000000;
param1 |= WRITE_32_MASK;
param2[0] = addr;
struct Command_ATSHA204 c = make_command ();
set_opcode (&c, COMMAND_WRITE);
set_param1 (&c, param1);
set_param2 (&c, param2);
set_data (&c, buf.ptr, buf.len);
set_execution_time (&c, 0, WRITE_AVG_EXEC);
if (RSP_SUCCESS == process_command (fd, &c, &recv, sizeof (recv)));
{
if (0 == (int) recv)
status = true;
}
return status;
}
