int com_keys_test(char* arg) {
// Arg format: 1k|4k A|B
char* s = strtok(arg, " ");
char* ab = strtok(NULL, " ");
if (s && ab && strtok(NULL, " ") != NULL) {
printf("Too many arguments\n");
return -1;
}
if (!s || !ab) {
printf("Too few arguments: (1k|4k) (A|B)\n");
return -1;
}
// Parse arguments
mf_size_t size = parse_size(s);
if (size == MF_INVALID_SIZE) {
printf("Unknown size argument (1k|4k): %s\n", s);
return -1;
}
mf_key_type_t key_type = parse_key_type(ab);
if (key_type == MF_INVALID_KEY_TYPE) {
printf("Unknown key type argument (A|B): %s\n", ab);
return -1;
}
// Run the auth test
mf_test_auth(¤t_auth, size, key_type);
return 0;
}
int com_write_tag(char* arg) {
// Add option to choose key
char* ab = strtok(arg, " ");
if (!ab) {
printf("Too few arguments: (A|B)\n");
return -1;
}
if (strtok(NULL, " ") != (char*)NULL) {
printf("Too many arguments\n");
return -1;
}
// Parse key selection
mf_key_type_t key_type = parse_key_type(ab);
if (key_type == MF_INVALID_KEY_TYPE) {
printf("Invalid argument (A|B): %s\n", ab);
return -1;
}
// Issue the read request
mf_write_tag(¤t_tag, key_type);
return 0;
}
EVP_PKEY *EVP_parse_public_key(CBS *cbs) {
// Parse the SubjectPublicKeyInfo.
CBS spki, algorithm, key;
int type;
uint8_t padding;
if (!CBS_get_asn1(cbs, &spki, CBS_ASN1_SEQUENCE) ||
!CBS_get_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
!parse_key_type(&algorithm, &type) ||
!CBS_get_asn1(&spki, &key, CBS_ASN1_BITSTRING) ||
CBS_len(&spki) != 0 ||
// Every key type defined encodes the key as a byte string with the same
// conversion to BIT STRING.
!CBS_get_u8(&key, &padding) ||
padding != 0) {
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
return NULL;
}
// Set up an |EVP_PKEY| of the appropriate type.
EVP_PKEY *ret = EVP_PKEY_new();
if (ret == NULL ||
!EVP_PKEY_set_type(ret, type)) {
goto err;
}
// Call into the type-specific SPKI decoding function.
if (ret->ameth->pub_decode == NULL) {
OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
goto err;
}
if (!ret->ameth->pub_decode(ret, &algorithm, &key)) {
goto err;
}
return ret;
err:
EVP_PKEY_free(ret);
return NULL;
}
EVP_PKEY *EVP_parse_private_key(CBS *cbs) {
// Parse the PrivateKeyInfo.
CBS pkcs8, algorithm, key;
uint64_t version;
int type;
if (!CBS_get_asn1(cbs, &pkcs8, CBS_ASN1_SEQUENCE) ||
!CBS_get_asn1_uint64(&pkcs8, &version) ||
version != 0 ||
!CBS_get_asn1(&pkcs8, &algorithm, CBS_ASN1_SEQUENCE) ||
!parse_key_type(&algorithm, &type) ||
!CBS_get_asn1(&pkcs8, &key, CBS_ASN1_OCTETSTRING)) {
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
return NULL;
}
// A PrivateKeyInfo ends with a SET of Attributes which we ignore.
// Set up an |EVP_PKEY| of the appropriate type.
EVP_PKEY *ret = EVP_PKEY_new();
if (ret == NULL ||
!EVP_PKEY_set_type(ret, type)) {
goto err;
}
// Call into the type-specific PrivateKeyInfo decoding function.
if (ret->ameth->priv_decode == NULL) {
OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
goto err;
}
if (!ret->ameth->priv_decode(ret, &algorithm, &key)) {
goto err;
}
return ret;
err:
EVP_PKEY_free(ret);
return NULL;
}
mf_key_type_t parse_key_type_default(const char* str,
mf_key_type_t default_type) {
if (str == NULL)
return default_type;
return parse_key_type(str);
}
int com_keys_set(char* arg) {
// Arg format: A|B #S key
char* ab = strtok(arg, " ");
char* sector_str = strtok(NULL, " ");
char* key_str = strtok(NULL, " ");
if (strtok(NULL, " ") != (char*)NULL) {
printf("Too many arguments\n");
return -1;
}
if (!ab || !sector_str || !key_str) {
printf("Too few arguments: (A|B) #sector key\n");
return -1;
}
// Read sector
long int sector = strtol(sector_str, §or_str, 16);
// Sanity check sector range
if (*sector_str != '\0') {
printf("Invalid sector character (non hex): %s\n", sector_str);
return -1;
}
if (sector < 0 || sector > 0x1b) {
printf("Invalid sector [0,1b]: %lx\n", sector);
return -1;
}
// Sanity check key length
if (strncmp(key_str, "0x", 2) == 0)
key_str += 2;
if (strlen(key_str) != 12) {
printf("Invalid key (6 byte hex): %s\n", key_str);
return -1;
}
// Compute the block that houses the key for the desired sector
size_t block = sector_to_trailer((size_t)sector);
// Parse key selection and point to appropriate key
uint8_t* key;
mf_key_type_t key_type = parse_key_type(ab);
if (key_type == MF_KEY_A)
key = current_auth.amb[block].mbt.abtKeyA;
else if (key_type == MF_KEY_B)
key = current_auth.amb[block].mbt.abtKeyB;
else {
printf("Invalid argument (A|B): %s\n", ab);
return -1;
}
// Parse the key
if (read_key(key, key_str) == NULL) {
printf("Invalid key character (non hex)\n");
return -1;
}
return 0;
}
