bolos_crypto.h

Go to the documentation of this file.

/*
*******************************************************************************    
*   BOLOS TEE
*   (c) 2016 Ledger
*   
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*   Unless required by applicable law or agreed to in writing, software
*   distributed under the License is distributed on an "AS IS" BASIS,
*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*   limitations under the License.
********************************************************************************/

#ifndef  __BOLOS_CRYPTO_H__

#define __BOLOS_CRYPTO_H__

/* ####################################################################### */
/*                                   RAND                                  */
/* ####################################################################### */

uint8_t bls_rng_u8(void);


int bls_rng(uint8_t *buffer, size_t len);


/* ####################################################################### */
/*                                 HASH/HMAC                               */
/* ####################################################################### */

/* ======================================================================= */
/*                                   HASH                                 */
/* ======================================================================= */

int bls_ripemd160_init(bls_ripemd160_t  *hash);

int bls_sha1_init(bls_sha1_t  *hash);

int bls_sha256_init(bls_sha256_t  *hash);

int bls_sha512_init(bls_sha512_t  *hash);

int bls_hash(bls_hash_t *hash, int mode,
            const uint8_t WIDE *in, size_t len, uint8_t *out);

/* ======================================================================= */
/*                                 HASH MAC                                */
/* ======================================================================= */

int bls_hmac_ripemd160_init(bls_hmac_ripemd160_t *hmac, const uint8_t WIDE *key, size_t key_len);

int bls_hmac_sha256_init(bls_hmac_sha256_t *hmac, const uint8_t WIDE *key, size_t key_len);

int bls_hmac_sha512_init(bls_hmac_sha512_t *hmac, const uint8_t WIDE *key, size_t key_len);

int bls_hmac(bls_hmac_t *hmac, int mode,
            const uint8_t WIDE *in, size_t len, uint8_t *mac);

/* ####################################################################### */
/*                             KEY STRETCHING                              */
/* ####################################################################### */

int bls_pbkdf2(bls_md_t hash,
            const bls_area_t *password, 
            const bls_area_t *salt, 
            int iterations,
            uint8_t *out);

/* ####################################################################### */
/*                               CIPHER/SIGNATURE                          */
/* ####################################################################### */
/* - DES
 * - ECDSA
 * - ECDH
 * - RSA
 */


/* ======================================================================= */
/*                                   DES                                   */
/* ======================================================================= */


int bls_des_init_key(const uint8_t WIDE *rawkey, 
                    size_t key_len,
                    bls_des_key_t *key);


int bls_des(bls_des_key_t WIDE *key, int mode,
           const bls_area_t *in, bls_area_t *out);



int bls_des_iv(bls_des_key_t WIDE *key, int mode,
              const bls_area_t *iv,
              const bls_area_t *in, bls_area_t *out);


/* ======================================================================= */
/*                                   AES                                   */
/* ======================================================================= */


int bls_aes_init_key(const uint8_t WIDE *rawkey, 
                    size_t key_len,
                    bls_aes_key_t *key);


int bls_aes(bls_aes_key_t WIDE *key, int mode,
           const bls_area_t *in, bls_area_t *out);


int bls_aes_iv(bls_aes_key_t WIDE *key, int mode,
              const bls_area_t *iv,
              const bls_area_t *in, bls_area_t *out);


int bls_aes_iv_gcm(bls_aes_key_t WIDE *key, int mode,
              const bls_area_t *in,
              const bls_area_t *iv,
              const bls_area_t WIDE *aadTag, // encrypt : aad in/tag out | decrypt : tag in
              bls_area_t *out);


/* ======================================================================= */
/*                                   RSA                                   */
/* ======================================================================= */

int bls_rsa_init_public_key(const bls_rsa_keypair_data_t WIDE *keyData,
                           bls_rsa_abstract_public_key_t  *key);

int bls_rsa_init_private_key(const bls_rsa_keypair_data_t WIDE *keyData,
                           bls_rsa_abstract_private_key_t  *key);

