Merge pull request #215 from Zondax/add-manifest

Add manifest

.github/workflows/guidelines_enforcer.yml

@@ -21,6 +21,3 @@ jobs:
   guidelines_enforcer:
     name: Call Ledger guidelines_enforcer
     uses: LedgerHQ/ledger-app-workflows/.github/workflows/reusable_guidelines_enforcer.yml@v1
-    with:
-      relative_app_directory: app
-      run_for_devices: '["nanos", "nanosp", "nanox"]'

app/Makefile

@@ -48,10 +48,7 @@ else ifeq ($(COIN),oasis_validator)
 DEFINES += APP_VALIDATOR
 APPNAME = "OasisVal"
 APPPATH = "43'/474'"
-APPCURVE =
-ifeq ($(TARGET_NAME),TARGET_NANOS)
-APP_STACK_SIZE:=1956
-endif
+APPCURVE = --curve ed25519
 
 ifeq ($(TARGET_NAME),TARGET_NANOX)
 $(error "Oasis Validator App is not supported in Nano X")

app/Makefile.version

@@ -1,3 +1,3 @@
 APPVERSION_M=2
 APPVERSION_N=5
-APPVERSION_P=8
+APPVERSION_P=9

app/src/consumer/parser_impl_con.c

@@ -1383,8 +1383,8 @@ __Z_INLINE parser_error_t _readRuntimeEncrypted(parser_tx_t *v, CborValue *rootI
     cx_sha256_t ctx;
     memset(&ctx, 0, sizeof(ctx));
     cx_sha256_init_no_throw(&ctx);
-    cx_hash_no_throw(&ctx.header, CX_LAST, buffer, buffer_size, (unsigned char *)&v->oasis.runtime.call.body.encrypted.data_hash,
-            sizeof(v->oasis.runtime.call.body.encrypted.data_hash));
+   CHECK_CX_PARSER_OK(cx_hash_no_throw(&ctx.header, CX_LAST, buffer, buffer_size, (unsigned char *)&v->oasis.runtime.call.body.encrypted.data_hash,
+            sizeof(v->oasis.runtime.call.body.encrypted.data_hash)));
 #else
     picohash_ctx_t ctx;
     picohash_init_sha256(&ctx);
@@ -1432,8 +1432,8 @@ __Z_INLINE parser_error_t _readRuntimeEvmBody(parser_tx_t *v, CborValue *rootIte
     cx_sha256_t ctx;
     memset(&ctx, 0, sizeof(ctx));
     cx_sha256_init_no_throw(&ctx);
-    cx_hash_no_throw(&ctx.header, CX_LAST, buffer, buffer_size, (unsigned char *)&v->oasis.runtime.call.body.encrypted.data_hash,
-                     sizeof(v->oasis.runtime.call.body.encrypted.data_hash));
+    CHECK_CX_PARSER_OK(cx_hash_no_throw(&ctx.header, CX_LAST, buffer, buffer_size, (unsigned char *)&v->oasis.runtime.call.body.encrypted.data_hash,
+                     sizeof(v->oasis.runtime.call.body.encrypted.data_hash)));
 #else
     picohash_ctx_t ctx;
     picohash_init_sha256(&ctx);

app/src/consumer/parser_impl_con.h

@@ -23,6 +23,14 @@
 extern "C" {
 #endif
 
+#define CHECK_CX_PARSER_OK(CALL)         \
+    do {                          \
+        cx_err_t __cx_err = CALL; \
+        if (__cx_err != CX_OK) {  \
+            return parser_unexepected_error; \
+        }                         \
+    } while (0)
+
 extern const char context_prefix_tx[];
 extern const char context_prefix_entity[];
 extern const char context_prefix_entity_metadata[];

app/src/crypto.c

@@ -42,8 +42,8 @@ __Z_INLINE zxerr_t keccak_hash(const unsigned char *in, unsigned int inLen,
     cx_sha3_t ctx;
     zxerr_t error = zxerr_unknown;
 
-    CATCH_CXERROR(cx_keccak_init_no_throw(&ctx, outLen * 8))
-    CATCH_CXERROR(cx_hash_no_throw((cx_hash_t *)&ctx, CX_LAST, in, inLen, out, outLen))
+    CATCH_CXERROR(cx_keccak_init_no_throw(&ctx, outLen * 8));
+    CATCH_CXERROR(cx_hash_no_throw((cx_hash_t *)&ctx, CX_LAST, in, inLen, out, outLen));
     error = zxerr_ok;
 
 catch_cx_error:
@@ -96,7 +96,7 @@ zxerr_t  crypto_extractPublicKeySr25519(uint8_t *pubKey, uint16_t pubKeyLen) {
         get_sr25519_sk(privateKeyData);
     }
 
-    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(pubKey, privateKeyData))
+    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(pubKey, privateKeyData));
     error = zxerr_ok;
 
 catch_cx_error:
@@ -128,11 +128,11 @@ zxerr_t  crypto_extractPublicKeyEd25519(uint8_t *pubKey, uint16_t pubKeyLen) {
                                                      privateKeyData,
                                                      NULL,
                                                      NULL,
-                                                     0))
+                                                     0));
 
