lcx_hash.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_HASH_H
#define LCX_HASH_H
 
#ifdef HAVE_HASH
 
#include "cx_errors.h"
#include "lcx_wrappers.h"
#include "lcx_common.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
enum cx_md_e {
    CX_NONE = 0,  
    // 20 bytes
    CX_RIPEMD160 = 1,  
    // 28 bytes
    CX_SHA224 = 2,  
    // 32 bytes
    CX_SHA256 = 3,  
    // 48 bytes
    CX_SHA384 = 4,  
    // 64 bytes
    CX_SHA512 = 5,  
    // 28,32,48,64 bytes
    CX_KECCAK = 6,  
    // 28,32,48,64 bytes
    CX_SHA3      = 7,  
    DEPRECATED_0 = 8,  
    CX_BLAKE2B   = 9,  
    // any bytes
    CX_SHAKE128 = 10,  
    // any bytes
    CX_SHAKE256 = 11,  
    CX_SHA3_256 = 12,  
    CX_SHA3_512 = 13,  
};
 
#define SHA256_BLOCK_SIZE 64
#define SHA512_BLOCK_SIZE 128
 
typedef enum cx_md_e cx_md_t;
 
#define CX_HASH_MAX_BLOCK_COUNT 65535
 
typedef struct cx_hash_header_s cx_hash_t;
 
typedef struct {
    cx_md_t md_type;                        
    size_t  output_size;                    
    size_t  block_size;                     
    size_t  ctx_size;                       
    cx_err_t (*init_func)(cx_hash_t *ctx);  
    cx_err_t (*update_func)(cx_hash_t     *ctx,
                            const uint8_t *data,
                            size_t         len);                       
    cx_err_t (*finish_func)(cx_hash_t *ctx, uint8_t *digest);  
    cx_err_t (*init_ex_func)(
        cx_hash_t *ctx,
        size_t     output_size);  
    size_t (*output_size_func)(const cx_hash_t *ctx);  
} cx_hash_info_t;
 
struct cx_hash_header_s {
    const cx_hash_info_t *info;     
    uint32_t              counter;  
};
 
size_t cx_hash_get_size(const cx_hash_t *ctx);
 
WARN_UNUSED_RESULT cx_err_t cx_hash_no_throw(cx_hash_t     *hash,
                                             uint32_t       mode,
                                             const uint8_t *in,
                                             size_t         len,
                                             uint8_t       *out,
                                             size_t         out_len);
 
DEPRECATED static inline size_t cx_hash(cx_hash_t           *hash,
                                        uint32_t             mode,
                                        const unsigned char *in,
                                        unsigned int         len,
                                        unsigned char       *out,
                                        unsigned int         out_len)
{
    CX_THROW(cx_hash_no_throw(hash, mode, in, len, out, out_len));
    return cx_hash_get_size(hash);
}
 
WARN_UNUSED_RESULT cx_err_t cx_hash_init(cx_hash_t *hash, cx_md_t hash_id);
 
WARN_UNUSED_RESULT cx_err_t cx_hash_init_ex(cx_hash_t *hash, cx_md_t hash_id, size_t output_size);
 
WARN_UNUSED_RESULT cx_err_t cx_hash_update(cx_hash_t *hash, const uint8_t *in, size_t in_len);
 
WARN_UNUSED_RESULT cx_err_t cx_hash_final(cx_hash_t *hash, uint8_t *digest);
 
const cx_hash_info_t *cx_hash_get_info(cx_md_t md_type);
 
void cx_hkdf_extract(const cx_md_t        hash_id,
                     const unsigned char *ikm,
                     unsigned int         ikm_len,
                     unsigned char       *salt,
                     unsigned int         salt_len,
                     unsigned char       *prk);
 
void cx_hkdf_expand(const cx_md_t        hash_id,
                    const unsigned char *prk,
                    unsigned int         prk_len,
                    unsigned char       *info,
                    unsigned int         info_len,
                    unsigned char       *okm,
                    unsigned int         okm_len);
 
#endif  // HAVE_HASH
 
#endif  // LCX_HASH_H