ctap.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once

 
#include <stdint.h>
 
#include "mutex.h"
#include "cbor.h"
#include "assert.h"
#include "crypto/modes/ccm.h"
#include "timex.h"
#include "board.h"
 
#include "fido2/ctap.h"
#include "fido2/ctap/ctap_crypto.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define CTAP_PIN_AUTH_SZ 16

#define CTAP_AUTH_DATA_FLAG_UP     (1 << 0)     
#define CTAP_AUTH_DATA_FLAG_UV     (1 << 2)     
#define CTAP_AUTH_DATA_FLAG_AT     (1 << 6)     
#define CTAP_AUTH_DATA_FLAG_ED     (1 << 7)     

#define CTAP_VERSION_FLAG_FIDO_PRE  0x01    
#define CTAP_VERSION_FLAG_FIDO      0x02    
#define CTAP_VERSION_FLAG_U2F_V2    0x04    

#define CTAP_GET_INFO_RESP_OPTIONS_ID_PLAT       "plat"         
#define CTAP_GET_INFO_RESP_OPTIONS_ID_RK         "rk"           
#define CTAP_GET_INFO_RESP_OPTIONS_ID_CLIENT_PIN "clientPin"    
#define CTAP_GET_INFO_RESP_OPTIONS_ID_UP         "up"           
#define CTAP_GET_INFO_RESP_OPTIONS_ID_UV         "uv"           

#define CTAP_INFO_OPTIONS_FLAG_PLAT         (1 << 0)    
#define CTAP_INFO_OPTIONS_FLAG_RK           (1 << 1)    
#define CTAP_INFO_OPTIONS_FLAG_CLIENT_PIN   (1 << 2)    
#define CTAP_INFO_OPTIONS_FLAG_UP           (1 << 3)    
#define CTAP_INFO_OPTIONS_FLAG_UV           (1 << 4)    

typedef enum {
    CTAP_PIN_GET_RETRIES     =    0x01,    
    CTAP_PIN_GET_KEY_AGREEMENT =  0x02,    
    CTAP_PIN_SET_PIN           =  0x03,    
    CTAP_PIN_CHANGE_PIN        =  0x04,    
    CTAP_PIN_GET_PIN_TOKEN     =  0x05    
} ctap_pin_subcommand_t;


#ifdef CONFIG_FIDO2_CTAP_STACK_SIZE
#define CTAP_STACKSIZE CONFIG_FIDO2_CTAP_STACK_SIZE
#else
#define CTAP_STACKSIZE 15000
#endif

#if defined(CONFIG_FIDO2_CTAP_UP_BUTTON_PORT) && defined(CONFIG_FIDO2_CTAP_UP_BUTTON_PIN) && \
    (CONFIG_FIDO2_CTAP_UP_BUTTON_PORT >= 0) && (CONFIG_FIDO2_CTAP_UP_BUTTON_PIN >= 0)
#define CTAP_UP_BUTTON GPIO_PIN(CONFIG_FIDO2_CTAP_UP_BUTTON_PORT, CONFIG_FIDO2_CTAP_UP_BUTTON_PIN)
#else
/* set default button if no button is configured */
#ifdef BTN0_PIN
#define CTAP_UP_BUTTON BTN0_PIN
#else
#define CTAP_UP_BUTTON 0
#define CONFIG_FIDO2_CTAP_DISABLE_UP 1
#endif /* BTN0_PIN */
#endif

#if IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_MODE_IN_PU)
#define CTAP_UP_BUTTON_MODE GPIO_IN_PU
#elif IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_MODE_IN_PD)
#define CTAP_UP_BUTTON_MODE GPIO_IN_PD
#elif IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_MODE_IN)
#define CTAP_UP_BUTTON_MODE GPIO_IN
#else
#define CTAP_UP_BUTTON_MODE GPIO_IN_PU
#endif

#if IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_FLANK_FALLING)
#define CTAP_UP_BUTTON_FLANK GPIO_FALLING
#elif IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_FLANK_RISING)
#define CTAP_UP_BUTTON_FLANK GPIO_RISING
#elif IS_ACTIVE(CONFIG_FIDO2_CTAP_UP_BUTTON_FLANK_BOTH)
#define CTAP_UP_BUTTON_FLANK GPIO_BOTH
#else
#define CTAP_UP_BUTTON_FLANK GPIO_FALLING
#endif

#ifndef CONFIG_FIDO2_CTAP_DISABLE_UP
#define CONFIG_FIDO2_CTAP_DISABLE_UP 0
#endif

#ifndef CONFIG_FIDO2_CTAP_DISABLE_LED
#define CONFIG_FIDO2_CTAP_DISABLE_LED 0
#endif

#define CTAP_RP_MAX_NAME_SIZE   32

#define CTAP_USER_MAX_NAME_SIZE 64 + 1

#define CTAP_USER_ID_MAX_SIZE 64

#define CTAP_DOMAIN_NAME_MAX_SIZE 253 + 1

