1 /* 2 * Copyright (c) 2018-2021 Yubico AB. All rights reserved. 3 * Use of this source code is governed by a BSD-style 4 * license that can be found in the LICENSE file. 5 */ 6 7 #include <openssl/evp.h> 8 #include <openssl/sha.h> 9 #if defined(LIBRESSL_VERSION_NUMBER) 10 #include <openssl/hkdf.h> 11 #elif OPENSSL_VERSION_NUMBER >= 0x10100000L 12 #include <openssl/kdf.h> 13 #endif 14 15 #include "fido.h" 16 #include "fido/es256.h" 17 18 #if defined(LIBRESSL_VERSION_NUMBER) || OPENSSL_VERSION_NUMBER < 0x10100000L 19 static int 20 hkdf_sha256(uint8_t *key, const char *info, const fido_blob_t *secret) 21 { 22 const EVP_MD *md; 23 uint8_t salt[32]; 24 25 memset(salt, 0, sizeof(salt)); 26 if ((md = EVP_sha256()) == NULL || 27 HKDF(key, SHA256_DIGEST_LENGTH, md, secret->ptr, secret->len, salt, 28 sizeof(salt), (const uint8_t *)info, strlen(info)) != 1) 29 return -1; 30 31 return 0; 32 } 33 #else 34 static int 35 hkdf_sha256(uint8_t *key, char *info, fido_blob_t *secret) 36 { 37 const EVP_MD *const_md; 38 EVP_MD *md = NULL; 39 EVP_PKEY_CTX *ctx = NULL; 40 size_t keylen = SHA256_DIGEST_LENGTH; 41 uint8_t salt[32]; 42 int ok = -1; 43 44 memset(salt, 0, sizeof(salt)); 45 if (secret->len > INT_MAX || strlen(info) > INT_MAX) { 46 fido_log_debug("%s: invalid param", __func__); 47 goto fail; 48 } 49 if ((const_md = EVP_sha256()) == NULL || 50 (md = EVP_MD_meth_dup(const_md)) == NULL || 51 (ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)) == NULL) { 52 fido_log_debug("%s: init", __func__); 53 goto fail; 54 } 55 if (EVP_PKEY_derive_init(ctx) < 1 || 56 EVP_PKEY_CTX_set_hkdf_md(ctx, md) < 1 || 57 EVP_PKEY_CTX_set1_hkdf_salt(ctx, salt, sizeof(salt)) < 1 || 58 EVP_PKEY_CTX_set1_hkdf_key(ctx, secret->ptr, (int)secret->len) < 1 || 59 EVP_PKEY_CTX_add1_hkdf_info(ctx, info, (int)strlen(info)) < 1) { 60 fido_log_debug("%s: EVP_PKEY_CTX", __func__); 61 goto fail; 62 } 63 if (EVP_PKEY_derive(ctx, key, &keylen) < 1) { 64 fido_log_debug("%s: EVP_PKEY_derive", __func__); 65 goto fail; 66 } 67 68 ok = 0; 69 fail: 70 if (md != NULL) 71 EVP_MD_meth_free(md); 72 if (ctx != NULL) 73 EVP_PKEY_CTX_free(ctx); 74 75 return ok; 76 } 77 #endif /* defined(LIBRESSL_VERSION_NUMBER) || OPENSSL_VERSION_NUMBER < 0x10100000L */ 78 79 static int 80 kdf(uint8_t prot, fido_blob_t *key, /* const */ fido_blob_t *secret) 81 { 82 char hmac_info[] = "CTAP2 HMAC key"; /* const */ 83 char aes_info[] = "CTAP2 AES key"; /* const */ 84 85 switch (prot) { 86 case CTAP_PIN_PROTOCOL1: 87 /* use sha256 on the resulting secret */ 88 key->len = SHA256_DIGEST_LENGTH; 89 if ((key->ptr = calloc(1, key->len)) == NULL || 90 SHA256(secret->ptr, secret->len, key->ptr) != key->ptr) { 91 fido_log_debug("%s: SHA256", __func__); 92 return -1; 93 } 94 break; 95 case CTAP_PIN_PROTOCOL2: 96 /* use two instances of hkdf-sha256 on the resulting secret */ 97 key->len = 2 * SHA256_DIGEST_LENGTH; 98 if ((key->ptr = calloc(1, key->len)) == NULL || 99 hkdf_sha256(key->ptr, hmac_info, secret) < 0 || 100 hkdf_sha256(key->ptr + SHA256_DIGEST_LENGTH, aes_info, 101 secret) < 0) { 102 fido_log_debug("%s: hkdf", __func__); 103 return -1; 104 } 105 break; 106 default: 107 fido_log_debug("%s: unknown pin protocol %u", __func__, prot); 108 return -1; 109 } 110 111 return 0; 112 } 113 114 static int 115 do_ecdh(const fido_dev_t *dev, const es256_sk_t *sk, const es256_pk_t *pk, 116 fido_blob_t **ecdh) 117 { 118 EVP_PKEY *pk_evp = NULL; 119 EVP_PKEY *sk_evp = NULL; 120 EVP_PKEY_CTX *ctx = NULL; 121 fido_blob_t *secret = NULL; 122 int ok = -1; 123 124 *ecdh = NULL; 125 if ((secret = fido_blob_new()) == NULL || 126 (*ecdh = fido_blob_new()) == NULL) 127 goto fail; 128 if ((pk_evp = es256_pk_to_EVP_PKEY(pk)) == NULL || 129 (sk_evp = es256_sk_to_EVP_PKEY(sk)) == NULL) { 130 fido_log_debug("%s: es256_to_EVP_PKEY", __func__); 131 goto fail; 132 } 133 if ((ctx = EVP_PKEY_CTX_new(sk_evp, NULL)) == NULL || 134 EVP_PKEY_derive_init(ctx) <= 0 || 135 EVP_PKEY_derive_set_peer(ctx, pk_evp) <= 0) { 136 fido_log_debug("%s: EVP_PKEY_derive_init", __func__); 137 goto fail; 138 } 139 if (EVP_PKEY_derive(ctx, NULL, &secret->len) <= 0 || 140 (secret->ptr = calloc(1, secret->len)) == NULL || 141 EVP_PKEY_derive(ctx, secret->ptr, &secret->len) <= 0) { 142 fido_log_debug("%s: EVP_PKEY_derive", __func__); 143 goto fail; 144 } 145 if (kdf(fido_dev_get_pin_protocol(dev), *ecdh, secret) < 0) { 146 fido_log_debug("%s: kdf", __func__); 147 goto fail; 148 } 149 150 ok = 0; 151 fail: 152 if (pk_evp != NULL) 153 EVP_PKEY_free(pk_evp); 154 if (sk_evp != NULL) 155 EVP_PKEY_free(sk_evp); 156 if (ctx != NULL) 157 EVP_PKEY_CTX_free(ctx); 158 if (ok < 0) 159 fido_blob_free(ecdh); 160 161 fido_blob_free(&secret); 162 163 return ok; 164 } 165 166 int 167 fido_do_ecdh(fido_dev_t *dev, es256_pk_t **pk, fido_blob_t **ecdh) 168 { 169 es256_sk_t *sk = NULL; /* our private key */ 170 es256_pk_t *ak = NULL; /* authenticator's public key */ 171 int r; 172 173 *pk = NULL; 174 *ecdh = NULL; 175 if ((sk = es256_sk_new()) == NULL || (*pk = es256_pk_new()) == NULL) { 176 r = FIDO_ERR_INTERNAL; 177 goto fail; 178 } 179 if (es256_sk_create(sk) < 0 || es256_derive_pk(sk, *pk) < 0) { 180 fido_log_debug("%s: es256_derive_pk", __func__); 181 r = FIDO_ERR_INTERNAL; 182 goto fail; 183 } 184 if ((ak = es256_pk_new()) == NULL || 185 fido_dev_authkey(dev, ak) != FIDO_OK) { 186 fido_log_debug("%s: fido_dev_authkey", __func__); 187 r = FIDO_ERR_INTERNAL; 188 goto fail; 189 } 190 if (do_ecdh(dev, sk, ak, ecdh) < 0) { 191 fido_log_debug("%s: do_ecdh", __func__); 192 r = FIDO_ERR_INTERNAL; 193 goto fail; 194 } 195 196 r = FIDO_OK; 197 fail: 198 es256_sk_free(&sk); 199 es256_pk_free(&ak); 200 201 if (r != FIDO_OK) { 202 es256_pk_free(pk); 203 fido_blob_free(ecdh); 204 } 205 206 return r; 207 } 208