crypto/evp/p5_crpt2.c

   1 /*
   2  * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include "internal/cryptlib.h"
  13 # include <openssl/x509.h>
  14 # include <openssl/evp.h>
  15 # include <openssl/hmac.h>
  16 # include "evp_locl.h"
  17
  18 /* set this to print out info about the keygen algorithm */
  19 /* #define OPENSSL_DEBUG_PKCS5V2 */
  20
  21 # ifdef OPENSSL_DEBUG_PKCS5V2
  22 static void h__dump(const unsigned char *p, int len);
  23 # endif
  24
  25 /*
  26  * This is an implementation of PKCS#5 v2.0 password based encryption key
  27  * derivation function PBKDF2. SHA1 version verified against test vectors
  28  * posted by Peter Gutmann <pgut001@cs.auckland.ac.nz> to the PKCS-TNG
  29  * <pkcs-tng@rsa.com> mailing list.
  30  */
  31
  32 int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
  33                       const unsigned char *salt, int saltlen, int iter,
  34                       const EVP_MD *digest, int keylen, unsigned char *out)
  35 {
  36     const char *empty = "";
  37     unsigned char digtmp[EVP_MAX_MD_SIZE], *p, itmp[4];
  38     int cplen, j, k, tkeylen, mdlen;
  39     unsigned long i = 1;
  40     HMAC_CTX *hctx_tpl = NULL, *hctx = NULL;
  41
  42     mdlen = EVP_MD_size(digest);
  43     if (mdlen < 0)
  44         return 0;
  45
  46     hctx_tpl = HMAC_CTX_new();
  47     if (hctx_tpl == NULL)
  48         return 0;
  49     p = out;
  50     tkeylen = keylen;
  51     if (pass == NULL) {
  52         pass = empty;
  53         passlen = 0;
  54     } else if (passlen == -1) {
  55         passlen = strlen(pass);
  56     }
  57     if (!HMAC_Init_ex(hctx_tpl, pass, passlen, digest, NULL)) {
  58         HMAC_CTX_free(hctx_tpl);
  59         return 0;
  60     }
  61     hctx = HMAC_CTX_new();
  62     if (hctx == NULL) {
  63         HMAC_CTX_free(hctx_tpl);
  64         return 0;
  65     }
  66     while (tkeylen) {
  67         if (tkeylen > mdlen)
  68             cplen = mdlen;
  69         else
  70             cplen = tkeylen;
  71         /*
  72          * We are unlikely to ever use more than 256 blocks (5120 bits!) but
  73          * just in case...
  74          */
  75         itmp[0] = (unsigned char)((i >> 24) & 0xff);
  76         itmp[1] = (unsigned char)((i >> 16) & 0xff);
  77         itmp[2] = (unsigned char)((i >> 8) & 0xff);
  78         itmp[3] = (unsigned char)(i & 0xff);
  79         if (!HMAC_CTX_copy(hctx, hctx_tpl)) {
  80             HMAC_CTX_free(hctx);
  81             HMAC_CTX_free(hctx_tpl);
  82             return 0;
  83         }
  84         if (!HMAC_Update(hctx, salt, saltlen)
  85             || !HMAC_Update(hctx, itmp, 4)
  86             || !HMAC_Final(hctx, digtmp, NULL)) {
  87             HMAC_CTX_free(hctx);
  88             HMAC_CTX_free(hctx_tpl);
  89             return 0;
  90         }
  91         memcpy(p, digtmp, cplen);
  92         for (j = 1; j < iter; j++) {
  93             if (!HMAC_CTX_copy(hctx, hctx_tpl)) {
  94                 HMAC_CTX_free(hctx);
  95                 HMAC_CTX_free(hctx_tpl);
  96                 return 0;
  97             }
  98             if (!HMAC_Update(hctx, digtmp, mdlen)
  99                 || !HMAC_Final(hctx, digtmp, NULL)) {
 100                 HMAC_CTX_free(hctx);
 101                 HMAC_CTX_free(hctx_tpl);
 102                 return 0;
 103             }
 104             for (k = 0; k < cplen; k++)
 105                 p[k] ^= digtmp[k];
 106         }
 107         tkeylen -= cplen;
 108         i++;
 109         p += cplen;
 110     }
 111     HMAC_CTX_free(hctx);
 112     HMAC_CTX_free(hctx_tpl);
 113 # ifdef OPENSSL_DEBUG_PKCS5V2
 114     fprintf(stderr, "Password:\n");
 115     h__dump(pass, passlen);
 116     fprintf(stderr, "Salt:\n");
 117     h__dump(salt, saltlen);
 118     fprintf(stderr, "Iteration count %d\n", iter);
 119     fprintf(stderr, "Key:\n");
 120     h__dump(out, keylen);
 121 # endif
 122     return 1;
 123 }
 124
 125 int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
 126                            const unsigned char *salt, int saltlen, int iter,
 127                            int keylen, unsigned char *out)
 128 {
 129     return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, EVP_sha1(),
 130                              keylen, out);
 131 }
 132
 133 /*
 134  * Now the key derivation function itself. This is a bit evil because it has
 135  * to check the ASN1 parameters are valid: and there are quite a few of
 136  * them...
 137  */
 138
 139 int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 140                           ASN1_TYPE *param, const EVP_CIPHER *c,
 141                           const EVP_MD *md, int en_de)
 142 {
 143     PBE2PARAM *pbe2 = NULL;
 144     const EVP_CIPHER *cipher;
 145     EVP_PBE_KEYGEN *kdf;
 146
 147     int rv = 0;
 148
 149     pbe2 = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBE2PARAM), param);
 150     if (pbe2 == NULL) {
 151         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
 152         goto err;
 153     }
 154
 155     /* See if we recognise the key derivation function */
 156     if (!EVP_PBE_find(EVP_PBE_TYPE_KDF, OBJ_obj2nid(pbe2->keyfunc->algorithm),
 157                         NULL, NULL, &kdf)) {
 158         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
 159                EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
 160         goto err;
 161     }
 162
 163     /*
 164      * lets see if we recognise the encryption algorithm.
 165      */
 166
 167     cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);
 168
 169     if (!cipher) {
 170         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_UNSUPPORTED_CIPHER);
 171         goto err;
 172     }
 173
 174     /* Fixup cipher based on AlgorithmIdentifier */
 175     if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
 176         goto err;
 177     if (EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
 178         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_CIPHER_PARAMETER_ERROR);
 179         goto err;
 180     }
 181     rv = kdf(ctx, pass, passlen, pbe2->keyfunc->parameter, NULL, NULL, en_de);
 182  err:
 183     PBE2PARAM_free(pbe2);
 184     return rv;
 185 }
 186
 187 int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
 188                              int passlen, ASN1_TYPE *param,
 189                              const EVP_CIPHER *c, const EVP_MD *md, int en_de)
 190 {
 191     unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
 192     int saltlen, iter;
 193     int rv = 0;
 194     unsigned int keylen = 0;
 195     int prf_nid, hmac_md_nid;
 196     PBKDF2PARAM *kdf = NULL;
 197     const EVP_MD *prfmd;
 198
 199     if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
 200         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);
 201         goto err;
 202     }
 203     keylen = EVP_CIPHER_CTX_key_length(ctx);
 204     OPENSSL_assert(keylen <= sizeof key);
 205
 206     /* Decode parameter */
 207
 208     kdf = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), param);
 209
 210     if (kdf == NULL) {
 211         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
 212         goto err;
 213     }
 214
 215     keylen = EVP_CIPHER_CTX_key_length(ctx);
 216
 217     /* Now check the parameters of the kdf */
 218
 219     if (kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)) {
 220         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_KEYLENGTH);
 221         goto err;
 222     }
 223
 224     if (kdf->prf)
 225         prf_nid = OBJ_obj2nid(kdf->prf->algorithm);
 226     else
 227         prf_nid = NID_hmacWithSHA1;
 228
 229     if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {
 230         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
 231         goto err;
 232     }
 233
 234     prfmd = EVP_get_digestbynid(hmac_md_nid);
 235     if (prfmd == NULL) {
 236         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
 237         goto err;
 238     }
 239
 240     if (kdf->salt->type != V_ASN1_OCTET_STRING) {
 241         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_SALT_TYPE);
 242         goto err;
 243     }
 244
 245     /* it seems that its all OK */
 246     salt = kdf->salt->value.octet_string->data;
 247     saltlen = kdf->salt->value.octet_string->length;
 248     iter = ASN1_INTEGER_get(kdf->iter);
 249     if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
 250                            keylen, key))
 251         goto err;
 252     rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
 253  err:
 254     OPENSSL_cleanse(key, keylen);
 255     PBKDF2PARAM_free(kdf);
 256     return rv;
 257 }
 258
 259 # ifdef OPENSSL_DEBUG_PKCS5V2
 260 static void h__dump(const unsigned char *p, int len)
 261 {
 262     for (; len--; p++)
 263         fprintf(stderr, "%02X ", *p);
 264     fprintf(stderr, "\n");
 265 }
 266 # endif