1 /* 2 * Port of `<openssl/kdf.h>` 3 * 4 * This header was introduced in v1.1.0. 5 * 6 * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved. 7 * 8 * Licensed under the Apache License 2.0 (the "License"). You may not use 9 * this file except in compliance with the License. You can obtain a copy 10 * in the file LICENSE in the source distribution or at 11 * https://www.openssl.org/source/license.html 12 */ 13 module deimos.openssl.kdf; 14 15 import deimos.openssl.evp; 16 import deimos.openssl.opensslv; 17 import deimos.openssl.types; 18 19 extern (C): 20 nothrow: 21 22 static if (OPENSSL_VERSION_AT_LEAST(3, 0, 0)) 23 { 24 int EVP_KDF_up_ref(EVP_KDF* kdf); 25 void EVP_KDF_free(EVP_KDF* kdf); 26 EVP_KDF* EVP_KDF_fetch( 27 OSSL_LIB_CTX *libctx, const(char)* algorithm, const(char)* properties); 28 29 EVP_KDF_CTX* EVP_KDF_CTX_new(EVP_KDF* kdf); 30 void EVP_KDF_CTX_free(EVP_KDF_CTX* ctx); 31 EVP_KDF_CTX* EVP_KDF_CTX_dup(const(EVP_KDF_CTX)* src); 32 const(char)* EVP_KDF_get0_description(const(EVP_KDF)* kdf); 33 int EVP_KDF_is_a(const(EVP_KDF)* kdf, const(char)* name); 34 const(char)* EVP_KDF_get0_name(const(EVP_KDF)* kdf); 35 const(OSSL_PROVIDER)* EVP_KDF_get0_provider(const(EVP_KDF)* kdf); 36 const(EVP_KDF)* EVP_KDF_CTX_kdf(EVP_KDF_CTX* ctx); 37 38 void EVP_KDF_CTX_reset(EVP_KDF_CTX* ctx); 39 size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX* ctx); 40 int EVP_KDF_derive( 41 EVP_KDF_CTX* ctx, ubyte* key, size_t keylen, const(OSSL_PARAM)* params); 42 int EVP_KDF_get_params(EVP_KDF* kdf, OSSL_PARAM* params); 43 int EVP_KDF_CTX_get_params(EVP_KDF_CTX* ctx, OSSL_PARAM* params); 44 int EVP_KDF_CTX_set_params(EVP_KDF_CTX* ctx, const(OSSL_PARAM)* params); 45 const(OSSL_PARAM)* EVP_KDF_gettable_params(const(EVP_KDF)* kdf); 46 const(OSSL_PARAM)* EVP_KDF_gettable_ctx_params(const(EVP_KDF)* kdf); 47 const(OSSL_PARAM)* EVP_KDF_settable_ctx_params(const(EVP_KDF)* kdf); 48 const(OSSL_PARAM)* EVP_KDF_CTX_gettable_params(EVP_KDF_CTX* ctx); 49 const(OSSL_PARAM)* EVP_KDF_CTX_settable_params(EVP_KDF_CTX* ctx); 50 51 private alias EVP_KDF_apply_fn = extern(C) void function(EVP_KDF* kdf, void* arg); 52 void EVP_KDF_do_all_provided(OSSL_LIB_CTX *libctx, EVP_KDF_apply_fn fn, void* arg); 53 private alias EVP_KDF_names_apply_fn = extern(C) void function(const(char)* name, void* data); 54 int EVP_KDF_names_do_all(const(EVP_KDF)* kdf, EVP_KDF_names_apply_fn fn, void* data); 55 } 56 57 enum EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND = 0; 58 enum EVP_KDF_HKDF_MODE_EXTRACT_ONLY = 1; 59 enum EVP_KDF_HKDF_MODE_EXPAND_ONLY = 2; 60 61 enum EVP_KDF_SSHKDF_TYPE_INITIAL_IV_CLI_TO_SRV = 65; 62 enum EVP_KDF_SSHKDF_TYPE_INITIAL_IV_SRV_TO_CLI = 66; 63 enum EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_CLI_TO_SRV = 67; 64 enum EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_SRV_TO_CLI = 68; 65 enum EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_CLI_TO_SRV = 69; 66 enum EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_SRV_TO_CLI = 70; 67 68 /**** The legacy PKEY-based KDF API follows. ****/ 69 70 enum EVP_PKEY_CTRL_TLS_MD = (EVP_PKEY_ALG_CTRL); 71 enum EVP_PKEY_CTRL_TLS_SECRET = (EVP_PKEY_ALG_CTRL + 1); 72 enum EVP_PKEY_CTRL_TLS_SEED = (EVP_PKEY_ALG_CTRL + 2); 73 enum EVP_PKEY_CTRL_HKDF_MD = (EVP_PKEY_ALG_CTRL + 3); 74 enum EVP_PKEY_CTRL_HKDF_SALT = (EVP_PKEY_ALG_CTRL + 4); 75 enum EVP_PKEY_CTRL_HKDF_KEY = (EVP_PKEY_ALG_CTRL + 5); 76 enum EVP_PKEY_CTRL_HKDF_INFO = (EVP_PKEY_ALG_CTRL + 6); 77 static if (OPENSSL_VERSION_AT_LEAST(1, 1, 1)) 78 { 79 // https://github.com/openssl/openssl/commit/cefa762ee5c28359986c6af5bf4db4e901f75846 80 enum EVP_PKEY_CTRL_HKDF_MODE = (EVP_PKEY_ALG_CTRL + 7); 81 enum EVP_PKEY_CTRL_PASS = (EVP_PKEY_ALG_CTRL + 8); 82 enum EVP_PKEY_CTRL_SCRYPT_SALT = (EVP_PKEY_ALG_CTRL + 9); 83 enum EVP_PKEY_CTRL_SCRYPT_N = (EVP_PKEY_ALG_CTRL + 10); 84 enum EVP_PKEY_CTRL_SCRYPT_R = (EVP_PKEY_ALG_CTRL + 11); 85 enum EVP_PKEY_CTRL_SCRYPT_P = (EVP_PKEY_ALG_CTRL + 12); 86 enum EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES = (EVP_PKEY_ALG_CTRL + 13); 87 } 88 else 89 { 90 // https://github.com/openssl/openssl/blob/OpenSSL_1_1_0l/include/openssl/kdf.h#L59 91 92 /* Error codes for the KDF functions. */ 93 int ERR_load_KDF_strings(); 94 95 /* Function codes. */ 96 enum KDF_F_PKEY_TLS1_PRF_CTRL_STR = 100; 97 enum KDF_F_PKEY_TLS1_PRF_DERIVE = 101; 98 99 /* Reason codes. */ 100 enum KDF_R_INVALID_DIGEST = 100; 101 enum KDF_R_MISSING_PARAMETER = 101; 102 enum KDF_R_VALUE_MISSING = 102; 103 } 104 105 alias EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND = EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND; 106 alias EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY = EVP_KDF_HKDF_MODE_EXTRACT_ONLY; 107 alias EVP_PKEY_HKDEF_MODE_EXPAND_ONLY = EVP_KDF_HKDF_MODE_EXPAND_ONLY; 108 109 static if (OPENSSL_VERSION_AT_LEAST(3, 0, 0)) 110 { 111 // Before 3.0.0 those were macros 112 int EVP_PKEY_CTX_set_tls1_prf_md(EVP_PKEY_CTX* ctx, const(EVP_MD)* md); 113 int EVP_PKEY_CTX_set1_tls1_prf_secret( 114 EVP_PKEY_CTX* pctx, const(ubyte)* sec, int seclen); 115 int EVP_PKEY_CTX_add1_tls1_prf_seed( 116 EVP_PKEY_CTX* pctx, const(ubyte)* seed, int seedlen); 117 118 int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX* ctx, const(EVP_MD)* md); 119 int EVP_PKEY_CTX_set1_hkdf_salt( 120 EVP_PKEY_CTX* ctx, const(ubyte)* salt, int saltlen); 121 int EVP_PKEY_CTX_set1_hkdf_key( 122 EVP_PKEY_CTX* ctx, const(ubyte)* key, int keylen); 123 int EVP_PKEY_CTX_add1_hkdf_info( 124 EVP_PKEY_CTX* ctx, const(ubyte)* info, int infolen); 125 126 int EVP_PKEY_CTX_set_hkdf_mode(EVP_PKEY_CTX* ctx, int mode); 127 alias EVP_PKEY_CTX_hkdf_mode = EVP_PKEY_CTX_set_hkdf_mode; 128 129 int EVP_PKEY_CTX_set1_pbe_pass(EVP_PKEY_CTX* ctx, const(char)* pass, int passlen); 130 131 int EVP_PKEY_CTX_set1_scrypt_salt( 132 EVP_PKEY_CTX* ctx, const(ubyte)* salt, int saltlen); 133 134 int EVP_PKEY_CTX_set_scrypt_N(EVP_PKEY_CTX* ctx, ulong n); 135 int EVP_PKEY_CTX_set_scrypt_r(EVP_PKEY_CTX* ctx, ulong r); 136 int EVP_PKEY_CTX_set_scrypt_p(EVP_PKEY_CTX* ctx, ulong p); 137 138 int EVP_PKEY_CTX_set_scrypt_maxmem_bytes(EVP_PKEY_CTX* ctx, ulong maxmem_bytes); 139 } 140 else 141 { 142 auto EVP_PKEY_CTX_set_tls1_prf_md () (EVP_PKEY_CTX* ctx, const(EVP_MD)* md) 143 { 144 return EVP_PKEY_CTX_ctrl( 145 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_TLS_MD, 0, md); 146 } 147 148 auto EVP_PKEY_CTX_set1_tls1_prf_secret () ( 149 EVP_PKEY_CTX* pctx, const(ubyte)* sec, int seclen) 150 { 151 return EVP_PKEY_CTX_ctrl( 152 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_TLS_SECRET, seclen, sec); 153 } 154 155 auto EVP_PKEY_CTX_add1_tls1_prf_seed () ( 156 EVP_PKEY_CTX* pctx, const(ubyte)* seed, int seedlen) 157 { 158 return EVP_PKEY_CTX_ctrl( 159 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_TLS_SEED, seedlen, seed); 160 } 161 162 auto EVP_PKEY_CTX_set_hkdf_md () (EVP_PKEY_CTX* ctx, const(EVP_MD)* md) 163 { 164 return EVP_PKEY_CTX_ctrl( 165 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_HKDF_MD, 0, md); 166 } 167 auto EVP_PKEY_CTX_set1_hkdf_salt () ( 168 EVP_PKEY_CTX* ctx, const(ubyte)* salt, int saltlen) 169 { 170 return EVP_PKEY_CTX_ctrl( 171 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_HKDF_SALT, saltlen, salt); 172 } 173 auto EVP_PKEY_CTX_set1_hkdf_key () ( 174 EVP_PKEY_CTX* ctx, const(ubyte)* key, int keylen) 175 { 176 return EVP_PKEY_CTX_ctrl( 177 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_HKDF_KEY, keylen, key); 178 } 179 auto EVP_PKEY_CTX_add1_hkdf_info () ( 180 EVP_PKEY_CTX* ctx, const(ubyte)* info, int infolen) 181 { 182 return EVP_PKEY_CTX_ctrl( 183 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_HKDF_INFO, infolen, info); 184 } 185 186 auto EVP_PKEY_CTX_hkdf_mode () (EVP_PKEY_CTX* ctx, int mode) 187 { 188 return EVP_PKEY_CTX_ctrl( 189 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_HKDF_MODE, mode, null); 190 } 191 192 static if (OPENSSL_VERSION_AT_LEAST(1, 1, 1)) 193 { 194 auto EVP_PKEY_CTX_set1_pbe_pass () 195 (EVP_PKEY_CTX* ctx, const(char)* pass, int passlen) 196 { 197 return EVP_PKEY_CTX_ctrl( 198 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_PASS, passlen, pass); 199 } 200 201 auto EVP_PKEY_CTX_set1_scrypt_salt () 202 (EVP_PKEY_CTX* ctx, const(ubyte)* salt, int saltlen) 203 { 204 return EVP_PKEY_CTX_ctrl( 205 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_SCRYPT_SALT, saltlen, salt); 206 } 207 208 auto EVP_PKEY_CTX_set_scrypt_N () 209 (EVP_PKEY_CTX* ctx, ulong n) 210 { 211 return EVP_PKEY_CTX_ctrl_uint64( 212 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_SCRYPT_N, n); 213 } 214 215 auto EVP_PKEY_CTX_set_scrypt_r () 216 (EVP_PKEY_CTX* ctx, ulong n) 217 { 218 return EVP_PKEY_CTX_ctrl_uint64( 219 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_SCRYPT_R, r); 220 } 221 222 auto EVP_PKEY_CTX_set_scrypt_p () 223 (EVP_PKEY_CTX* ctx, ulong n) 224 { 225 return EVP_PKEY_CTX_ctrl_uint64( 226 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_SCRYPT_P, p); 227 } 228 229 auto EVP_PKEY_CTX_set_scrypt_maxmem_bytes () 230 (EVP_PKEY_CTX* ctx, ulong maxmem_bytes) 231 { 232 return EVP_PKEY_CTX_ctrl_uint64( 233 pctx, -1, EVP_PKEY_OP_DERIVE, EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, maxmem_bytes); 234 } 235 } 236 }