-    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_Ed25519, privateKeyData, 32, &cx_privateKey))
-    CATCH_CXERROR(cx_ecfp_init_public_key_no_throw(CX_CURVE_Ed25519, NULL, 0, &cx_publicKey))
-    CATCH_CXERROR(cx_ecfp_generate_pair_no_throw(CX_CURVE_Ed25519, &cx_publicKey, &cx_privateKey, 1))
+    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_Ed25519, privateKeyData, 32, &cx_privateKey));
+    CATCH_CXERROR(cx_ecfp_init_public_key_no_throw(CX_CURVE_Ed25519, NULL, 0, &cx_publicKey));
+    CATCH_CXERROR(cx_ecfp_generate_pair_no_throw(CX_CURVE_Ed25519, &cx_publicKey, &cx_privateKey, 1));
     // Format pubkey
     for (int i = 0; i < 32; i++) {
         pubKey[i] = cx_publicKey.W[64 - i];
@@ -171,11 +171,11 @@ zxerr_t crypto_extractPublicKeySecp256k1(uint8_t *pubKey, uint16_t pubKeyLen, ui
                                                      privateKeyData,
                                                      chainCode,
                                                      NULL,
-                                                     0))
+                                                     0));
 
-    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, SK_SECP256K1_SIZE, &cx_privateKey))
-    CATCH_CXERROR(cx_ecfp_init_public_key_no_throw(CX_CURVE_256K1, NULL, 0, &cx_publicKey))
-    CATCH_CXERROR(cx_ecfp_generate_pair_no_throw(CX_CURVE_256K1, &cx_publicKey, &cx_privateKey, 1))
+    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, SK_SECP256K1_SIZE, &cx_privateKey));
+    CATCH_CXERROR(cx_ecfp_init_public_key_no_throw(CX_CURVE_256K1, NULL, 0, &cx_publicKey));
+    CATCH_CXERROR(cx_ecfp_generate_pair_no_throw(CX_CURVE_256K1, &cx_publicKey, &cx_privateKey, 1));
     memcpy(pubKey, cx_publicKey.W, PK_LEN_SECP256K1_FULL);
     error = zxerr_ok;
 
@@ -224,16 +224,16 @@ zxerr_t crypto_signSecp256k1(uint8_t *output, uint16_t outputLen, const uint8_t
                                                      privateKeyData,
                                                      NULL,
                                                      NULL,
-                                                     0))
+                                                     0));
 
-    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, SK_SECP256K1_SIZE, &cx_privateKey))
+    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, SK_SECP256K1_SIZE, &cx_privateKey));
     CATCH_CXERROR(cx_ecdsa_sign_no_throw(&cx_privateKey,
                                          CX_RND_RFC6979 | CX_LAST,
                                          CX_SHA256,
                                          message,
                                          messageLen,
                                          signature_object->der_signature,
-                                         &maxSignatureLen, &info))
+                                         &maxSignatureLen, &info));
 
     const err_convert_e err_c = convertDERtoRSV(signature_object->der_signature, info,  signature_object->r, signature_object->s, &signature_object->v);
     if (err_c == no_error) {
@@ -274,15 +274,15 @@ zxerr_t crypto_signEd25519(uint8_t *output, uint16_t outputLen, const uint8_t *m
                                                      privateKeyData,
                                                      NULL,
                                                      NULL,
-                                                     0))
+                                                     0));
 
-    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_Ed25519, privateKeyData, 32, &cx_privateKey))
+    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_Ed25519, privateKeyData, 32, &cx_privateKey));
     CATCH_CXERROR(cx_eddsa_sign_no_throw(&cx_privateKey,
                                          CX_SHA512,
                                          message,
                                          messageLen,
                                          output,
-                                         outputLen))
+                                         outputLen));
 
     *sigSize = ED25519_SIGNATURE_SIZE;
     error = zxerr_ok;
