crypto_helpers.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>  // uint*_t
 
#include "os.h"
#include "cx.h"
 
WARN_UNUSED_RESULT cx_err_t
bip32_derive_with_seed_init_privkey_256(unsigned int               derivation_mode,
                                        cx_curve_t                 curve,
                                        const uint32_t            *path,
                                        size_t                     path_len,
                                        cx_ecfp_256_private_key_t *privkey,
                                        uint8_t                   *chain_code,
                                        unsigned char             *seed,
                                        size_t                     seed_len);
 
WARN_UNUSED_RESULT static inline cx_err_t bip32_derive_init_privkey_256(
    cx_curve_t                 curve,
    const uint32_t            *path,
    size_t                     path_len,
    cx_ecfp_256_private_key_t *privkey,
    uint8_t                   *chain_code)
{
    return bip32_derive_with_seed_init_privkey_256(
        HDW_NORMAL, curve, path, path_len, privkey, chain_code, NULL, 0);
}
 
WARN_UNUSED_RESULT cx_err_t bip32_derive_with_seed_get_pubkey_256(unsigned int    derivation_mode,
                                                                  cx_curve_t      curve,
                                                                  const uint32_t *path,
                                                                  size_t          path_len,
                                                                  uint8_t  raw_pubkey[static 65],
                                                                  uint8_t *chain_code,
                                                                  cx_md_t  hashID,
                                                                  unsigned char *seed,
                                                                  size_t         seed_len);
 
WARN_UNUSED_RESULT static inline cx_err_t bip32_derive_get_pubkey_256(cx_curve_t      curve,
                                                                      const uint32_t *path,
                                                                      size_t          path_len,
                                                                      uint8_t raw_pubkey[static 65],
                                                                      uint8_t *chain_code,
                                                                      cx_md_t  hashID)
{
    return bip32_derive_with_seed_get_pubkey_256(
        HDW_NORMAL, curve, path, path_len, raw_pubkey, chain_code, hashID, NULL, 0);
}
 
WARN_UNUSED_RESULT cx_err_t bip32_derive_with_seed_ecdsa_sign_hash_256(unsigned int derivation_mode,
                                                                       cx_curve_t   curve,
                                                                       const uint32_t *path,
                                                                       size_t          path_len,
                                                                       uint32_t        sign_mode,
                                                                       cx_md_t         hashID,
                                                                       const uint8_t  *hash,
                                                                       size_t          hash_len,
                                                                       uint8_t        *sig,
                                                                       size_t         *sig_len,
                                                                       uint32_t       *info,
                                                                       unsigned char  *seed,
                                                                       size_t          seed_len);
 
WARN_UNUSED_RESULT static inline cx_err_t bip32_derive_ecdsa_sign_hash_256(cx_curve_t      curve,
                                                                           const uint32_t *path,
                                                                           size_t          path_len,
                                                                           uint32_t       sign_mode,
                                                                           cx_md_t        hashID,
                                                                           const uint8_t *hash,
                                                                           size_t         hash_len,
                                                                           uint8_t       *sig,
                                                                           size_t        *sig_len,
                                                                           uint32_t      *info)
{
    return bip32_derive_with_seed_ecdsa_sign_hash_256(HDW_NORMAL,
                                                      curve,
                                                      path,
                                                      path_len,
                                                      sign_mode,
                                                      hashID,
                                                      hash,
                                                      hash_len,
                                                      sig,
                                                      sig_len,
                                                      info,
                                                      NULL,
                                                      0);
}
 
WARN_UNUSED_RESULT cx_err_t
bip32_derive_with_seed_ecdsa_sign_rs_hash_256(unsigned int    derivation_mode,
                                              cx_curve_t      curve,
                                              const uint32_t *path,
                                              size_t          path_len,
                                              uint32_t        sign_mode,
                                              cx_md_t         hashID,
                                              const uint8_t  *hash,
                                              size_t          hash_len,
                                              uint8_t         sig_r[static 32],
                                              uint8_t         sig_s[static 32],
                                              uint32_t       *info,
                                              unsigned char  *seed,
                                              size_t          seed_len);
 
WARN_UNUSED_RESULT static inline cx_err_t bip32_derive_ecdsa_sign_rs_hash_256(
    cx_curve_t      curve,
    const uint32_t *path,
    size_t          path_len,
    uint32_t        sign_mode,
    cx_md_t         hashID,
    const uint8_t  *hash,
    size_t          hash_len,
    uint8_t         sig_r[static 32],
    uint8_t         sig_s[static 32],
    uint32_t       *info)
{
    return bip32_derive_with_seed_ecdsa_sign_rs_hash_256(HDW_NORMAL,
                                                         curve,
                                                         path,
                                                         path_len,
                                                         sign_mode,
                                                         hashID,
                                                         hash,
                                                         hash_len,
                                                         sig_r,
                                                         sig_s,
                                                         info,
                                                         NULL,
                                                         0);
}
 
WARN_UNUSED_RESULT cx_err_t bip32_derive_with_seed_eddsa_sign_hash_256(unsigned int derivation_mode,
                                                                       cx_curve_t   curve,
                                                                       const uint32_t *path,
                                                                       size_t          path_len,
                                                                       cx_md_t         hashID,
                                                                       const uint8_t  *hash,
                                                                       size_t          hash_len,
                                                                       uint8_t        *sig,
                                                                       size_t         *sig_len,
                                                                       unsigned char  *seed,
                                                                       size_t          seed_len);
 
WARN_UNUSED_RESULT static inline cx_err_t bip32_derive_eddsa_sign_hash_256(cx_curve_t      curve,
                                                                           const uint32_t *path,
                                                                           size_t          path_len,
                                                                           cx_md_t         hashID,
                                                                           const uint8_t  *hash,
                                                                           size_t          hash_len,
                                                                           uint8_t        *sig,
                                                                           size_t         *sig_len)
{
    return bip32_derive_with_seed_eddsa_sign_hash_256(
        HDW_NORMAL, curve, path, path_len, hashID, hash, hash_len, sig, sig_len, NULL, 0);
}