lcx_aead.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_AEAD_H
#define LCX_AEAD_H
 
#if defined(HAVE_AEAD)
 
#include "cx_errors.h"
#include <stddef.h>
#if defined(HAVE_AES_GCM)
#include "lcx_aes_gcm.h"
#endif
#if defined(HAVE_CHACHA_POLY) && defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
#include "lcx_chacha_poly.h"
#endif
 
#define GCM_MAX_IV_LENGTH 64
#define MAX_TAG_LENGTH    16
 
typedef enum {
    CX_AEAD_AES128_GCM,        
    CX_AEAD_AES192_GCM,        
    CX_AEAD_AES256_GCM,        
    CX_AEAD_CHACHA20_POLY1305  
} cx_aead_type_t;
 
typedef struct {
    void (*init)(void *ctx);  
    cx_err_t (*set_key)(void *ctx, const uint8_t *key, size_t key_len);  
    cx_err_t (*start)(void          *ctx,
                      uint32_t       mode,
                      const uint8_t *iv,
                      size_t         iv_len);  
    cx_err_t (*update_aad)(void          *ctx,
                           const uint8_t *aad,
                           size_t aad_len);  
    cx_err_t (*update)(void          *ctx,
                       const uint8_t *input,
                       uint8_t       *output,
                       size_t         len);  
    cx_err_t (*finish)(void    *ctx,
                       uint8_t *tag,
                       size_t   tag_len);  
    cx_err_t (*encrypt_and_tag)(void          *ctx,
                                const uint8_t *input,
                                size_t         len,
                                const uint8_t *iv,
                                size_t         iv_len,
                                const uint8_t *aad,
                                size_t         aad_len,
                                uint8_t       *output,
                                uint8_t       *tag,
                                size_t tag_len);  
 
    cx_err_t (*auth_decrypt)(void          *ctx,
                             const uint8_t *input,
                             size_t         len,
                             const uint8_t *iv,
                             size_t         iv_len,
                             const uint8_t *aad,
                             size_t         aad_len,
                             uint8_t       *output,
                             const uint8_t *tag,
                             size_t tag_len);  
    cx_err_t (*check_tag)(void *ctx, const uint8_t *tag, size_t tag_len);  
} cx_aead_base_t;
 
typedef struct {
    cx_aead_type_t        type;        
    size_t                key_bitlen;  
    size_t                block_size;  
    const cx_aead_base_t *func;        
} cx_aead_info_t;
 
typedef struct {
    const cx_aead_info_t *info;  
    uint32_t              mode;  
    void *base_ctx;  
} cx_aead_context_t;
 
WARN_UNUSED_RESULT cx_err_t cx_aead_init(cx_aead_context_t *ctx);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_setup(cx_aead_context_t *ctx, cx_aead_type_t type);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_set_key(cx_aead_context_t *ctx,
                                            const uint8_t     *key,
                                            size_t             key_len,
                                            uint32_t           mode);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_set_iv(cx_aead_context_t *ctx,
                                           const uint8_t     *iv,
                                           size_t             iv_len);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_update_ad(cx_aead_context_t *ctx,
                                              const uint8_t     *ad,
                                              size_t             ad_len);
 
WARN_UNUSED_RESULT cx_err_t
cx_aead_update(cx_aead_context_t *ctx, uint8_t *in, size_t in_len, uint8_t *out, size_t *out_len);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_write_tag(cx_aead_context_t *ctx, uint8_t *tag, size_t tag_len);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_check_tag(cx_aead_context_t *ctx,
                                              const uint8_t     *tag,
                                              size_t             tag_len);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_encrypt(cx_aead_context_t *ctx,
                                            const uint8_t     *iv,
                                            size_t             iv_len,
                                            const uint8_t     *ad,
                                            size_t             ad_len,
                                            uint8_t           *in,
                                            size_t             in_len,
                                            uint8_t           *out,
                                            size_t            *out_len,
                                            uint8_t           *tag,
                                            size_t             tag_len);
 
WARN_UNUSED_RESULT cx_err_t cx_aead_decrypt(cx_aead_context_t *ctx,
                                            const uint8_t     *iv,
                                            size_t             iv_len,
                                            const uint8_t     *ad,
                                            size_t             ad_len,
                                            uint8_t           *in,
                                            size_t             in_len,
                                            uint8_t           *out,
                                            size_t            *out_len,
                                            const uint8_t     *tag,
                                            size_t             tag_len);
 
#endif  // HAVE_AEAD
 
#endif  // LCX_AED_H