@@ -316,7 +316,7 @@ zxerr_t crypto_sign_sr25519(uint8_t *output, uint16_t outputLen, const uint8_t *
                                                      sk,
                                                      NULL,
                                                      NULL,
-                                                     0))
+                                                     0));
 
     if (mode == HDW_ED25519_SLIP10) {
         uint8_t privateKeyData_expanded[SK_LEN_25519] = {0};
@@ -327,9 +327,9 @@ zxerr_t crypto_sign_sr25519(uint8_t *output, uint16_t outputLen, const uint8_t *
         get_sr25519_sk(sk);
     }
 
-    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(pk, sk))
+    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(pk, sk));
     sign_sr25519_phase1(sk, pk, ctx, ctx_len, data, len, output);
-    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(output, output + PK_LEN_SR25519))
+    CATCH_CXERROR(crypto_scalarmult_ristretto255_base_sdk(output, output + PK_LEN_SR25519));
     *sigSize = SIG_LEN;
     error = zxerr_ok;
 
@@ -366,15 +366,15 @@ zxerr_t _sign(uint8_t *output, uint16_t outputLen, const uint8_t *message, uint1
                                                      privateKeyData,
                                                      NULL,
                                                      NULL,
-                                                     0))
-    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, 32, &cx_privateKey))
+                                                     0));
+    CATCH_CXERROR(cx_ecfp_init_private_key_no_throw(CX_CURVE_256K1, privateKeyData, 32, &cx_privateKey));
     CATCH_CXERROR(cx_ecdsa_sign_no_throw(&cx_privateKey,
                                          CX_RND_RFC6979 | CX_LAST,
                                          CX_SHA256,
                                          message,
                                          messageLen,
                                          signature->der_signature,
-                                         &signatureLength, &tmpInfo))
+                                         &signatureLength, &tmpInfo));
 
     const err_convert_e err_c = convertDERtoRSV(signature->der_signature, tmpInfo,  signature->r, signature->s, &signature->v);
     if (err_c == no_error) {

app/src/ristretto.c

@@ -121,7 +121,7 @@ static cx_err_t fe25519_cneg_sdk(fe25519_sdk h, const fe25519_sdk f, unsigned in
 {
     fe25519_sdk negf;
 
-    CHECK_CXERROR(fe25519_neg_sdk(negf, f))
+    CHECK_CXERROR(fe25519_neg_sdk(negf, f));
     fe25519_copy_sdk(h, f);
     fe25519_cmov_sdk(h, negf, b);
 
@@ -153,29 +153,29 @@ static cx_err_t ristretto255_sqrt_ratio_m1_sdk(fe25519_sdk x, const fe25519_sdk
     fe25519_sdk x_sqrtm1;
     int has_p_root, has_f_root;
 
-    CHECK_CXERROR(fe25519_sq_sdk(v3, v))
-    CHECK_CXERROR(fe25519_mul_sdk(v3, v3, v)) /* v3 = v^3 */
-    CHECK_CXERROR(fe25519_sq_sdk(x, v3))
-    CHECK_CXERROR(fe25519_mul_sdk(x, x, u))
-    CHECK_CXERROR(fe25519_mul_sdk(x, x, v)) /* x = uv^7 */
+    CHECK_CXERROR(fe25519_sq_sdk(v3, v));
+    CHECK_CXERROR(fe25519_mul_sdk(v3, v3, v)); /* v3 = v^3 */
+    CHECK_CXERROR(fe25519_sq_sdk(x, v3));
+    CHECK_CXERROR(fe25519_mul_sdk(x, x, u));
+    CHECK_CXERROR(fe25519_mul_sdk(x, x, v)); /* x = uv^7 */
 
-    CHECK_CXERROR(fe25519_pow22523_sdk(x, x)) /* x = (uv^7)^((q-5)/8) */
-    CHECK_CXERROR(fe25519_mul_sdk(x, x, v3))
-    CHECK_CXERROR(fe25519_mul_sdk(x, x, u)) /* x = uv^3(uv^7)^((q-5)/8) */
+    CHECK_CXERROR(fe25519_pow22523_sdk(x, x)); /* x = (uv^7)^((q-5)/8) */
+    CHECK_CXERROR(fe25519_mul_sdk(x, x, v3));
+    CHECK_CXERROR(fe25519_mul_sdk(x, x, u)); /* x = uv^3(uv^7)^((q-5)/8) */
 
-    CHECK_CXERROR(fe25519_sq_sdk(vxx, x))
-    CHECK_CXERROR(fe25519_mul_sdk(vxx, vxx, v)) /* vx^2 */
-    CHECK_CXERROR(fe25519_sub_sdk(m_root_check, vxx, u)) /* vx^2-u */
-    CHECK_CXERROR(fe25519_add_sdk(p_root_check, vxx, u)) /* vx^2+u */
-    CHECK_CXERROR(fe25519_mul_sdk(f_root_check, u, fe25519_sqrtm1_sdk)) /* u*sqrt(-1) */
-    CHECK_CXERROR(fe25519_add_sdk(f_root_check, vxx, f_root_check)) /* vx^2+u*sqrt(-1) */
+    CHECK_CXERROR(fe25519_sq_sdk(vxx, x));
+    CHECK_CXERROR(fe25519_mul_sdk(vxx, vxx, v)); /* vx^2 */
+    CHECK_CXERROR(fe25519_sub_sdk(m_root_check, vxx, u)); /* vx^2-u */
+    CHECK_CXERROR(fe25519_add_sdk(p_root_check, vxx, u)); /* vx^2+u */
+    CHECK_CXERROR(fe25519_mul_sdk(f_root_check, u, fe25519_sqrtm1_sdk)); /* u*sqrt(-1) */
+    CHECK_CXERROR(fe25519_add_sdk(f_root_check, vxx, f_root_check)); /* vx^2+u*sqrt(-1) */
 
     has_p_root = fe25519_iszero_sdk(p_root_check);
     has_f_root = fe25519_iszero_sdk(f_root_check);
-    CHECK_CXERROR(fe25519_mul_sdk(x_sqrtm1,x, fe25519_sqrtm1_sdk))
+    CHECK_CXERROR(fe25519_mul_sdk(x_sqrtm1,x, fe25519_sqrtm1_sdk));
 
     fe25519_cmov_sdk(x, x_sqrtm1, has_p_root | has_f_root);
-    CHECK_CXERROR(fe25519_abs_sdk(x, x))
+    CHECK_CXERROR(fe25519_abs_sdk(x, x));
 
     return CX_OK;
 }
@@ -198,28 +198,28 @@ static cx_err_t ristretto255_p3_tobytes_sdk(fe25519_sdk s, const ge25519_p3_sdk
     fe25519_sdk zmy;
     int     rotate;
 
-    CHECK_CXERROR(fe25519_add_sdk(u1, h->Z, h->Y))       /* u1 = Z+Y */
-    CHECK_CXERROR(fe25519_sub_sdk(zmy, h->Z, h->Y))      /* zmy = Z-Y */
-    CHECK_CXERROR(fe25519_mul_sdk(u1, u1, zmy))          /* u1 = (Z+Y)*(Z-Y) */
-    CHECK_CXERROR(fe25519_mul_sdk(u2, h->X, h->Y))       /* u2 = X*Y */
+    CHECK_CXERROR(fe25519_add_sdk(u1, h->Z, h->Y));       /* u1 = Z+Y */
+    CHECK_CXERROR(fe25519_sub_sdk(zmy, h->Z, h->Y));      /* zmy = Z-Y */
+    CHECK_CXERROR(fe25519_mul_sdk(u1, u1, zmy));          /* u1 = (Z+Y)*(Z-Y) */
+    CHECK_CXERROR(fe25519_mul_sdk(u2, h->X, h->Y));       /* u2 = X*Y */
 
-    CHECK_CXERROR(fe25519_sq_sdk(u1_u2u2, u2))           /* u1_u2u2 = u2^2 */
-    CHECK_CXERROR(fe25519_mul_sdk(u1_u2u2, u1, u1_u2u2)) /* u1_u2u2 = u1*u2^2 */
+    CHECK_CXERROR(fe25519_sq_sdk(u1_u2u2, u2));           /* u1_u2u2 = u2^2 */
+    CHECK_CXERROR(fe25519_mul_sdk(u1_u2u2, u1, u1_u2u2)); /* u1_u2u2 = u1*u2^2 */
 
     fe25519_1_sdk(one);
-    CHECK_CXERROR(ristretto255_sqrt_ratio_m1_sdk(inv_sqrt, one, u1_u2u2))
+    CHECK_CXERROR(ristretto255_sqrt_ratio_m1_sdk(inv_sqrt, one, u1_u2u2));
 
-    CHECK_CXERROR(fe25519_mul_sdk(den1, inv_sqrt, u1))
-    CHECK_CXERROR(fe25519_mul_sdk(den2, inv_sqrt, u2))
-    CHECK_CXERROR(fe25519_mul_sdk(z_inv, den1, den2))
-    CHECK_CXERROR(fe25519_mul_sdk(z_inv, z_inv, h->T))
+    CHECK_CXERROR(fe25519_mul_sdk(den1, inv_sqrt, u1));
+    CHECK_CXERROR(fe25519_mul_sdk(den2, inv_sqrt, u2));
+    CHECK_CXERROR(fe25519_mul_sdk(z_inv, den1, den2));
+    CHECK_CXERROR(fe25519_mul_sdk(z_inv, z_inv, h->T));
 
-    CHECK_CXERROR(fe25519_mul_sdk(ix, h->X, fe25519_sqrtm1_sdk))
-    CHECK_CXERROR(fe25519_mul_sdk(iy, h->Y, fe25519_sqrtm1_sdk))
+    CHECK_CXERROR(fe25519_mul_sdk(ix, h->X, fe25519_sqrtm1_sdk));
+    CHECK_CXERROR(fe25519_mul_sdk(iy, h->Y, fe25519_sqrtm1_sdk));
 
-    CHECK_CXERROR(fe25519_mul_sdk(eden, den1, ed25519_invsqrtamd_sdk))
+    CHECK_CXERROR(fe25519_mul_sdk(eden, den1, ed25519_invsqrtamd_sdk));
 
-    CHECK_CXERROR(fe25519_mul_sdk(t_z_inv, h->T, z_inv))
+    CHECK_CXERROR(fe25519_mul_sdk(t_z_inv, h->T, z_inv));
     rotate = fe25519_isnegative_sdk(t_z_inv);
 
     fe25519_copy_sdk(x_, h->X);
@@ -231,12 +231,12 @@ static cx_err_t ristretto255_p3_tobytes_sdk(fe25519_sdk s, const ge25519_p3_sdk
     fe25519_cmov_sdk(y_, ix, rotate);
     fe25519_cmov_sdk(den_inv, eden, rotate);
 
-    CHECK_CXERROR(fe25519_mul_sdk(x_z_inv, x_, z_inv))
-    CHECK_CXERROR(fe25519_cneg_sdk(y_, y_, fe25519_isnegative_sdk(x_z_inv)))
+    CHECK_CXERROR(fe25519_mul_sdk(x_z_inv, x_, z_inv));
+    CHECK_CXERROR(fe25519_cneg_sdk(y_, y_, fe25519_isnegative_sdk(x_z_inv)));;
 
-    CHECK_CXERROR(fe25519_sub_sdk(s_, h->Z, y_))
-    CHECK_CXERROR(fe25519_mul_sdk(s_, den_inv, s_))
-    CHECK_CXERROR(fe25519_abs_sdk(s, s_))
+    CHECK_CXERROR(fe25519_sub_sdk(s_, h->Z, y_));
+    CHECK_CXERROR(fe25519_mul_sdk(s_, den_inv, s_));
+    CHECK_CXERROR(fe25519_abs_sdk(s, s_));
 
     return CX_OK;
 }
@@ -253,18 +253,18 @@ cx_err_t crypto_scalarmult_ristretto255_base_sdk(unsigned char *q,const unsigned
 
     uint8_t Pxy[ED25519_SDKPOINT_BYTES];
     memcpy(Pxy, ED25519_GEN, sizeof(Pxy));
-    CHECK_CXERROR(cx_ecfp_scalar_mult_no_throw(CX_CURVE_Ed25519, Pxy, t, ED25519_SCALAR_BYTES))
+    CHECK_CXERROR(cx_ecfp_scalar_mult_no_throw(CX_CURVE_Ed25519, Pxy, t, ED25519_SCALAR_BYTES));
 
     ge25519_p3_sdk Q_sdk;
     MEMZERO(&Q_sdk, sizeof(ge25519_p3_sdk));
     memcpy(Q_sdk.X, &Pxy[1],ED25519_SCALAR_BYTES);
     memcpy(Q_sdk.Y, &Pxy[1+ED25519_SCALAR_BYTES],ED25519_SCALAR_BYTES);
     fe25519_1_sdk(Q_sdk.Z);
-    CHECK_CXERROR(fe25519_mul_sdk(Q_sdk.T, Q_sdk.X,Q_sdk.Y))
+    CHECK_CXERROR(fe25519_mul_sdk(Q_sdk.T, Q_sdk.X,Q_sdk.Y));
 
     fe25519_sdk s;
 
-    CHECK_CXERROR(ristretto255_p3_tobytes_sdk(s, &Q_sdk))
+    CHECK_CXERROR(ristretto255_p3_tobytes_sdk(s, &Q_sdk));
 
     if (fe25519_iszero_sdk(s)) {
         return CX_INTERNAL_ERROR;

ledger_app.toml

@@ -0,0 +1,7 @@
+[app]
+build_directory = "./app/"
+sdk = "C"
+devices = ["nanos", "nanox", "nanos+"]
+
+[tests]
+unit_directory = ""