lcx_eddsa.h

Go to the documentation of this file.

 
/*******************************************************************************
 *   Ledger Nano S - Secure firmware
 *   (c) 2022 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 LCX_EDDSA_H
#define LCX_EDDSA_H
 
#include "lcx_ecfp.h"
#include "lcx_wrappers.h"
 
#ifdef HAVE_EDDSA
 
WARN_UNUSED_RESULT cx_err_t cx_eddsa_sign_no_throw(const cx_ecfp_private_key_t *pvkey,
                                                   cx_md_t                      hashID,
                                                   const uint8_t               *hash,
                                                   size_t                       hash_len,
                                                   uint8_t                     *sig,
                                                   size_t                       sig_len);
 
DEPRECATED static inline size_t cx_eddsa_sign(const cx_ecfp_private_key_t *pvkey,
                                              int                          mode,
                                              cx_md_t                      hashID,
                                              const unsigned char         *hash,
                                              unsigned int                 hash_len,
                                              const unsigned char         *ctx,
                                              unsigned int                 ctx_len,
                                              unsigned char               *sig,
                                              unsigned int                 sig_len,
                                              unsigned int                *info)
{
    UNUSED(ctx);
    UNUSED(ctx_len);
    UNUSED(mode);
    UNUSED(info);
 
    CX_THROW(cx_eddsa_sign_no_throw(pvkey, hashID, hash, hash_len, sig, sig_len));
 
    size_t size;
    CX_THROW(cx_ecdomain_parameters_length(pvkey->curve, &size));
 
    return 2 * size;
}
 
WARN_UNUSED_RESULT bool cx_eddsa_verify_no_throw(const cx_ecfp_public_key_t *pukey,
                                                 cx_md_t                     hashID,
                                                 const uint8_t              *hash,
                                                 size_t                      hash_len,
                                                 const uint8_t              *sig,
                                                 size_t                      sig_len);
 
static inline int cx_eddsa_verify(const cx_ecfp_public_key_t *pukey,
                                  int                         mode,
                                  cx_md_t                     hashID,
                                  const unsigned char        *hash,
                                  unsigned int                hash_len,
                                  const unsigned char        *ctx,
                                  unsigned int                ctx_len,
                                  const unsigned char        *sig,
                                  unsigned int                sig_len)
{
    UNUSED(mode);
    UNUSED(ctx);
    UNUSED(ctx_len);
 
    return cx_eddsa_verify_no_throw(pukey, hashID, hash, hash_len, sig, sig_len);
}
 
void cx_encode_coord(uint8_t *coord, int len, int sign);
 
int cx_decode_coord(uint8_t *coord, int len);
 
cx_err_t cx_eddsa_sign_init_first_hash(cx_hash_t                   *hash_context,
                                       const cx_ecfp_private_key_t *private_key,
                                       cx_md_t                      hash_id);
 
cx_err_t cx_eddsa_sign_init_second_hash(cx_hash_t                   *hash_context,
                                        const cx_ecfp_private_key_t *private_key,
                                        cx_md_t                      hash_id,
                                        uint8_t                     *hash,
                                        size_t                       hash_len,
                                        uint8_t                     *sig,
                                        size_t                       sig_len);
 
cx_err_t cx_eddsa_sign_hash(const cx_ecfp_private_key_t *pv_key,
                            cx_md_t                      hash_id,
                            const uint8_t               *hash,
                            size_t                       hash_len,
                            uint8_t                     *sig,
                            size_t                       sig_len);
 
cx_err_t cx_eddsa_verify_init_hash(cx_hash_t                  *hash_context,
                                   const cx_ecfp_public_key_t *public_key,
                                   cx_md_t                     hash_id,
                                   const uint8_t              *sig_r,
                                   size_t                      sig_r_len);
 
cx_err_t cx_eddsa_update_hash(cx_hash_t *hash_context, const uint8_t *msg, size_t msg_len);
 
cx_err_t cx_eddsa_final_hash(cx_hash_t *hash_context, uint8_t *hash, size_t hash_len);
 
bool cx_eddsa_verify_hash(const cx_ecfp_public_key_t *public_key,
                          uint8_t                    *hash,
                          size_t                      hash_len,
                          const uint8_t              *signature,
                          size_t                      signature_len);
 
WARN_UNUSED_RESULT cx_err_t cx_eddsa_get_public_key_internal(const cx_ecfp_private_key_t *pv_key,
                                                             cx_md_t                      hashID,
                                                             cx_ecfp_public_key_t        *pu_key,
                                                             uint8_t                     *a,
                                                             size_t                       a_len,
                                                             uint8_t                     *h,
                                                             size_t                       h_len,
                                                             uint8_t *scal /*temp uint8[114]*/);
 
#endif  // HAVE_EDDSA
 
#endif  // LCX_EDDSA_H