137 lines
3.9 KiB
C
137 lines
3.9 KiB
C
#ifdef HAVE_EIP712_FULL_SUPPORT
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "encode_field.h"
|
|
#include "mem.h"
|
|
#include "shared_context.h"
|
|
#include "apdu_constants.h" // APDU response codes
|
|
|
|
typedef enum { MSB, LSB } e_padding_type;
|
|
|
|
/**
|
|
* Encode a field value to 32 bytes (padded)
|
|
*
|
|
* @param[in] value field value to encode
|
|
* @param[in] length field length before encoding
|
|
* @param[in] ptype padding direction (LSB vs MSB)
|
|
* @param[in] pval value used for padding
|
|
* @return encoded field value
|
|
*/
|
|
static void *field_encode(const uint8_t *const value,
|
|
uint8_t length,
|
|
e_padding_type ptype,
|
|
uint8_t pval) {
|
|
uint8_t *padded_value;
|
|
uint8_t start_idx;
|
|
|
|
if (length > EIP_712_ENCODED_FIELD_LENGTH) // sanity check
|
|
{
|
|
apdu_response_code = APDU_RESPONSE_INVALID_DATA;
|
|
return NULL;
|
|
}
|
|
if ((padded_value = mem_alloc(EIP_712_ENCODED_FIELD_LENGTH)) != NULL) {
|
|
switch (ptype) {
|
|
case MSB:
|
|
memset(padded_value, pval, EIP_712_ENCODED_FIELD_LENGTH - length);
|
|
start_idx = EIP_712_ENCODED_FIELD_LENGTH - length;
|
|
break;
|
|
case LSB:
|
|
explicit_bzero(padded_value + length, EIP_712_ENCODED_FIELD_LENGTH - length);
|
|
start_idx = 0;
|
|
break;
|
|
default:
|
|
apdu_response_code = APDU_RESPONSE_CONDITION_NOT_SATISFIED;
|
|
return NULL; // should not be here
|
|
}
|
|
memcpy(&padded_value[start_idx], value, length);
|
|
} else {
|
|
apdu_response_code = APDU_RESPONSE_INSUFFICIENT_MEMORY;
|
|
}
|
|
return padded_value;
|
|
}
|
|
|
|
/**
|
|
* Encode an unsigned integer
|
|
*
|
|
* @param[in] value pointer to the "packed" integer received
|
|
* @param[in] length its byte-length
|
|
* @return the encoded value
|
|
*/
|
|
void *encode_uint(const uint8_t *const value, uint8_t length) {
|
|
// no length check here since it will be checked by field_encode
|
|
return field_encode(value, length, MSB, 0x00);
|
|
}
|
|
|
|
/**
|
|
* Encode a signed integer
|
|
*
|
|
* @param[in] value pointer to the "packed" integer received
|
|
* @param[in] length its byte-length
|
|
* @param[in] typesize the type size in bytes
|
|
* @return the encoded value
|
|
*/
|
|
void *encode_int(const uint8_t *const value, uint8_t length, uint8_t typesize) {
|
|
uint8_t padding_value;
|
|
|
|
if (length < 1) {
|
|
apdu_response_code = APDU_RESPONSE_INVALID_DATA;
|
|
return NULL;
|
|
}
|
|
|
|
if ((length == typesize) && (value[0] & (1 << 7))) // negative number
|
|
{
|
|
padding_value = 0xFF;
|
|
} else {
|
|
padding_value = 0x00;
|
|
}
|
|
// no length check here since it will be checked by field_encode
|
|
return field_encode(value, length, MSB, padding_value);
|
|
}
|
|
|
|
/**
|
|
* Encode a fixed-size byte array
|
|
*
|
|
* @param[in] value pointer to the "packed" bytes array
|
|
* @param[in] length its byte-length
|
|
* @return the encoded value
|
|
*/
|
|
void *encode_bytes(const uint8_t *const value, uint8_t length) {
|
|
// no length check here since it will be checked by field_encode
|
|
return field_encode(value, length, LSB, 0x00);
|
|
}
|
|
|
|
/**
|
|
* Encode a boolean
|
|
*
|
|
* @param[in] value pointer to the boolean received
|
|
* @param[in] length its byte-length
|
|
* @return the encoded value
|
|
*/
|
|
void *encode_boolean(const bool *const value, uint8_t length) {
|
|
if (length != 1) // sanity check
|
|
{
|
|
apdu_response_code = APDU_RESPONSE_INVALID_DATA;
|
|
return NULL;
|
|
}
|
|
return encode_uint((uint8_t *) value, length);
|
|
}
|
|
|
|
/**
|
|
* Encode an address
|
|
*
|
|
* @param[in] value pointer to the address received
|
|
* @param[in] length its byte-length
|
|
* @return the encoded value
|
|
*/
|
|
void *encode_address(const uint8_t *const value, uint8_t length) {
|
|
if (length != ADDRESS_LENGTH) // sanity check
|
|
{
|
|
apdu_response_code = APDU_RESPONSE_INVALID_DATA;
|
|
return NULL;
|
|
}
|
|
return encode_uint(value, length);
|
|
}
|
|
|
|
#endif // HAVE_EIP712_FULL_SUPPORT
|