lcx_ecdsa.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_ECDSA_H
#define LCX_ECDSA_H
 
#ifdef HAVE_ECDSA
 
#include "lcx_wrappers.h"
#include "lcx_ecfp.h"
 
#define cx_ecdsa_init_public_key  cx_ecfp_init_public_key_no_throw
#define cx_ecdsa_init_private_key cx_ecfp_init_private_key_no_throw
 
WARN_UNUSED_RESULT cx_err_t cx_ecdsa_sign_no_throw(const cx_ecfp_private_key_t *pvkey,
                                                   uint32_t                     mode,
                                                   cx_md_t                      hashID,
                                                   const uint8_t               *hash,
                                                   size_t                       hash_len,
                                                   uint8_t                     *sig,
                                                   size_t                      *sig_len,
                                                   uint32_t                    *info);
 
DEPRECATED static inline size_t cx_ecdsa_sign(const cx_ecfp_private_key_t *pvkey,
                                              uint32_t                     mode,
                                              cx_md_t                      hashID,
                                              const unsigned char         *hash,
                                              unsigned int                 hash_len,
                                              unsigned char               *sig,
                                              unsigned int                 sig_len,
                                              unsigned int                *info)
{
    size_t   sig_len_ = sig_len;
    uint32_t info_;
    CX_THROW(cx_ecdsa_sign_no_throw(pvkey, mode, hashID, hash, hash_len, sig, &sig_len_, &info_));
    if (info) {
        *info = (uint32_t) info_;
    }
    return sig_len_;
}
 
WARN_UNUSED_RESULT cx_err_t cx_ecdsa_sign_rs_no_throw(const cx_ecfp_private_key_t *key,
                                                      uint32_t                     mode,
                                                      cx_md_t                      hashID,
                                                      const uint8_t               *hash,
                                                      size_t                       hash_len,
                                                      size_t                       rs_len,
                                                      uint8_t                     *sig_r,
                                                      uint8_t                     *sig_s,
                                                      uint32_t                    *info);
 
WARN_UNUSED_RESULT bool cx_ecdsa_verify_no_throw(const cx_ecfp_public_key_t *pukey,
                                                 const uint8_t              *hash,
                                                 size_t                      hash_len,
                                                 const uint8_t              *sig,
                                                 size_t                      sig_len);
 
DEPRECATED static inline bool cx_ecdsa_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        *sig,
                                              unsigned int                sig_len)
{
    UNUSED(mode);
    UNUSED(hashID);
    return cx_ecdsa_verify_no_throw(pukey, hash, hash_len, sig, sig_len);
}
 
#endif  // HAVE_ECDSA
 
#endif  // LCX_ECDSA_H