Files
proxmark3/client/src/crypto/libpcrypto.c
T
iceman1001andClaude Opus 5 28d49510e2 hf mf: add RKF travel card parser
The RKF travel card (Resekortsföreningen i Norden) is the Nordic public
transport card, specified 2001-2002 on MIFARE Classic and deployed by
Västtrafik, SL Stockholm, Länstrafiken and the Danish Rejsekort.

Decodes the card issuer and support layers (CMI, TCCI, TCAS, TCDI) and
every application object the specification pins down: TCPU purse, TCEL
event log, TCDB, TCCP, TCST, and TCTI/TCCO through an identifier chain
walker covering all 18 data element groups. AID owners are named from
RKF-0019.

Three things the specification does not state, determined from 21 cards:

  - RKF-0022 7.7.1 calls the block checksum 'standard CRC-8' without
    naming the parameters. It is CRC-8/MIFARE-MAD, poly 0x1D init 0xC7,
    which the tree already ships as CRC8Mad().

  - The MAC trio is the final 24 bits of a MACed object. The RKF-0023
    tables list Free (bits) as a trailing summary row, which reads as if
    the authenticator follows a gap after the key identifier; it does
    not. Measured on the fact that MACAlgorithmIdentifier must be 0:
    TCST 42/42 against 15/42, TCCP 20/20 against 13/20.

  - TCPU version 4 drops EndDate and moves Value to bit 16.

Cards reporting a version other than 2 are flagged, and a MAC algorithm
the specification does not define is reported as a layout failure rather
than printed as data.

MAC values are not verified. The master key is in RKF-0018, which was
never published. des_mac() is added to libpcrypto for when that changes,
with the FIPS 113 worked example as its test.

Verified against a Danish Rejsekort whose provenance notes give the
purchase timestamp, card number and balance; the parser reproduces all
three. 48 self test checks on 'hf mf view --selftest', no false
positives across 460 local dumps.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-22 11:14:44 +02:00

1554 lines
48 KiB
C