#define CTAP_ICON_MAX_SIZE  128 + 1

#define CTAP_PIN_MIN_SIZE   4

#define CTAP_PIN_ENC_MIN_SIZE 64

#define CTAP_PIN_ENC_MAX_SIZE 256

#define CTAP_PIN_MAX_SIZE   64

#define CTAP_PIN_MAX_ATTS 8

#define CTAP_PIN_MAX_ATTS_BOOT 3

#define CTAP_PIN_PROT_VER 1

#define CTAP_AMT_SUP_PIN_VER 1

#define CTAP_PIN_TOKEN_SZ 16

#define CTAP_CRED_KEY_LEN 16

#define CTAP_AES_CCM_L 2

#define CTAP_AES_CCM_NONCE_SIZE (15 - CTAP_AES_CCM_L)

#define CTAP_CREDENTIAL_ID_ENC_SIZE (sizeof(struct ctap_resident_key) - \
                                     sizeof(((struct ctap_resident_key *)0)-> \
                                            cred_desc.cred_id) - \
                                     sizeof(((struct ctap_resident_key *)0)-> \
                                            cred_desc.has_nonce))

#ifdef CONFIG_FIDO2_CTAP_UP_TIMEOUT
#define CTAP_UP_TIMEOUT (CONFIG_FIDO2_CTAP_UP_TIMEOUT * MS_PER_SEC)
#else
#define CTAP_UP_TIMEOUT (15 * MS_PER_SEC)
#endif

#define CTAP_GET_NEXT_ASSERTION_TIMEOUT (30 * MS_PER_SEC)

#ifdef CONFIG_FIDO2_CTAP_DEVICE_AAGUID
#define CTAP_AAGUID CONFIG_FIDO2_CTAP_DEVICE_AAGUID
#else
/* randomly generated fallback value */
#define CTAP_AAGUID "9c295865fa2c36b705a42320af9c8f16"
#endif

#define CTAP_PUB_KEY_CRED_PUB_KEY 0x01  
#define CTAP_PUB_KEY_CRED_UNKNOWN 0x02  

#define CTAP_COSE_KEY_LABEL_KTY      1  
#define CTAP_COSE_KEY_LABEL_ALG      3  
#define CTAP_COSE_KEY_LABEL_CRV      -1 
#define CTAP_COSE_KEY_LABEL_X        -2 
#define CTAP_COSE_KEY_LABEL_Y        -3 
#define CTAP_COSE_KEY_KTY_EC2        2  
#define CTAP_COSE_KEY_CRV_P256       1  

#define CTAP_AAGUID_SIZE 16

#define CTAP_COSE_ALG_ES256           -7

#define CTAP_COSE_ALG_ECDH_ES_HKDF_256 -25

#define CTAP_CREDENTIAL_ID_SIZE 16U

#define CTAP_INITIALIZED_MARKER 0x4e

#define CTAP_MAX_EXCLUDE_LIST_SIZE 0x14

typedef struct ctap_cred_desc ctap_cred_desc_t;

typedef struct ctap_cred_desc_alt ctap_cred_desc_alt_t;

typedef struct ctap_resident_key ctap_resident_key_t;

typedef struct {
    uint8_t aaguid[CTAP_AAGUID_SIZE];   
    uint8_t options;                    
} ctap_config_t;

typedef struct {
    ctap_config_t config;                       
    ctap_crypto_key_agreement_key_t ag_key;     
    int rem_pin_att;                            
    uint16_t rk_amount_stored;                  
    uint8_t initialized_marker;                 
    uint8_t pin_hash[SHA256_DIGEST_LENGTH / 2]; 
    uint8_t cred_key[CTAP_CRED_KEY_LEN];        
    bool cred_key_is_initialized;               
    bool pin_is_set;                            
    uint32_t id_cnt;                            
} ctap_state_t;

typedef struct {
    int rk; 
    int uv; 
    int up; 
} ctap_options_t;

typedef struct {
    uint8_t id[CTAP_USER_ID_MAX_SIZE];                  
    uint8_t id_len;                                     
    uint8_t name[CTAP_USER_MAX_NAME_SIZE];              
    uint8_t display_name[CTAP_USER_MAX_NAME_SIZE];      
    uint8_t icon[CTAP_DOMAIN_NAME_MAX_SIZE];            
} ctap_user_ent_t;

typedef struct {
    uint8_t id[CTAP_DOMAIN_NAME_MAX_SIZE + 1];      
    uint8_t id_len;                                 
    uint8_t name[CTAP_RP_MAX_NAME_SIZE + 1];        
    uint8_t icon[CTAP_DOMAIN_NAME_MAX_SIZE + 1];    
} ctap_rp_ent_t;

typedef struct {
    ctap_crypto_pub_key_t pubkey;   
    int kty;                        
    int crv;                        
    int32_t alg_type;               
    uint8_t cred_type;              
} ctap_public_key_cose_t;

