Skip to content

Commit 60af55f

Browse files
chcmedeiroschcmedeiros
committed
review improvements
1 parent eb78f26 commit 60af55f

File tree

6 files changed

+59
-51
lines changed

6 files changed

+59
-51
lines changed

‎app/src/crypto.c

+31-31
Original file line numberDiff line numberDiff line change
@@ -540,8 +540,8 @@ __Z_INLINE zxerr_t copyKeys(keys_t *saplingKeys, key_kind_e requestedKeys, uint8
540540
return zxerr_ok;
541541
}
542542

543-
zxerr_t crypto_computeSaplingSeed(uint8_t *sk) {
544-
if (sk == NULL) {
543+
zxerr_t crypto_computeSaplingSeed(uint8_t spendingKey[static KEY_LENGTH]) {
544+
if (spendingKey == NULL ) {
545545
return zxerr_no_data;
546546
}
547547

@@ -552,10 +552,11 @@ zxerr_t crypto_computeSaplingSeed(uint8_t *sk) {
552552
HDPATH_LEN_DEFAULT,
553553
privateKeyData,
554554
NULL, NULL, 0));
555-
memcpy(sk, privateKeyData, KEY_LENGTH);
555+
memcpy(spendingKey, privateKeyData, KEY_LENGTH);
556556

557557
catch_cx_error:
558558
MEMZERO(privateKeyData, sizeof(privateKeyData));
559+
MEMZERO(spendingKey, KEY_LENGTH);
559560
return zxerr_ok;
560561
}
561562

@@ -570,16 +571,16 @@ zxerr_t crypto_generateSaplingKeys(uint8_t *output, uint16_t outputLen, key_kind
570571
keys_t saplingKeys = {0};
571572
uint8_t sk[KEY_LENGTH] = {0};
572573
CHECK_ZXERR(crypto_computeSaplingSeed(sk))
573-
CHECK_PARSER_OK(computeMasterFromSeed(sk, saplingKeys.spendingKey));
574+
CHECK_PARSER_OK(computeMasterFromSeed((const uint8_t*) sk, saplingKeys.spendingKey));
574575

575576
error = computeKeys(&saplingKeys);
576577

577578
// Copy keys
578579
if (error == zxerr_ok) {
579580
error = copyKeys(&saplingKeys, requestedKey, output, outputLen);
580581
} else {
581-
MEMZERO(sk, sizeof(sk));
582-
MEMZERO(&saplingKeys, sizeof(saplingKeys));
582+
MEMZERO(sk, sizeof(sk));
583+
MEMZERO(&saplingKeys, sizeof(saplingKeys));
583584
}
584585

585586
return error;
@@ -638,7 +639,7 @@ static parser_error_t h_star(uint8_t *a, uint16_t a_len, uint8_t *b, uint16_t b_
638639

639640
return parser_ok;
640641
}
641-
static zxerr_t sign_sapling_spend(keys_t *keys, uint8_t *alpha, uint8_t *sign_hash ,uint8_t *signature) {
642+
static zxerr_t sign_sapling_spend(keys_t *keys, uint8_t alpha[static KEY_LENGTH], uint8_t sign_hash[static KEY_LENGTH], uint8_t *signature) {
642643
if (alpha == NULL || sign_hash == NULL || signature == NULL) {
643644
return zxerr_no_data;
644645
}
@@ -679,7 +680,7 @@ static zxerr_t sign_sapling_spend(keys_t *keys, uint8_t *alpha, uint8_t *sign_ha
679680
return zxerr_ok;
680681
}
681682

682-
zxerr_t crypto_sign_spends_sapling(const parser_tx_t *txObj, uint8_t *output, uint16_t outputLen, uint16_t *responseLen) {
683+
zxerr_t crypto_sign_spends_sapling(const parser_tx_t *txObj, keys_t *keys, uint8_t *output, uint16_t outputLen, uint16_t *responseLen) {
683684
zemu_log_stack("crypto_signspends_sapling");
684685
if (txObj->transaction.sections.maspTx.data.sapling_bundle.n_shielded_spends == 0) {
685686
return zxerr_ok;
@@ -690,13 +691,6 @@ zxerr_t crypto_sign_spends_sapling(const parser_tx_t *txObj, uint8_t *output, ui
690691
uint8_t sign_hash[HASH_LEN] = {0};
691692
signature_hash(txObj, sign_hash);
692693

693-
// Get keys to use ask
694-
uint8_t sapling_seed[KEY_LENGTH] = {0};
695-
keys_t keys = {0};
696-
CHECK_ZXERR(crypto_computeSaplingSeed(sapling_seed));
697-
CHECK_PARSER_OK(computeMasterFromSeed(sapling_seed, keys.spendingKey));
698-
CHECK_ZXERR(computeKeys(&keys));
699-
700694
uint8_t signature[2 * HASH_LEN] = {0};
701695
uint8_t alpha[KEY_LENGTH] = {0};
702696
const uint8_t *spend = txObj->transaction.sections.maspBuilder.builder.sapling_builder.spends.ptr;
@@ -707,7 +701,7 @@ zxerr_t crypto_sign_spends_sapling(const parser_tx_t *txObj, uint8_t *output, ui
707701
spend += spendLen;
708702
MEMCPY(alpha, spend + ALPHA_OFFSET, KEY_LENGTH);
709703

710-
CHECK_ZXERR(sign_sapling_spend(&keys, alpha, sign_hash, signature));
704+
CHECK_ZXERR(sign_sapling_spend(keys, alpha, sign_hash, signature));
711705

712706
// Copy signature to output
713707
MEMCPY(output + i * MASP_SIG_LEN, signature, MASP_SIG_LEN);
@@ -807,21 +801,15 @@ zxerr_t checkConverts(const parser_tx_t *txObj) {
807801
return zxerr_ok;
808802
}
809803

810-
zxerr_t crypto_check_masp(const parser_tx_t *txObj) {
811-
if (txObj == NULL) {
804+
zxerr_t crypto_check_masp(const parser_tx_t *txObj, keys_t *keys) {
805+
if (txObj == NULL || keys == NULL) {
812806
return zxerr_unknown;
813807
}
814-
// Get keys to use ask
815-
uint8_t sapling_seed[KEY_LENGTH] = {0};
816-
keys_t keys = {0};
817-
CHECK_ZXERR(crypto_computeSaplingSeed(sapling_seed));
818-
CHECK_PARSER_OK(computeMasterFromSeed(sapling_seed, keys.spendingKey));
819-
CHECK_ZXERR(computeKeys(&keys));
820808

821809
#if !defined(LEDGER_SPECIFIC)
822810
// For now verify cv and rk https://github.com/anoma/masp/blob/main/masp_proofs/src/sapling/prover.rs#L278
823811
// Check Spends
824-
CHECK_ZXERR(checkSpends(txObj, &keys));
812+
CHECK_ZXERR(checkSpends(txObj, keys));
825813

826814
// Check outputs
827815
CHECK_ZXERR(checkOutputs(txObj));
@@ -837,11 +825,23 @@ zxerr_t crypto_sign_masp(const parser_tx_t *txObj, uint8_t *output, uint16_t out
837825
return zxerr_unknown;
838826
}
839827

840-
CHECK_ZXERR(crypto_check_masp(txObj));
828+
// Get keys
829+
uint8_t sapling_seed[KEY_LENGTH] = {0};
830+
keys_t keys = {0};
831+
CHECK_ZXERR(crypto_computeSaplingSeed(sapling_seed));
832+
CHECK_PARSER_OK(computeMasterFromSeed(sapling_seed, keys.spendingKey));
833+
834+
if (computeKeys(&keys) != zxerr_ok || crypto_check_masp(txObj, &keys) != zxerr_ok) {
835+
MEMZERO(sapling_seed, sizeof(sapling_seed));
836+
MEMZERO(&keys, sizeof(keys));
837+
return zxerr_invalid_crypto_settings;
838+
}
841839

842840
// Sign Sapling spends
843-
CHECK_ZXERR(crypto_sign_spends_sapling(txObj, output, outputLen, responseLen));
841+
CHECK_ZXERR(crypto_sign_spends_sapling(txObj, &keys, output, outputLen, responseLen));
844842

843+
MEMZERO(sapling_seed, sizeof(sapling_seed));
844+
MEMZERO(&keys, sizeof(keys));
845845
return zxerr_ok;
846846
}
847847

@@ -863,10 +863,10 @@ zxerr_t crypto_computeRandomness(const uint8_t *buffer, uint16_t bufferLen, uint
863863
}
864864
MEMZERO(out, outLen);
865865
zemu_log_stack("crypto_computeRandomness");
866-
uint8_t spend_len = buffer[0];
867-
uint8_t output_len = buffer[1];
868-
uint8_t convert_len = buffer[2];
869-
uint8_t tmp_rnd[32] = {0};
866+
const uint8_t spend_len = buffer[0];
867+
const uint8_t output_len = buffer[1];
868+
const uint8_t convert_len = buffer[2];
869+
uint8_t tmp_rnd[KEY_LENGTH] = {0};
870870

871871
zemu_log_stack("crypto_computeRandomness");
872872
transaction_add_sizes(spend_len, output_len, convert_len);

‎app/src/crypto_helper.c

+20
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919
#include "zxformat.h"
2020
#include "leb128.h"
2121
#include "zxmacros.h"
22+
#include "bech32_encoding.h"
2223

2324
#include "keys_personalizations.h"
2425
#include "rslib.h"
@@ -33,6 +34,9 @@
3334
#define TESTNET_ADDRESS_T_HRP "testtnam"
3435
#define TESTNET_PUBKEY_T_HRP "testtpknam"
3536

37+
#define MAINNET_EXT_FULL_VIEWING_KEY_HRP "zvknam"
38+
#define MAINNET_PAYMENT_ADDR_HRP "znam"
39+
3640
#if defined(TARGET_NANOS) || defined(TARGET_NANOS2) || defined(TARGET_NANOX) || defined(TARGET_STAX)
3741
#include "cx.h"
3842
#include "cx_sha256.h"
@@ -136,6 +140,22 @@ zxerr_t crypto_encodeAddress(const uint8_t *pubkey, uint16_t pubkeyLen, uint8_t
136140
return zxerr_ok;
137141
}
138142

143+
parser_error_t crypto_encodeLargeBech32(const uint8_t *address, size_t addressLen, uint8_t *output, size_t outputLen, bool paymentAddr) {
144+
if (output == NULL || address == NULL) {
145+
return parser_unexpected_value;
146+
}
147+
148+
char HRP[10] = MAINNET_PAYMENT_ADDR_HRP;
149+
if (!paymentAddr) {
150+
strcpy(HRP, MAINNET_EXT_FULL_VIEWING_KEY_HRP);
151+
}
152+
153+
if(bech32EncodeFromLargeBytes((char *)output, outputLen, HRP, (uint8_t*) address, addressLen, 1, BECH32_ENCODING_BECH32M) != zxerr_ok) {
154+
return parser_unexpected_value;
155+
};
156+
return parser_ok;
157+
}
158+
139159
zxerr_t crypto_sha256(const uint8_t *input, uint16_t inputLen, uint8_t *output, uint16_t outputLen) {
140160
if (input == NULL || output == NULL || outputLen < CX_SHA256_SIZE) {
141161
return zxerr_encoding_failed;

‎app/src/crypto_helper.h

+1
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,7 @@ parser_error_t computeDiversifier(const uint8_t dk[KEY_LENGTH], uint8_t start_in
6666
parser_error_t computePkd(const uint8_t ivk[KEY_LENGTH], const uint8_t diversifier[DIVERSIFIER_LENGTH], uint8_t pk_d[KEY_LENGTH]);
6767
parser_error_t computeValueCommitment(uint64_t value, uint8_t *rcv, uint8_t *identifier, uint8_t *cv);
6868
parser_error_t computeRk(keys_t *keys, uint8_t *alpha, uint8_t *rk);
69+
parser_error_t crypto_encodeLargeBech32( const uint8_t *address, size_t addressLen, uint8_t *output, size_t outputLen, bool paymentAddr);
6970
#ifdef __cplusplus
7071
}
7172
#endif

‎app/src/parser_print_txn.c

+3-16
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323
#include "bech32.h"
2424
#include "parser_address.h"
2525
#include "bech32_encoding.h"
26+
#include "crypto_helper.h"
2627

2728
#include "txn_delegation.h"
2829

@@ -308,14 +309,7 @@ static parser_error_t printMaspTransferTxn( const parser_context_t *ctx,
308309
if (ctx->tx_obj->transfer.source_address.tag != 2) {
309310
CHECK_ERROR(printAddressAlt(&ctx->tx_obj->transfer.source_address, outVal, outValLen, pageIdx, pageCount))
310311
} else {
311-
const char *hrp = "zvknam";
312-
bech32EncodeFromLargeBytes(tmp_buf,
313-
sizeof(tmp_buf),
314-
hrp,
315-
(uint8_t*) spend.ptr,
316-
EXTENDED_FVK_LEN,
317-
1,
318-
BECH32_ENCODING_BECH32M);
312+
CHECK_ERROR(crypto_encodeLargeBech32(spend.ptr, EXTENDED_FVK_LEN, (uint8_t*) tmp_buf, sizeof(tmp_buf), 0));
319313
pageString(outVal, outValLen, (const char*) tmp_buf, pageIdx, pageCount);
320314
}
321315

@@ -348,14 +342,7 @@ static parser_error_t printMaspTransferTxn( const parser_context_t *ctx,
348342
if(ctx->tx_obj->transfer.target_address.tag != 2) {
349343
CHECK_ERROR(printAddressAlt(&ctx->tx_obj->transfer.target_address, outVal, outValLen, pageIdx, pageCount))
350344
} else {
351-
const char *hrp = "znam";
352-
bech32EncodeFromLargeBytes(tmp_buf,
353-
sizeof(tmp_buf),
354-
hrp,
355-
(uint8_t*) out.ptr,
356-
PAYMENT_ADDR_LEN + DIVERSIFIER_LEN + 1,
357-
1,
358-
BECH32_ENCODING_BECH32M);
345+
CHECK_ERROR(crypto_encodeLargeBech32(out.ptr, PAYMENT_ADDR_LEN + DIVERSIFIER_LEN + 1, (uint8_t*) tmp_buf, sizeof(tmp_buf), 1));
359346
pageString(outVal, outValLen, (const char*) tmp_buf, pageIdx, pageCount);
360347
}
361348
break;

‎app/src/tx_hash.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ zxerr_t tx_hash_transparent_inputs(const parser_tx_t *txObj, uint8_t *output) {
5858

5959
const uint8_t *vin = txObj->transaction.sections.maspTx.data.transparent_bundle.vin.ptr;
6060

61-
for(uint64_t i = 0; i < txObj->transaction.sections.maspTx.data.transparent_bundle.n_vin; i++, vin += VOUT_LEN){
61+
for(uint64_t i = 0; i < txObj->transaction.sections.maspTx.data.transparent_bundle.n_vin; i++, vin += VIN_LEN){
6262
CHECK_CX_OK(cx_hash_no_throw(&ctx.header, 0, vin, ASSET_ID_LEN, NULL, 0));
6363
CHECK_CX_OK(cx_hash_no_throw(&ctx.header, 0, vin + VIN_VALUE_OFFSET, sizeof(uint64_t), NULL, 0));
6464
CHECK_CX_OK(cx_hash_no_throw(&ctx.header, 0, vin + VIN_ADDR_OFFSET, IMPLICIT_ADDR_LEN, NULL, 0));

‎js/src/processResponses.ts

+3-3
Original file line numberDiff line numberDiff line change
@@ -106,17 +106,17 @@ export function processGetKeysResponse(response: Buffer, keyType: NamadaKeys): K
106106
const viewKey = Buffer.from(response.subarray(0, 2 * KEY_LENGTH))
107107
response = response.subarray(2 * KEY_LENGTH)
108108

109-
const ivk = Buffer.from(response.subarray(0, KEY_LENGTH))
109+
const ovk = Buffer.from(response.subarray(0, KEY_LENGTH))
110110
response = response.subarray(KEY_LENGTH)
111111

112-
const ovk = Buffer.from(response.subarray(0, KEY_LENGTH))
112+
const ivk = Buffer.from(response.subarray(0, KEY_LENGTH))
113113
response = response.subarray(KEY_LENGTH)
114114

115115
requestedKey = {
116116
...requestedKey,
117117
viewKey,
118-
ivk,
119118
ovk,
119+
ivk,
120120
}
121121
break
122122
}

0 commit comments

Comments
 (0)