int bls_rsa_init_private_key_crt(const bls_rsa_crt_t WIDE *crtParameters,
                           bls_rsa_abstract_private_key_t  *key);

int bls_rsa_generate_keypair(int modulus_len, // in bits
                           bls_rsa_abstract_private_key_t  *privateKey,
                           bls_rsa_abstract_public_key_t   *publicKey,
                           bls_rsa_keypair_data_t *generatedKeypairInfo
                           );

int bls_rsa_get_public_key_data(bls_rsa_abstract_public_key_t   *publicKey,
                           bls_rsa_keypair_data_t *keyInfo);

int bls_rsa_pub(bls_rsa_abstract_public_key_t WIDE *key, int mode,
                  bls_md_t hashID, const bls_area_t *src,
                  const bls_area_t *dest);

int bls_rsa_priv(bls_rsa_abstract_private_key_t WIDE *key, int mode,
                  bls_md_t hashID, const bls_area_t *src,
                  const bls_area_t *dest);


/* ======================================================================= */
/*                                   ECDSA                                 */
/* ======================================================================= */


bls_curve_domain_t WIDE * bls_ecfp_get_domain(bls_curve_t curve);


int bls_ecfp_is_valid_point(const bls_curve_domain_t WIDE *domain, const uint8_t WIDE *point);

int bls_ecfp_add_point(const bls_curve_domain_t WIDE *domain, uint8_t *R, 
          const uint8_t WIDE *P, const uint8_t WIDE *Q);

int bls_ecdsa_init_public_key(bls_curve_t curve, 
                             const uint8_t  WIDE *rawkey, size_t key_len,
                             bls_ecfp_public_key_t  *key);

int bls_ecdsa_init_private_key(bls_curve_t curve, 
                              const uint8_t WIDE *rawkey, size_t key_len,
                              bls_ecfp_private_key_t *key);
int bls_ecfp_generate_pair(bls_curve_t curve,
                          bls_ecfp_public_key_t  *public_key, bls_ecfp_private_key_t *private_key, 
                          uint8_t *d);

int bls_ecfp_get_public_component(const bls_ecfp_public_key_t *public_key,
                          uint8_t *W);

int bls_ecdsa_sign(bls_ecfp_private_key_t WIDE *key, int mode, bls_md_t hashID,
                  const uint8_t  WIDE *hash, size_t hash_len, uint8_t *sig);
int bls_ecdsa_verify(bls_ecfp_public_key_t WIDE *key, int mode, bls_md_t hashID,
                  const uint8_t  WIDE *hash, size_t hash_len, uint8_t *sig);

int bls_schnorr_sign(bls_ecfp_private_key_t WIDE *key, int mode, bls_md_t hashID,
                  const uint8_t WIDE *hash, size_t hash_len, uint8_t *sig);
int bls_schnorr_verify(bls_ecfp_public_key_t WIDE *key, int mode, bls_md_t hashID,
                  const uint8_t WIDE *hash, size_t hash_len, uint8_t *sig);


/* ======================================================================= */
/*                                     ECDH                                */
/* ======================================================================= */

int bls_ecdh(bls_ecfp_private_key_t WIDE *key, int mode,
            const uint8_t WIDE *public_point, uint8_t *secret);


/* ======================================================================= */
/*                                    CRC                                */
/* ======================================================================= */

uint16_t bls_crc16(const void WIDE *buffer, size_t len);


uint16_t bls_crc16_update(unsigned short crc, const void WIDE *buffer, size_t len);


/* ======================================================================= */
/*                                    MATH                                 */
/* ======================================================================= */


void    bls_math_addm(uint8_t* r, const uint8_t WIDE *a, const uint8_t WIDE *b,  const uint8_t WIDE *m, size_t len);


int    bls_math_cmp(const uint8_t WIDE *a, const uint8_t WIDE *b, size_t len);

int    bls_math_is_zero(const uint8_t WIDE *a, size_t len);

void bls_math_modm(uint8_t *v, size_t len_v,
                  const uint8_t WIDE *m, size_t len_m);

#endif //__BOLOS_CRYPTO_H__