struct ctap_cred_desc {
    uint8_t cred_type;                              
    union {
        uint8_t cred_id[CTAP_CREDENTIAL_ID_SIZE];   
        uint8_t nonce[CTAP_AES_CCM_NONCE_SIZE];     
    };
    bool has_nonce;                                 
};

struct __attribute__((packed)) ctap_resident_key {
    uint8_t rp_id_hash[SHA256_DIGEST_LENGTH];   
    uint8_t user_id[CTAP_USER_ID_MAX_SIZE];     
    uint8_t user_id_len;                        
    uint8_t priv_key[CTAP_CRYPTO_KEY_SIZE];     
    uint16_t id;                                
    uint32_t sign_count;                        
    ctap_cred_desc_t cred_desc;                 
};

typedef struct __attribute__((packed)) {
    uint8_t id[CTAP_CREDENTIAL_ID_ENC_SIZE];    
    uint8_t mac[CCM_MAC_MAX_LEN];               
    uint8_t nonce[CTAP_AES_CCM_NONCE_SIZE];     
} ctap_cred_id_t;

struct ctap_cred_desc_alt {
    uint8_t cred_type;          
    ctap_cred_id_t cred_id;     
};

typedef struct {
    ctap_cred_desc_alt_t exclude_list[CTAP_MAX_EXCLUDE_LIST_SIZE];  
    size_t exclude_list_len;                                        
    ctap_rp_ent_t rp;                                               
    ctap_user_ent_t user;                                           
    ctap_options_t options;                                         
    uint8_t client_data_hash[SHA256_DIGEST_LENGTH];                 
    uint8_t pin_auth[CTAP_PIN_AUTH_SZ];                             
    size_t pin_auth_len;                                            
    int32_t alg_type;                                               
    bool pin_auth_present;                                          
    uint8_t pin_protocol;                                           
    uint8_t cred_type;                                              
} ctap_make_credential_req_t;

typedef struct {
    ctap_options_t options;                                         
    ctap_cred_desc_alt_t allow_list[CTAP_MAX_EXCLUDE_LIST_SIZE];    
    uint8_t client_data_hash[SHA256_DIGEST_LENGTH];                 
    uint8_t rp_id[CTAP_DOMAIN_NAME_MAX_SIZE + 1];                   
    uint8_t rp_id_len;                                              
    uint8_t allow_list_len;                                         
    uint8_t pin_auth[CTAP_PIN_AUTH_SZ];                             
    size_t pin_auth_len;                                            
    uint8_t pin_protocol;                                           
    bool pin_auth_present;                                          
} ctap_get_assertion_req_t;

typedef struct {
    ctap_public_key_cose_t key_agreement;                       
    uint16_t new_pin_enc_size;                                  
    uint8_t pin_auth[CTAP_PIN_AUTH_SZ];                         
    uint8_t new_pin_enc[CTAP_PIN_ENC_MAX_SIZE];                 
    uint8_t pin_hash_enc[SHA256_DIGEST_LENGTH / 2];             
    ctap_pin_subcommand_t sub_command;                          
    uint8_t pin_protocol;                                       
    bool pin_hash_enc_present;                                  
    bool pin_auth_present;                                      
    bool key_agreement_present;                                 
} ctap_client_pin_req_t;

typedef struct __attribute__((packed)){
    uint8_t aaguid[CTAP_AAGUID_SIZE];   
    uint8_t cred_len_h;                 
    uint8_t cred_len_l;                 
    ctap_cred_id_t cred_id;             
} ctap_attested_cred_data_header_t;

typedef struct {
    ctap_attested_cred_data_header_t header;    
    ctap_public_key_cose_t key;                 
} ctap_attested_cred_data_t;

typedef struct __attribute__((packed)){
    uint8_t rp_id_hash[SHA256_DIGEST_LENGTH];   
    uint8_t flags;                              
    uint32_t sign_count;                        
} ctap_auth_data_header_t;

typedef struct {
    ctap_auth_data_header_t header;                 
    ctap_attested_cred_data_t attested_cred_data;   
} ctap_auth_data_t;

typedef struct {
    uint16_t max_msg_size;              
    uint8_t aaguid[CTAP_AAGUID_SIZE];   
    uint8_t versions;                   
    uint8_t options;                    
    uint8_t pin_protocol;               
    bool pin_is_set;                    
} ctap_info_t;

int fido2_ctap_get_sig(const uint8_t *auth_data, size_t auth_data_len,
                       const uint8_t *client_data_hash,
                       const ctap_resident_key_t *rk,
                       uint8_t *sig, size_t *sig_len);

bool fido2_ctap_cred_params_supported(uint8_t cred_type, int32_t alg_type);

int fido2_ctap_encrypt_rk(ctap_resident_key_t *rk, uint8_t *nonce,
                          size_t nonce_len, ctap_cred_id_t *id);

bool fido2_ctap_pin_is_set(void);

ctap_state_t *fido2_ctap_get_state(void);
 
#ifdef __cplusplus
}
#endif