1 /* $OpenBSD: hm_pmeth.c,v 1.13 2022/03/30 07:17:48 tb Exp $ */ 2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 3 * project 2007. 4 */ 5 /* ==================================================================== 6 * Copyright (c) 2007 The OpenSSL Project. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in 17 * the documentation and/or other materials provided with the 18 * distribution. 19 * 20 * 3. All advertising materials mentioning features or use of this 21 * software must display the following acknowledgment: 22 * "This product includes software developed by the OpenSSL Project 23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 24 * 25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 26 * endorse or promote products derived from this software without 27 * prior written permission. For written permission, please contact 28 * licensing@OpenSSL.org. 29 * 30 * 5. Products derived from this software may not be called "OpenSSL" 31 * nor may "OpenSSL" appear in their names without prior written 32 * permission of the OpenSSL Project. 33 * 34 * 6. Redistributions of any form whatsoever must retain the following 35 * acknowledgment: 36 * "This product includes software developed by the OpenSSL Project 37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 50 * OF THE POSSIBILITY OF SUCH DAMAGE. 51 * ==================================================================== 52 * 53 * This product includes cryptographic software written by Eric Young 54 * (eay@cryptsoft.com). This product includes software written by Tim 55 * Hudson (tjh@cryptsoft.com). 56 * 57 */ 58 59 #include <stdio.h> 60 #include <string.h> 61 62 #include <openssl/evp.h> 63 #include <openssl/hmac.h> 64 #include <openssl/x509.h> 65 #include <openssl/x509v3.h> 66 67 #include "evp_locl.h" 68 #include "hmac_local.h" 69 70 /* HMAC pkey context structure */ 71 72 typedef struct { 73 const EVP_MD *md; /* MD for HMAC use */ 74 ASN1_OCTET_STRING ktmp; /* Temp storage for key */ 75 HMAC_CTX ctx; 76 } HMAC_PKEY_CTX; 77 78 static int 79 pkey_hmac_init(EVP_PKEY_CTX *ctx) 80 { 81 HMAC_PKEY_CTX *hctx; 82 83 if ((hctx = calloc(1, sizeof(HMAC_PKEY_CTX))) == NULL) 84 return 0; 85 86 hctx->ktmp.type = V_ASN1_OCTET_STRING; 87 HMAC_CTX_init(&hctx->ctx); 88 89 ctx->data = hctx; 90 ctx->keygen_info_count = 0; 91 92 return 1; 93 } 94 95 static int 96 pkey_hmac_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) 97 { 98 HMAC_PKEY_CTX *sctx, *dctx; 99 100 if (!pkey_hmac_init(dst)) 101 return 0; 102 sctx = src->data; 103 dctx = dst->data; 104 dctx->md = sctx->md; 105 HMAC_CTX_init(&dctx->ctx); 106 if (!HMAC_CTX_copy(&dctx->ctx, &sctx->ctx)) 107 return 0; 108 if (sctx->ktmp.data) { 109 if (!ASN1_OCTET_STRING_set(&dctx->ktmp, sctx->ktmp.data, 110 sctx->ktmp.length)) 111 return 0; 112 } 113 return 1; 114 } 115 116 static void 117 pkey_hmac_cleanup(EVP_PKEY_CTX *ctx) 118 { 119 HMAC_PKEY_CTX *hctx; 120 121 if ((hctx = ctx->data) == NULL) 122 return; 123 124 HMAC_CTX_cleanup(&hctx->ctx); 125 freezero(hctx->ktmp.data, hctx->ktmp.length); 126 free(hctx); 127 } 128 129 static int 130 pkey_hmac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) 131 { 132 ASN1_OCTET_STRING *hkey = NULL; 133 HMAC_PKEY_CTX *hctx = ctx->data; 134 135 if (!hctx->ktmp.data) 136 return 0; 137 hkey = ASN1_OCTET_STRING_dup(&hctx->ktmp); 138 if (!hkey) 139 return 0; 140 EVP_PKEY_assign(pkey, EVP_PKEY_HMAC, hkey); 141 142 return 1; 143 } 144 145 static int 146 int_update(EVP_MD_CTX *ctx, const void *data, size_t count) 147 { 148 HMAC_PKEY_CTX *hctx = ctx->pctx->data; 149 150 if (!HMAC_Update(&hctx->ctx, data, count)) 151 return 0; 152 return 1; 153 } 154 155 static int 156 hmac_signctx_init(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx) 157 { 158 HMAC_PKEY_CTX *hctx = ctx->data; 159 160 HMAC_CTX_set_flags(&hctx->ctx, mctx->flags & ~EVP_MD_CTX_FLAG_NO_INIT); 161 EVP_MD_CTX_set_flags(mctx, EVP_MD_CTX_FLAG_NO_INIT); 162 mctx->update = int_update; 163 return 1; 164 } 165 166 static int 167 hmac_signctx(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, 168 EVP_MD_CTX *mctx) 169 { 170 unsigned int hlen; 171 HMAC_PKEY_CTX *hctx = ctx->data; 172 int l = EVP_MD_CTX_size(mctx); 173 174 if (l < 0) 175 return 0; 176 *siglen = l; 177 if (!sig) 178 return 1; 179 180 if (!HMAC_Final(&hctx->ctx, sig, &hlen)) 181 return 0; 182 *siglen = (size_t)hlen; 183 return 1; 184 } 185 186 static int 187 pkey_hmac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) 188 { 189 HMAC_PKEY_CTX *hctx = ctx->data; 190 ASN1_OCTET_STRING *key; 191 192 switch (type) { 193 case EVP_PKEY_CTRL_SET_MAC_KEY: 194 if ((!p2 && p1 > 0) || (p1 < -1)) 195 return 0; 196 if (!ASN1_OCTET_STRING_set(&hctx->ktmp, p2, p1)) 197 return 0; 198 break; 199 200 case EVP_PKEY_CTRL_MD: 201 hctx->md = p2; 202 break; 203 204 case EVP_PKEY_CTRL_DIGESTINIT: 205 key = (ASN1_OCTET_STRING *)ctx->pkey->pkey.ptr; 206 if (!HMAC_Init_ex(&hctx->ctx, key->data, key->length, hctx->md, 207 ctx->engine)) 208 return 0; 209 break; 210 211 default: 212 return -2; 213 } 214 return 1; 215 } 216 217 static int 218 pkey_hmac_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value) 219 { 220 if (!value) 221 return 0; 222 if (!strcmp(type, "key")) { 223 void *p = (void *)value; 224 return pkey_hmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, -1, p); 225 } 226 if (!strcmp(type, "hexkey")) { 227 unsigned char *key; 228 int r; 229 long keylen; 230 key = string_to_hex(value, &keylen); 231 if (!key) 232 return 0; 233 r = pkey_hmac_ctrl(ctx, EVP_PKEY_CTRL_SET_MAC_KEY, keylen, key); 234 free(key); 235 return r; 236 } 237 return -2; 238 } 239 240 const EVP_PKEY_METHOD hmac_pkey_meth = { 241 .pkey_id = EVP_PKEY_HMAC, 242 243 .init = pkey_hmac_init, 244 .copy = pkey_hmac_copy, 245 .cleanup = pkey_hmac_cleanup, 246 247 .keygen = pkey_hmac_keygen, 248 249 .signctx_init = hmac_signctx_init, 250 .signctx = hmac_signctx, 251 252 .ctrl = pkey_hmac_ctrl, 253 .ctrl_str = pkey_hmac_ctrl_str 254 }; 255