//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// crypto commands
//-----------------------------------------------------------------------------
#include "crypto/libpcrypto.h"
#include "crypto/asn1utils.h"
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <mbedtls/asn1.h>
#include <mbedtls/des.h>
#include <mbedtls/aes.h>
#include <mbedtls/cmac.h>
#include <mbedtls/pk.h>
#include <mbedtls/base64.h>
#include <mbedtls/ecdsa.h>
#include <mbedtls/sha1.h>
#include <mbedtls/sha256.h>
#include <mbedtls/sha512.h>
#include <mbedtls/ctr_drbg.h>
#include <mbedtls/entropy.h>
#include <mbedtls/error.h>
#include <mbedtls/blowfish.h>
#include "libpcrypto.h"
#include "util.h"
#include "ui.h"
#include "fileutils.h"
#include "math.h"
#define PCRYPTO_MAX_KEY_INPUT 8192
#define PCRYPTO_MAX_KEY_FILE_BYTES (64 * 1024)
int pcrypto_rng_init(pcrypto_rng_t *rng, const uint8_t *personalization, size_t personalization_len) {
if (rng == NULL || (personalization_len > 0 && personalization == NULL)) {
return PM3_EINVARG;
}
memset(rng, 0, sizeof(*rng));
mbedtls_entropy_init(&rng->entropy);
mbedtls_ctr_drbg_init(&rng->ctr_drbg);
int ret = mbedtls_ctr_drbg_seed(&rng->ctr_drbg, mbedtls_entropy_func, &rng->entropy,
personalization, personalization_len);
if (ret != 0) {
PrintAndLogEx(ERR, "Failed to initialize random generator (mbedtls: %d)", ret);
mbedtls_ctr_drbg_free(&rng->ctr_drbg);
mbedtls_entropy_free(&rng->entropy);
return PM3_ESOFT;
}
rng->seeded = true;
return PM3_SUCCESS;
}
void pcrypto_rng_free(pcrypto_rng_t *rng) {
if (rng == NULL) {
return;
}
mbedtls_ctr_drbg_free(&rng->ctr_drbg);
mbedtls_entropy_free(&rng->entropy);
rng->seeded = false;
}
int pcrypto_rng_fill(pcrypto_rng_t *rng, uint8_t *out, size_t out_len) {
if (rng == NULL || out == NULL || rng->seeded == false) {
return PM3_EINVARG;
}
if (out_len == 0) {
return PM3_SUCCESS;
}
return (mbedtls_ctr_drbg_random(&rng->ctr_drbg, out, out_len) == 0) ? PM3_SUCCESS : PM3_ESOFT;
}
int pcrypto_rng_fill_oneshot(uint8_t *out, size_t out_len, const char *personalization) {
if (out == NULL || personalization == NULL) {
return PM3_EINVARG;
}
pcrypto_rng_t rng = {0};
int res = pcrypto_rng_init(&rng, (const uint8_t *)personalization, strlen(personalization));
if (res != PM3_SUCCESS) {
pcrypto_rng_free(&rng);
return res;
}
res = pcrypto_rng_fill(&rng, out, out_len);
pcrypto_rng_free(&rng);
return res;
}
static int pcrypto_extract_priv_scalar_from_pk(const mbedtls_pk_context *pkctx,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (pkctx == NULL || out_priv == NULL || out_priv_len == 0) {
return PM3_EINVARG;
}
mbedtls_pk_type_t pk_type = mbedtls_pk_get_type(pkctx);
if (!(pk_type == MBEDTLS_PK_ECKEY || pk_type == MBEDTLS_PK_ECKEY_DH)) {
return PM3_EINVARG;
}
mbedtls_ecp_keypair *ec = mbedtls_pk_ec(*pkctx);
if (ec == NULL || ec->grp.id != curveid) {
return PM3_EINVARG;
}
if (mbedtls_mpi_bitlen(&ec->d) > (out_priv_len * 8U)) {
return PM3_EINVARG;
}
if (mbedtls_ecp_check_privkey(&ec->grp, &ec->d) != 0) {
return PM3_EINVARG;
}
if (mbedtls_mpi_write_binary(&ec->d, out_priv, out_priv_len) != 0) {
return PM3_ESOFT;
}
return PM3_SUCCESS;
}
static int pcrypto_validate_raw_scalar(const uint8_t *scalar, size_t scalar_len, mbedtls_ecp_group_id curveid);
static int pcrypto_parse_ec_private_blob(const uint8_t *blob, size_t blob_len,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (blob == NULL || out_priv == NULL || blob_len == 0 || out_priv_len == 0) {
return PM3_EINVARG;
}
mbedtls_pk_context pkctx;
mbedtls_pk_init(&pkctx);
int ret = mbedtls_pk_parse_key(&pkctx, blob, blob_len, NULL, 0);
if (ret != 0) {
uint8_t *nul_terminated = calloc(blob_len + 1, sizeof(uint8_t));
if (nul_terminated == NULL) {
mbedtls_pk_free(&pkctx);
return PM3_EMALLOC;
}
memcpy(nul_terminated, blob, blob_len);
ret = mbedtls_pk_parse_key(&pkctx, nul_terminated, blob_len + 1, NULL, 0);
free(nul_terminated);
}
if (ret != 0) {
mbedtls_pk_free(&pkctx);
return PM3_EINVARG;
}
int res = pcrypto_extract_priv_scalar_from_pk(&pkctx, curveid, out_priv, out_priv_len);
mbedtls_pk_free(&pkctx);
return res;
}
static int pcrypto_parse_ec_private_scalar_or_blob(const uint8_t *blob, size_t blob_len,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (blob == NULL || out_priv == NULL || blob_len == 0 || out_priv_len == 0) {
return PM3_EINVARG;
}
if (blob_len == out_priv_len &&
pcrypto_validate_raw_scalar(blob, blob_len, curveid) == PM3_SUCCESS) {
memcpy(out_priv, blob, out_priv_len);
return PM3_SUCCESS;
}
return pcrypto_parse_ec_private_blob(blob, blob_len, curveid, out_priv, out_priv_len);
}
static int pcrypto_parse_ec_private_base64(const char *input,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (input == NULL || out_priv == NULL || out_priv_len == 0) {
return PM3_EINVARG;
}
char compact[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t compact_len = 0;
int res = str_copy_without_whitespace(input, compact, sizeof(compact), &compact_len);
if (res != PM3_SUCCESS || compact_len == 0) {
return PM3_EINVARG;
}
size_t decoded_capacity = ((compact_len * 3) / 4) + 4;
uint8_t *decoded = calloc(decoded_capacity, sizeof(uint8_t));
if (decoded == NULL) {
return PM3_EMALLOC;
}
size_t decoded_len = 0;
int b64_res = mbedtls_base64_decode(decoded, decoded_capacity, &decoded_len,
(const unsigned char *)compact, compact_len);
if (b64_res != 0 || decoded_len == 0) {
free(decoded);
return PM3_EINVARG;
}
res = pcrypto_parse_ec_private_scalar_or_blob(decoded, decoded_len, curveid, out_priv, out_priv_len);
free(decoded);
return res;
}
static int pcrypto_validate_raw_scalar(const uint8_t *scalar, size_t scalar_len, mbedtls_ecp_group_id curveid) {
if (scalar == NULL || scalar_len == 0) {
return PM3_EINVARG;
}
mbedtls_ecp_group grp;
mbedtls_mpi d;
mbedtls_ecp_group_init(&grp);
mbedtls_mpi_init(&d);
int status = PM3_ESOFT;
if (mbedtls_ecp_group_load(&grp, curveid) != 0) {
goto out;
}
if (mbedtls_mpi_read_binary(&d, scalar, scalar_len) != 0) {
status = PM3_EINVARG;
goto out;
}
if (mbedtls_ecp_check_privkey(&grp, &d) != 0) {
status = PM3_EINVARG;
goto out;
}
status = PM3_SUCCESS;
out:
mbedtls_mpi_free(&d);
mbedtls_ecp_group_free(&grp);
return status;
}
static int pcrypto_parse_ec_private_text(const char *input, bool allow_file_path,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len);
static int pcrypto_parse_ec_private_file(const char *path,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (path == NULL || out_priv == NULL || out_priv_len == 0) {
return PM3_EINVARG;
}
FILE *f = fopen(path, "rb");
if (f == NULL) {
return PM3_EFILE;
}
if (fseek(f, 0, SEEK_END) != 0) {
fclose(f);
return PM3_EFILE;
}
long file_len_l = ftell(f);
if (file_len_l < 0) {
fclose(f);
return PM3_EFILE;
}
if ((size_t)file_len_l > PCRYPTO_MAX_KEY_FILE_BYTES) {
fclose(f);
return PM3_EOVFLOW;
}
if (fseek(f, 0, SEEK_SET) != 0) {
fclose(f);
return PM3_EFILE;
}
size_t file_len = (size_t)file_len_l;
uint8_t *data = calloc(file_len + 1, sizeof(uint8_t));
if (data == NULL) {
fclose(f);
return PM3_EMALLOC;
}
size_t read_len = fread(data, 1, file_len, f);
fclose(f);
if (read_len != file_len) {
free(data);
return PM3_EFILE;
}
int res = pcrypto_parse_ec_private_scalar_or_blob(data, file_len, curveid, out_priv, out_priv_len);
if (res == PM3_SUCCESS) {
free(data);
return PM3_SUCCESS;
}
char *text = calloc(file_len + 1, sizeof(char));
if (text == NULL) {
free(data);
return PM3_EMALLOC;
}
memcpy(text, data, file_len);
text[file_len] = '\0';
free(data);
res = pcrypto_parse_ec_private_text(text, false, curveid, out_priv, out_priv_len);
free(text);
return res;
}
static int pcrypto_parse_ec_private_text(const char *input, bool allow_file_path,
mbedtls_ecp_group_id curveid,
uint8_t *out_priv, size_t out_priv_len) {
if (input == NULL || out_priv == NULL || out_priv_len == 0) {
return PM3_EINVARG;
}
char normalized[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t input_len = strlen(input);
if (input_len >= sizeof(normalized)) {
return PM3_EOVFLOW;
}
memcpy(normalized, input, input_len + 1);
str_trim_ascii_inplace(normalized);
if (normalized[0] == '\0') {
return PM3_EINVARG;
}
if (allow_file_path) {
char *resolved_path = NULL;
if (searchFile(&resolved_path, RESOURCES_SUBDIR, normalized, "", true) == PM3_SUCCESS) {
int res = pcrypto_parse_ec_private_file(resolved_path, curveid, out_priv, out_priv_len);
free(resolved_path);
return res;
}
}
// Only unescape after path resolution fails, to avoid mutating valid paths
// (for example Windows paths containing '\t', '\n' or '\r').
str_unescape_newlines_inplace(normalized);
uint8_t decoded[PCRYPTO_MAX_KEY_INPUT] = {0};
int decoded_len = -1;
char compact[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t compact_len = 0;
if (str_copy_without_whitespace(normalized, compact, sizeof(compact), &compact_len) == PM3_SUCCESS &&
compact_len > 0) {
decoded_len = hex_to_bytes(compact, decoded, sizeof(decoded));
}
if (decoded_len > 0) {
int res = pcrypto_parse_ec_private_scalar_or_blob(decoded, (size_t)decoded_len, curveid, out_priv, out_priv_len);
if (res == PM3_SUCCESS) {
return PM3_SUCCESS;
}
}
int res = pcrypto_parse_ec_private_blob((const uint8_t *)normalized, strlen(normalized),
curveid, out_priv, out_priv_len);
if (res == PM3_SUCCESS) {
return PM3_SUCCESS;
}
return pcrypto_parse_ec_private_base64(normalized, curveid, out_priv, out_priv_len);
}
int ensure_ec_private_key(const char *input_or_path, mbedtls_ecp_group_id curveid, uint8_t *out_priv, size_t out_priv_len) {
return pcrypto_parse_ec_private_text(input_or_path, true, curveid, out_priv, out_priv_len);
}
// ============================================================================
// EC Public Key Loading
// ============================================================================
//
// Output format: uncompressed point 04 || X || Y
// For P-256 this is 65 bytes.
//
// Accepted input formats:
// - Raw uncompressed point bytes: 04 || X || Y (e.g. 65 bytes for P-256)
// - Raw X || Y coordinates: X || Y (e.g. 64 bytes for P-256)
// - Compressed point: 02/03 || X (e.g. 33 bytes for P-256)
// - DER-encoded SubjectPublicKeyInfo blob
// - PEM-encoded public key (-----BEGIN PUBLIC KEY-----)
// - Hex string of any of the above
// - Base64-encoded blob of any of the above
// - File path (PEM or DER)
static int pcrypto_extract_pub_point_from_pk(const mbedtls_pk_context *pkctx,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (pkctx == NULL || out_pub == NULL || out_pub_len == 0) {
return PM3_EINVARG;
}
mbedtls_pk_type_t pk_type = mbedtls_pk_get_type(pkctx);
if (!(pk_type == MBEDTLS_PK_ECKEY || pk_type == MBEDTLS_PK_ECKEY_DH || pk_type == MBEDTLS_PK_ECDSA)) {
return PM3_EINVARG;
}
mbedtls_ecp_keypair *ec = mbedtls_pk_ec(*pkctx);
if (ec == NULL || ec->grp.id != curveid) {
return PM3_EINVARG;
}
size_t coord_len = (ec->grp.nbits + 7) / 8;
size_t expected_len = 1 + 2 * coord_len;
if (out_pub_len < expected_len) {
return PM3_EOVFLOW;
}
size_t written = 0;
int ret = mbedtls_ecp_point_write_binary(&ec->grp, &ec->Q, MBEDTLS_ECP_PF_UNCOMPRESSED,
&written, out_pub, out_pub_len);
if (ret != 0 || written != expected_len) {
return PM3_ESOFT;
}
return PM3_SUCCESS;
}
// Decompress a compressed EC point (02/03 || X) to uncompressed (04 || X || Y).
// Bundled mbedtls does not support reading compressed points.
// Based on https://github.com/mwarning/mbedtls-ecp-compression
static int pcrypto_decompress_ec_point(const uint8_t *compressed, size_t comp_len,
const mbedtls_ecp_group *grp,
uint8_t *out, size_t out_len) {
size_t coord_len = (grp->nbits + 7) / 8;
if (comp_len != 1 + coord_len || (compressed[0] != 0x02 && compressed[0] != 0x03)) {
return PM3_EINVARG;
}
if (out_len < 1 + 2 * coord_len) {
return PM3_EOVFLOW;
}
// Solve y = sqrt(x^3 + ax + b) mod p, using y = rhs^((p+1)/4) mod p (valid for p ≡ 3 mod 4).
// Factor as: r = x(x^2 + a) + b to save one multiplication.
mbedtls_mpi r, x, n;
mbedtls_mpi_init(&r);
mbedtls_mpi_init(&x);
mbedtls_mpi_init(&n);
// Copy X coordinate and output prefix
memcpy(out, compressed, comp_len);
out[0] = 0x04;
int ok = (mbedtls_mpi_read_binary(&x, compressed + 1, coord_len) == 0);
// r = x^2
ok = ok && (mbedtls_mpi_mul_mpi(&r, &x, &x) == 0);
// r = x^2 + a (A.p == NULL means implicit a = -3 for NIST curves)
if (ok && grp->A.p == NULL) {
ok = (mbedtls_mpi_sub_int(&r, &r, 3) == 0);
} else {
ok = ok && (mbedtls_mpi_add_mpi(&r, &r, &grp->A) == 0);
}
// r = x(x^2 + a)
ok = ok && (mbedtls_mpi_mul_mpi(&r, &r, &x) == 0);
// r = x(x^2 + a) + b
ok = ok && (mbedtls_mpi_add_mpi(&r, &r, &grp->B) == 0);
// n = (p + 1) / 4
ok = ok && (mbedtls_mpi_add_int(&n, &grp->P, 1) == 0);
ok = ok && (mbedtls_mpi_shift_r(&n, 2) == 0);
// r = r^((p+1)/4) mod p
ok = ok && (mbedtls_mpi_exp_mod(&r, &r, &n, &grp->P, NULL) == 0);
// Fix parity: 02 = even y, 03 = odd y
if (ok && ((compressed[0] == 0x03) != mbedtls_mpi_get_bit(&r, 0))) {
ok = (mbedtls_mpi_sub_mpi(&r, &grp->P, &r) == 0);
}
// Write Y coordinate
ok = ok && (mbedtls_mpi_write_binary(&r, out + 1 + coord_len, coord_len) == 0);
mbedtls_mpi_free(&r);
mbedtls_mpi_free(&x);
mbedtls_mpi_free(&n);
return ok ? PM3_SUCCESS : PM3_ESOFT;
}
static int pcrypto_validate_raw_ec_point(const uint8_t *point, size_t point_len,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (point == NULL || out_pub == NULL || point_len == 0 || out_pub_len == 0) {
return PM3_EINVARG;
}
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
mbedtls_ecp_group_init(&grp);
mbedtls_ecp_point_init(&Q);
int status = PM3_ESOFT;
if (mbedtls_ecp_group_load(&grp, curveid) != 0) {
goto out;
}
size_t coord_len = (grp.nbits + 7) / 8;
size_t expected_uncompressed = 1 + 2 * coord_len;
// Build a properly-formatted point for mbedtls
uint8_t buf[133]; // max for P-521: 1 + 2*66
size_t buf_len = 0;
if (point_len == expected_uncompressed && point[0] == 0x04) {
// Already uncompressed: 04 || X || Y
memcpy(buf, point, point_len);
buf_len = point_len;
} else if (point_len == 2 * coord_len) {
// Raw X || Y, add 0x04 prefix
buf[0] = 0x04;
memcpy(buf + 1, point, point_len);
buf_len = 1 + point_len;
} else if (point_len == 1 + coord_len && (point[0] == 0x02 || point[0] == 0x03)) {
// Compressed point: decompress (bundled mbedtls lacks read support)
if (pcrypto_decompress_ec_point(point, point_len, &grp, buf, sizeof(buf)) != PM3_SUCCESS) {
status = PM3_EINVARG;
goto out;
}
buf_len = expected_uncompressed;
} else {
status = PM3_EINVARG;
goto out;
}
if (mbedtls_ecp_point_read_binary(&grp, &Q, buf, buf_len) != 0) {
status = PM3_EINVARG;
goto out;
}
if (mbedtls_ecp_check_pubkey(&grp, &Q) != 0) {
status = PM3_EINVARG;
goto out;
}
// Write out as uncompressed
if (out_pub_len < expected_uncompressed) {
status = PM3_EOVFLOW;
goto out;
}
size_t written = 0;
if (mbedtls_ecp_point_write_binary(&grp, &Q, MBEDTLS_ECP_PF_UNCOMPRESSED,
&written, out_pub, out_pub_len) != 0) {
status = PM3_ESOFT;
goto out;
}
status = PM3_SUCCESS;
out:
mbedtls_ecp_point_free(&Q);
mbedtls_ecp_group_free(&grp);
return status;
}
static int pcrypto_parse_ec_public_blob(const uint8_t *blob, size_t blob_len,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (blob == NULL || out_pub == NULL || blob_len == 0 || out_pub_len == 0) {
return PM3_EINVARG;
}
// Try as raw EC point first (uncompressed, X||Y, or compressed)
int res = pcrypto_validate_raw_ec_point(blob, blob_len, curveid, out_pub, out_pub_len);
if (res == PM3_SUCCESS) {
return PM3_SUCCESS;
}
// Try as DER/PEM SubjectPublicKeyInfo via mbedtls pk parser
mbedtls_pk_context pkctx;
mbedtls_pk_init(&pkctx);
int ret = mbedtls_pk_parse_public_key(&pkctx, blob, blob_len);
if (ret != 0) {
// mbedtls_pk_parse_public_key requires NUL-terminated PEM
uint8_t *nul_terminated = calloc(blob_len + 1, sizeof(uint8_t));
if (nul_terminated == NULL) {
mbedtls_pk_free(&pkctx);
return PM3_EMALLOC;
}
memcpy(nul_terminated, blob, blob_len);
ret = mbedtls_pk_parse_public_key(&pkctx, nul_terminated, blob_len + 1);
free(nul_terminated);
}
if (ret != 0) {
mbedtls_pk_free(&pkctx);
return PM3_EINVARG;
}
res = pcrypto_extract_pub_point_from_pk(&pkctx, curveid, out_pub, out_pub_len);
mbedtls_pk_free(&pkctx);
return res;
}
static int pcrypto_parse_ec_public_text(const char *input, bool allow_file_path,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len);
static int pcrypto_parse_ec_public_file(const char *path,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (path == NULL || out_pub == NULL || out_pub_len == 0) {
return PM3_EINVARG;
}
FILE *f = fopen(path, "rb");
if (f == NULL) {
return PM3_EFILE;
}
if (fseek(f, 0, SEEK_END) != 0) {
fclose(f);
return PM3_EFILE;
}
long file_len_l = ftell(f);
if (file_len_l < 0) {
fclose(f);
return PM3_EFILE;
}
if ((size_t)file_len_l > PCRYPTO_MAX_KEY_FILE_BYTES) {
fclose(f);
return PM3_EOVFLOW;
}
if (fseek(f, 0, SEEK_SET) != 0) {
fclose(f);
return PM3_EFILE;
}
size_t file_len = (size_t)file_len_l;
uint8_t *data = calloc(file_len + 1, sizeof(uint8_t));
if (data == NULL) {
fclose(f);
return PM3_EMALLOC;
}
size_t read_len = fread(data, 1, file_len, f);
fclose(f);
if (read_len != file_len) {
free(data);
return PM3_EFILE;
}
int res = pcrypto_parse_ec_public_blob(data, file_len, curveid, out_pub, out_pub_len);
if (res == PM3_SUCCESS) {
free(data);
return PM3_SUCCESS;
}
char *text = calloc(file_len + 1, sizeof(char));
if (text == NULL) {
free(data);
return PM3_EMALLOC;
}
memcpy(text, data, file_len);
text[file_len] = '\0';
free(data);
res = pcrypto_parse_ec_public_text(text, false, curveid, out_pub, out_pub_len);
free(text);
return res;
}
static int pcrypto_parse_ec_public_base64(const char *input,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (input == NULL || out_pub == NULL || out_pub_len == 0) {
return PM3_EINVARG;
}
char compact[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t compact_len = 0;
int res = str_copy_without_whitespace(input, compact, sizeof(compact), &compact_len);
if (res != PM3_SUCCESS || compact_len == 0) {
return PM3_EINVARG;
}
size_t decoded_capacity = ((compact_len * 3) / 4) + 4;
uint8_t *decoded = calloc(decoded_capacity, sizeof(uint8_t));
if (decoded == NULL) {
return PM3_EMALLOC;
}
size_t decoded_len = 0;
int b64_res = mbedtls_base64_decode(decoded, decoded_capacity, &decoded_len,
(const unsigned char *)compact, compact_len);
if (b64_res != 0 || decoded_len == 0) {
free(decoded);
return PM3_EINVARG;
}
res = pcrypto_parse_ec_public_blob(decoded, decoded_len, curveid, out_pub, out_pub_len);
free(decoded);
return res;
}
static int pcrypto_parse_ec_public_text(const char *input, bool allow_file_path,
mbedtls_ecp_group_id curveid,
uint8_t *out_pub, size_t out_pub_len) {
if (input == NULL || out_pub == NULL || out_pub_len == 0) {
return PM3_EINVARG;
}
char normalized[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t input_len = strlen(input);
if (input_len >= sizeof(normalized)) {
return PM3_EOVFLOW;
}
memcpy(normalized, input, input_len + 1);
str_trim_ascii_inplace(normalized);
if (normalized[0] == '\0') {
return PM3_EINVARG;
}
if (allow_file_path) {
char *resolved_path = NULL;
if (searchFile(&resolved_path, RESOURCES_SUBDIR, normalized, "", true) == PM3_SUCCESS) {
int res = pcrypto_parse_ec_public_file(resolved_path, curveid, out_pub, out_pub_len);
free(resolved_path);
return res;
}
}
// Only unescape after path resolution fails
str_unescape_newlines_inplace(normalized);
// Try as hex string
uint8_t decoded[PCRYPTO_MAX_KEY_INPUT] = {0};
int decoded_len = -1;
char compact[PCRYPTO_MAX_KEY_INPUT] = {0};
size_t compact_len = 0;
if (str_copy_without_whitespace(normalized, compact, sizeof(compact), &compact_len) == PM3_SUCCESS &&
compact_len > 0) {
decoded_len = hex_to_bytes(compact, decoded, sizeof(decoded));
}
if (decoded_len > 0) {
int res = pcrypto_parse_ec_public_blob(decoded, (size_t)decoded_len, curveid, out_pub, out_pub_len);
if (res == PM3_SUCCESS) {
return PM3_SUCCESS;
}
}
// Try as raw blob (PEM)
int res = pcrypto_parse_ec_public_blob((const uint8_t *)normalized, strlen(normalized),
curveid, out_pub, out_pub_len);
if (res == PM3_SUCCESS) {
return PM3_SUCCESS;
}
// Try as base64
return pcrypto_parse_ec_public_base64(normalized, curveid, out_pub, out_pub_len);
}
int ensure_ec_public_key(const char *input_or_path, mbedtls_ecp_group_id curveid, uint8_t *out_pub, size_t out_pub_len) {
return pcrypto_parse_ec_public_text(input_or_path, true, curveid, out_pub, out_pub_len);
}
void des_encrypt(void *out, const void *in, const void *key) {
mbedtls_des_context ctx;
mbedtls_des_setkey_enc(&ctx, key);
mbedtls_des_crypt_ecb(&ctx, in, out);
mbedtls_des_free(&ctx);
}
void des_decrypt(void *out, const void *in, const void *key) {
mbedtls_des_context ctx;
mbedtls_des_setkey_dec(&ctx, key);
mbedtls_des_crypt_ecb(&ctx, in, out);
mbedtls_des_free(&ctx);
}
void des_encrypt_ecb(void *out, const void *in, const int length, const void *key) {
for (int i = 0; i < length; i += 8) {
des_encrypt((uint8_t *)out + i, (uint8_t *)in + i, key);
}
}
void des_decrypt_ecb(void *out, const void *in, const int length, const void *key) {
for (int i = 0; i < length; i += 8) {
des_decrypt((uint8_t *)out + i, (uint8_t *)in + i, key);
}
}
void des_encrypt_cbc(void *out, const void *in, const int length, const void *key, uint8_t *iv) {
mbedtls_des_context ctx;
mbedtls_des_setkey_enc(&ctx, key);
mbedtls_des_crypt_cbc(&ctx, MBEDTLS_DES_ENCRYPT, length, iv, in, out);
}
void des_decrypt_cbc(void *out, const void *in, const int length, const void *key, uint8_t *iv) {
mbedtls_des_context ctx;
mbedtls_des_setkey_dec(&ctx, key);
mbedtls_des_crypt_cbc(&ctx, MBEDTLS_DES_DECRYPT, length, iv, in, out);
}
// FIPS PUB 113 - Computer Data Authentication.
// https://csrc.nist.gov/files/pubs/fips/113/final/docs/fips113.pdf
int des_mac(const void *key, const void *input, size_t length, uint8_t *mac, size_t mac_len) {
if (key == NULL || mac == NULL || mac_len == 0 || mac_len > 8) {
return PM3_EINVARG;
}
if (length && input == NULL) {
return PM3_EINVARG;
}
// zero pad up to a whole number of blocks, an empty message is one block
size_t n = (length + 7) & ~(size_t)7;
if (n == 0) {
n = 8;
}
uint8_t *buf = calloc(n * 2, sizeof(uint8_t));
if (buf == NULL) {
return PM3_EMALLOC;
}
uint8_t *out = buf + n;
if (length) {
memcpy(buf, input, length);
}
uint8_t iv[8] = {0};
des_encrypt_cbc(out, buf, (int)n, key, iv);
// the MAC is the leading bits of the last cipher block
memcpy(mac, out + n - 8, mac_len);
free(buf);
return PM3_SUCCESS;
}
void des3_encrypt(void *out, const void *in, const void *key, uint8_t keycount) {
switch (keycount) {
case 1:
des_encrypt(out, in, key);
break;
case 2: {
mbedtls_des3_context ctx3;
mbedtls_des3_set2key_enc(&ctx3, key);
mbedtls_des3_crypt_ecb(&ctx3, in, out);
mbedtls_des3_free(&ctx3);
break;
}
case 3: {
mbedtls_des3_context ctx3;
mbedtls_des3_set3key_enc(&ctx3, key);
mbedtls_des3_crypt_ecb(&ctx3, in, out);
mbedtls_des3_free(&ctx3);
break;
}
default:
break;
}
}
void des3_decrypt(void *out, const void *in, const void *key, uint8_t keycount) {
switch (keycount) {
case 1:
des_encrypt(out, in, key);
break;
case 2: {
mbedtls_des3_context ctx3;
mbedtls_des3_set2key_dec(&ctx3, key);
mbedtls_des3_crypt_ecb(&ctx3, in, out);
mbedtls_des3_free(&ctx3);
break;
}
case 3: {
mbedtls_des3_context ctx3;
mbedtls_des3_set3key_dec(&ctx3, key);
mbedtls_des3_crypt_ecb(&ctx3, in, out);
mbedtls_des3_free(&ctx3);
break;
}
default:
break;
}
}
// NIST Special Publication 800-38A — Recommendation for block cipher modes of operation: methods and techniques, 2001.
int aes_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, sizeof(iiv));
}
mbedtls_aes_context aes;
mbedtls_aes_init(&aes);
if (mbedtls_aes_setkey_enc(&aes, key, 128)) {
return 1;
}
if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, length, iiv, input, output)) {
return 2;
}
mbedtls_aes_free(&aes);
return PM3_SUCCESS;
}
int aes_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, 16);
}
mbedtls_aes_context aes;
mbedtls_aes_init(&aes);
if (mbedtls_aes_setkey_dec(&aes, key, 128)) {
return 1;
}
if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, length, iiv, input, output)) {
return 2;
}
mbedtls_aes_free(&aes);
return PM3_SUCCESS;
}
// NIST Special Publication 800-38A — Recommendation for block cipher modes of operation: methods and techniques, 2001.
int aes256_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, sizeof(iiv));
}
mbedtls_aes_context aes;
mbedtls_aes_init(&aes);
if (mbedtls_aes_setkey_enc(&aes, key, 256)) {
return 1;
}
if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, length, iiv, input, output)) {
return 2;
}
mbedtls_aes_free(&aes);
return PM3_SUCCESS;
}
int aes256_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, 16);
}
mbedtls_aes_context aes;
mbedtls_aes_init(&aes);
if (mbedtls_aes_setkey_dec(&aes, key, 256)) {
return 1;
}
if (mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, length, iiv, input, output)) {
return 2;
}
mbedtls_aes_free(&aes);
return PM3_SUCCESS;
}
// NIST Special Publication 800-38B — Recommendation for block cipher modes of operation: The CMAC mode for authentication.
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/AES_CMAC.pdf
int aes_cmac(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
memset(mac, 0x00, 16);
// NIST 800-38B
return mbedtls_aes_cmac_prf_128(key, MBEDTLS_AES_BLOCK_SIZE, input, length, mac);
}
int aes_cmac8(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
uint8_t cmac_tmp[16] = {0};
memset(mac, 0x00, 8);
int res = aes_cmac(iv, key, input, cmac_tmp, length);
if (res) {
return res;
}
for (int i = 0; i < 8; i++) {
mac[i] = cmac_tmp[i * 2 + 1];
}
return PM3_SUCCESS;
}
static uint8_t fixed_rand_value[250] = {0};
static int fixed_rand(void *rng_state, unsigned char *output, size_t len) {
if (len <= 250) {
memcpy(output, fixed_rand_value, len);
} else {
memset(output, 0x00, len);
}
return PM3_SUCCESS;
}
int sha1hash(uint8_t *input, int length, uint8_t *hash) {
if (!hash || !input) {
return 1;
}
mbedtls_sha1(input, length, hash);
return PM3_SUCCESS;
}
int sha256hash(uint8_t *input, int length, uint8_t *hash) {
if (!hash || !input) {
return 1;
}
mbedtls_sha256_context sctx;
mbedtls_sha256_init(&sctx);
mbedtls_sha256_starts(&sctx, 0); // SHA-256, not 224
mbedtls_sha256_update(&sctx, input, length);
mbedtls_sha256_finish(&sctx, hash);
mbedtls_sha256_free(&sctx);
return PM3_SUCCESS;
}
int sha512hash(uint8_t *input, int length, uint8_t *hash) {
if (!hash || !input) {
return 1;
}
mbedtls_sha512_context sctx;
mbedtls_sha512_init(&sctx);
mbedtls_sha512_starts(&sctx, 0); //SHA-512, not 384
mbedtls_sha512_update(&sctx, input, length);
mbedtls_sha512_finish(&sctx, hash);
mbedtls_sha512_free(&sctx);
return PM3_SUCCESS;
}
static int ecdsa_init_str(mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id curveid, const char *key_d, const char *key_x, const char *key_y) {
if (!ctx) {
return 1;
}
mbedtls_ecdsa_init(ctx);
int res = mbedtls_ecp_group_load(&ctx->grp, curveid);
if (res) {
return res;
}
if (key_d) {
res = mbedtls_mpi_read_string(&ctx->d, 16, key_d);
if (res) {
return res;
}
}
if (key_x && key_y) {
res = mbedtls_ecp_point_read_string(&ctx->Q, 16, key_x, key_y);
if (res) {
return res;
}
}
return PM3_SUCCESS;
}
static int ecdsa_init(mbedtls_ecdsa_context *ctx, mbedtls_ecp_group_id curveid, uint8_t *key_d, uint8_t *key_xy) {
if (!ctx)
return 1;
int res;
mbedtls_ecdsa_init(ctx);
res = mbedtls_ecp_group_load(&ctx->grp, curveid);
if (res)
return res;
size_t keylen = (ctx->grp.nbits + 7) / 8;
if (key_d) {
res = mbedtls_mpi_read_binary(&ctx->d, key_d, keylen);
if (res)
return res;
}
if (key_xy) {
res = mbedtls_ecp_point_read_binary(&ctx->grp, &ctx->Q, key_xy, keylen * 2 + 1);
if (res)
return res;
}
return PM3_SUCCESS;
}
int ecdsa_key_create(mbedtls_ecp_group_id curveid, uint8_t *key_d, uint8_t *key_xy) {
int res;
mbedtls_ecdsa_context ctx;
res = ecdsa_init(&ctx, curveid, NULL, NULL);
if (res)
goto exit;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "ecdsaproxmark";
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_init(&ctr_drbg);
res = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers, strlen(pers));
if (res)
goto exit;
res = mbedtls_ecdsa_genkey(&ctx, curveid, mbedtls_ctr_drbg_random, &ctr_drbg);
if (res)
goto exit;
size_t keylen = (ctx.grp.nbits + 7) / 8;
res = mbedtls_mpi_write_binary(&ctx.d, key_d, keylen);
if (res)
goto exit;
size_t public_keylen = 0;
uint8_t public_key[200] = {0};
res = mbedtls_ecp_point_write_binary(&ctx.grp, &ctx.Q, MBEDTLS_ECP_PF_UNCOMPRESSED, &public_keylen, public_key, sizeof(public_key));
if (res)
goto exit;
if (public_keylen != 1 + 2 * keylen) { // 0x04 <key x><key y>
res = 1;
goto exit;
}
memcpy(key_xy, public_key, public_keylen);
exit:
mbedtls_entropy_free(&entropy);
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_ecdsa_free(&ctx);
return res;
}
char *ecdsa_get_error(int ret) {
static char retstr[300];
memset(retstr, 0x00, sizeof(retstr));
mbedtls_strerror(ret, retstr, sizeof(retstr));
return retstr;
}
int ecdsa_public_key_from_pk(mbedtls_pk_context *pk, mbedtls_ecp_group_id curveid, uint8_t *key, size_t keylen) {
int res = 0;
size_t realkeylen = 0;
mbedtls_ecdsa_context ctx;
mbedtls_ecdsa_init(&ctx);
res = mbedtls_ecp_group_load(&ctx.grp, curveid);
if (res)
goto exit;
size_t private_keylen = (ctx.grp.nbits + 7) / 8;
if (keylen < 1 + 2 * private_keylen) {
res = 1;
goto exit;
}
res = mbedtls_ecdsa_from_keypair(&ctx, mbedtls_pk_ec(*pk));
if (res)
goto exit;
res = mbedtls_ecp_point_write_binary(&ctx.grp, &ctx.Q, MBEDTLS_ECP_PF_UNCOMPRESSED, &realkeylen, key, keylen);
if (realkeylen != 1 + 2 * private_keylen)
res = 2;
exit:
mbedtls_ecdsa_free(&ctx);
return res;
}
int ecdsa_signature_create(mbedtls_ecp_group_id curveid, uint8_t *key_d, uint8_t *key_xy, uint8_t *input, int length, uint8_t *signature, size_t *signaturelen, bool hash) {
int res;
*signaturelen = 0;
uint8_t shahash[32] = {0};
res = sha256hash(input, length, shahash);
if (res)
return res;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "ecdsaproxmark";
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_init(&ctr_drbg);
res = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers, strlen(pers));
if (res)
goto exit;
mbedtls_ecdsa_context ctx;
res = ecdsa_init(&ctx, curveid, key_d, key_xy);
if (res)
goto exit;
res = mbedtls_ecdsa_write_signature(
&ctx,
MBEDTLS_MD_SHA256,
hash ? shahash : input,
hash ? sizeof(shahash) : length,
signature,
signaturelen,
mbedtls_ctr_drbg_random,
&ctr_drbg
);
exit:
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_ecdsa_free(&ctx);
return res;
}
static int ecdsa_signature_create_test(mbedtls_ecp_group_id curveid, const char *key_d, const char *key_x, const char *key_y, const char *random, uint8_t *input, int length, uint8_t *signature, size_t *signaturelen) {
int res;
*signaturelen = 0;
uint8_t shahash[32] = {0};
res = sha256hash(input, length, shahash);
if (res)
return res;
int rndlen = 0;
param_gethex_to_eol(random, 0, fixed_rand_value, sizeof(fixed_rand_value), &rndlen);
mbedtls_ecdsa_context ctx;
res = ecdsa_init_str(&ctx, curveid, key_d, key_x, key_y);
if (res)
return res;
res = mbedtls_ecdsa_write_signature(&ctx, MBEDTLS_MD_SHA256, shahash, sizeof(shahash), signature, signaturelen, fixed_rand, NULL);
mbedtls_ecdsa_free(&ctx);
return res;
}
static int ecdsa_signature_verify_keystr(mbedtls_ecp_group_id curveid, const char *key_x, const char *key_y, uint8_t *input, int length, uint8_t *signature, size_t signaturelen, bool hash) {
int res;
uint8_t shahash[32] = {0};
res = sha256hash(input, length, shahash);
if (res)
return res;
mbedtls_ecdsa_context ctx;
res = ecdsa_init_str(&ctx, curveid, NULL, key_x, key_y);
if (res)
return res;
res = mbedtls_ecdsa_read_signature(
&ctx,
hash ? shahash : input,
hash ? sizeof(shahash) : length,
signature,
signaturelen
);
mbedtls_ecdsa_free(&ctx);
return res;
}
int ecdsa_signature_verify(mbedtls_ecp_group_id curveid, uint8_t *key_xy, uint8_t *input, int length, uint8_t *signature, size_t signaturelen, bool hash) {
int res;
uint8_t shahash[32] = {0};
if (hash) {
res = sha256hash(input, length, shahash);
if (res) {
return res;
}
}
mbedtls_ecdsa_context ctx;
res = ecdsa_init(&ctx, curveid, NULL, key_xy);
if (res) {
return res;
}
res = mbedtls_ecdsa_read_signature(
&ctx,
hash ? shahash : input,
hash ? sizeof(shahash) : length,
signature,
signaturelen
);
mbedtls_ecdsa_free(&ctx);
return res;
}
// take signature bytes, converts to ASN1 signature and tries to verify
int ecdsa_signature_r_s_verify(mbedtls_ecp_group_id curveid, uint8_t *key_xy, uint8_t *input, int length, uint8_t *r_s, size_t r_s_len, bool hash) {
uint8_t signature[MBEDTLS_ECDSA_MAX_LEN] = {0};
size_t signature_len = 0;
// convert r & s to ASN.1 signature
mbedtls_mpi r, s;
mbedtls_mpi_init(&r);
mbedtls_mpi_init(&s);
mbedtls_mpi_read_binary(&r, r_s, r_s_len / 2);
mbedtls_mpi_read_binary(&s, r_s + r_s_len / 2, r_s_len / 2);
int res = ecdsa_signature_to_asn1(&r, &s, signature, &signature_len);
if (res < 0) {
return res;
}
res = ecdsa_signature_verify(curveid, key_xy, input, length, signature, signature_len, hash);
mbedtls_mpi_free(&r);
mbedtls_mpi_free(&s);
return res;
}
#define T_PRIVATE_KEY "C477F9F65C22CCE20657FAA5B2D1D8122336F851A508A1ED04E479C34985BF96"
#define T_Q_X "B7E08AFDFE94BAD3F1DC8C734798BA1C62B3A0AD1E9EA2A38201CD0889BC7A19"
#define T_Q_Y "3603F747959DBF7A4BB226E41928729063ADC7AE43529E61B563BBC606CC5E09"
#define T_K "7A1A7E52797FC8CAAA435D2A4DACE39158504BF204FBE19F14DBB427FAEE50AE"
#define T_R "2B42F576D07F4165FF65D1F3B1500F81E44C316F1F0B3EF57325B69ACA46104F"
#define T_S "DC42C2122D6392CD3E3A993A89502A8198C1886FE69D262C4B329BDB6B63FAF1"
static int des_mac_test_one(const char *name, const uint8_t key[8], const uint8_t *data,
size_t len, const uint8_t *expect, size_t expect_len, bool verbose) {
uint8_t mac[8] = {0};
int res = des_mac(key, data, len, mac, expect_len);
if (res != PM3_SUCCESS) {
return res;
}
if (memcmp(mac, expect, expect_len) != 0) {
if (verbose) {
PrintAndLogEx(FAILED, " %s got %s", name, sprint_hex_inrow(mac, expect_len));
}
return PM3_ESOFT;
}
if (verbose) {
PrintAndLogEx(INFO, " %s %s ( %s )", name, sprint_hex_inrow(mac, expect_len), _GREEN_("ok"));
}
return PM3_SUCCESS;
}
int des_mac_test(bool verbose) {
if (verbose) {
PrintAndLogEx(INFO, "DES-MAC FIPS 113 test");
} else {
PrintAndLogEx(INFO, "DES-MAC FIPS 113 test " NOLF);
}
const uint8_t key[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
// the worked example of FIPS PUB 113, which publishes the 32 bit MAC
const uint8_t msg[] = "7654321 Now is the time for ";
const uint8_t full[8] = {0xF1, 0xD3, 0x0F, 0x68, 0x49, 0x31, 0x2C, 0xA4};
int res = des_mac_test_one("FIPS 113, 64 bit", key, msg, sizeof(msg) - 1, full, 8, verbose);
if (res == PM3_SUCCESS) {
res = des_mac_test_one("FIPS 113, 32 bit", key, msg, sizeof(msg) - 1, full, 4, verbose);
}
if (res == PM3_SUCCESS) {
res = des_mac_test_one("FIPS 113, 16 bit", key, msg, sizeof(msg) - 1, full, 2, verbose);
}
// one block of zero padding only
if (res == PM3_SUCCESS) {
const uint8_t empty[8] = {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D};
res = des_mac_test_one("empty message...", key, NULL, 0, empty, 8, verbose);
}
// exactly one block, so no padding is added
if (res == PM3_SUCCESS) {
const uint8_t one[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
const uint8_t want[8] = {0xCA, 0xDB, 0x67, 0x82, 0xEE, 0x2B, 0x48, 0x23};
res = des_mac_test_one("one whole block.", key, one, sizeof(one), want, 8, verbose);
}
if (verbose == false) {
PrintAndLogEx(NORMAL, (res == PM3_SUCCESS) ? "( " _GREEN_("ok") " )" : "( " _RED_("fail") " )");
}
return res;
}
int ecdsa_nist_test(bool verbose) {
int res;
uint8_t input[] = "Example of ECDSA with P-256";
mbedtls_ecp_group_id curveid = MBEDTLS_ECP_DP_SECP256R1;
int length = strlen((char *)input);
uint8_t signature[300] = {0};
size_t siglen = 0;
// NIST ecdsa test
if (verbose) {
PrintAndLogEx(INFO, "ECDSA NIST test " NOLF);
}
// make signature
res = ecdsa_signature_create_test(curveid, T_PRIVATE_KEY, T_Q_X, T_Q_Y, T_K, input, length, signature, &siglen);
// PrintAndLogEx(INFO, "res: %x signature[%x]: %s", (res < 0)? -res : res, siglen, sprint_hex(signature, siglen));
if (res != PM3_SUCCESS)
goto exit;
// check vectors
uint8_t rval[300] = {0};
uint8_t sval[300] = {0};
res = ecdsa_asn1_get_signature(signature, siglen, rval, sval);
if (res)
goto exit;
int slen = 0;
uint8_t rval_s[33] = {0};
param_gethex_to_eol(T_R, 0, rval_s, sizeof(rval_s), &slen);
uint8_t sval_s[33] = {0};
param_gethex_to_eol(T_S, 0, sval_s, sizeof(sval_s), &slen);
if (strncmp((char *)rval, (char *)rval_s, 32) || strncmp((char *)sval, (char *)sval_s, 32)) {
PrintAndLogEx(NORMAL, "( " _RED_("R or S check error") " )");
res = 100;
goto exit;
}
// verify signature
res = ecdsa_signature_verify_keystr(curveid, T_Q_X, T_Q_Y, input, length, signature, siglen, true);
if (res) {
goto exit;
}
// verify wrong signature
input[0] ^= 0xFF;
res = ecdsa_signature_verify_keystr(curveid, T_Q_X, T_Q_Y, input, length, signature, siglen, true);
if (res == false) {
res = 1;
goto exit;
}
if (verbose) {
PrintAndLogEx(NORMAL, "( " _GREEN_("ok") " )");
PrintAndLogEx(INFO, "ECDSA binary signature create/check test " NOLF);
}
// random ecdsa test
uint8_t key_d[32] = {0};
uint8_t key_xy[32 * 2 + 2] = {0};
memset(signature, 0x00, sizeof(signature));
siglen = 0;
res = ecdsa_key_create(curveid, key_d, key_xy);
if (res)
goto exit;
res = ecdsa_signature_create(curveid, key_d, key_xy, input, length, signature, &siglen, true);
if (res)
goto exit;
res = ecdsa_signature_verify(curveid, key_xy, input, length, signature, siglen, true);
if (res)
goto exit;
input[0] ^= 0xFF;
res = ecdsa_signature_verify(curveid, key_xy, input, length, signature, siglen, true);
if (!res)
goto exit;
if (verbose)
PrintAndLogEx(NORMAL, "( " _GREEN_("ok") " )");
return PM3_SUCCESS;
exit:
if (verbose)
PrintAndLogEx(NORMAL, "( " _RED_("fail") " )");
return res;
}
// iceman: todo, remove and use xor in commonutil.c
void bin_xor(uint8_t *d1, const uint8_t *d2, size_t len) {
for (size_t i = 0; i < len; i++) {
d1[i] = d1[i] ^ d2[i];
}
}
void AddISO9797M2Padding(uint8_t *ddata, size_t *ddatalen, uint8_t *sdata, size_t sdatalen, size_t blocklen) {
*ddatalen = sdatalen + 1;
*ddatalen += blocklen - *ddatalen % blocklen;
memset(ddata, 0, *ddatalen);
memcpy(ddata, sdata, sdatalen);
ddata[sdatalen] = ISO9797_M2_PAD_BYTE;
}
size_t FindISO9797M2PaddingDataLen(const uint8_t *data, size_t datalen) {
for (int i = datalen; i > 0; i--) {
if (data[i - 1] == 0x80)
return i - 1;
if (data[i - 1] != 0x00)
return 0;
}
return 0;
}
int blowfish_decrypt(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
if (iv)
memcpy(iiv, iv, 16);
mbedtls_blowfish_context blow;
mbedtls_blowfish_init(&blow);
if (mbedtls_blowfish_setkey(&blow, key, 64))
return 1;
if (mbedtls_blowfish_crypt_cbc(&blow, MBEDTLS_BLOWFISH_DECRYPT, length, iiv, input, output))
return 2;
mbedtls_blowfish_free(&blow);
return 0;
}
// Implementation from http://www.secg.org/sec1-v2.pdf#subsubsection.3.6.1
int ansi_x963_sha256(uint8_t *sharedSecret, size_t sharedSecretLen, uint8_t *sharedInfo, size_t sharedInfoLen, size_t keyDataLen, uint8_t *keyData) {
// sha256 hash has (practically) no max input len, so skipping that step
if (keyDataLen >= 32 * (pow(2, 32) - 1)) {
return 1;
}
uint32_t counter = 0x00000001;
for (int i = 0; i < (keyDataLen / 32); ++i) {
uint8_t *hashMaterial = calloc(4 + sharedSecretLen + sharedInfoLen, sizeof(uint8_t));
if (hashMaterial == NULL) {
PrintAndLogEx(WARNING, "Failed to allocate memory");
return 2;
}
memcpy(hashMaterial, sharedSecret, sharedSecretLen);
hashMaterial[sharedSecretLen] = (counter >> 24);
hashMaterial[sharedSecretLen + 1] = (counter >> 16) & 0xFF;
hashMaterial[sharedSecretLen + 2] = (counter >> 8) & 0xFF;
hashMaterial[sharedSecretLen + 3] = counter & 0xFF;
memcpy(hashMaterial + sharedSecretLen + 4, sharedInfo, sharedInfoLen);
uint8_t hash[32] = {0};
sha256hash(hashMaterial, 4 + sharedSecretLen + sharedInfoLen, hash);
free(hashMaterial);
memcpy(keyData + (32 * i), hash, 32);
counter++;
}
return 0;
}