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         HMAC_CTX_reset(hctx);
  92         memcpy(p, digtmp, cplen);
  93         for (j = 1; j < iter; j++) {
  94             if (!HMAC_CTX_copy(hctx, hctx_tpl)) {
  95                 HMAC_CTX_free(hctx);
  96                 HMAC_CTX_free(hctx_tpl);
  97                 return 0;
  98             }
  99             if (!HMAC_Update(hctx, digtmp, mdlen)
 100                 || !HMAC_Final(hctx, digtmp, NULL)) {
 101                 HMAC_CTX_free(hctx);
 102                 HMAC_CTX_free(hctx_tpl);
 103                 return 0;
 104             }
 105             HMAC_CTX_reset(hctx);
 106             for (k = 0; k < cplen; k++)
 107                 p[k] ^= digtmp[k];
 108         }
 109         tkeylen -= cplen;
 110         i++;
 111         p += cplen;
 112     }
 113     HMAC_CTX_free(hctx);
 114     HMAC_CTX_free(hctx_tpl);
 115 # ifdef OPENSSL_DEBUG_PKCS5V2
 116     fprintf(stderr, "Password:\n");
 117     h__dump(pass, passlen);
 118     fprintf(stderr, "Salt:\n");
 119     h__dump(salt, saltlen);
 120     fprintf(stderr, "Iteration count %d\n", iter);
 121     fprintf(stderr, "Key:\n");
 122     h__dump(out, keylen);
 123 # endif
 124     return 1;
 125 }
 126
 127 int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
 128                            const unsigned char *salt, int saltlen, int iter,
 129                            int keylen, unsigned char *out)
 130 {
 131     return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, EVP_sha1(),
 132                              keylen, out);
 133 }
 134
 135 /*
 136  * Now the key derivation function itself. This is a bit evil because it has
 137  * to check the ASN1 parameters are valid: and there are quite a few of
 138  * them...
 139  */
 140
 141 int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 142                           ASN1_TYPE *param, const EVP_CIPHER *c,
 143                           const EVP_MD *md, int en_de)
 144 {
 145     PBE2PARAM *pbe2 = NULL;
 146     const EVP_CIPHER *cipher;
 147     EVP_PBE_KEYGEN *kdf;
 148
 149     int rv = 0;
 150
 151     pbe2 = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBE2PARAM), param);
 152     if (pbe2 == NULL) {
 153         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
 154         goto err;
 155     }
 156
 157     /* See if we recognise the key derivation function */
 158     if (!EVP_PBE_find(EVP_PBE_TYPE_KDF, OBJ_obj2nid(pbe2->keyfunc->algorithm),
 159                         NULL, NULL, &kdf)) {
 160         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
 161                EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
 162         goto err;
 163     }
 164
 165     /*
 166      * lets see if we recognise the encryption algorithm.
 167      */
 168
 169     cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);
 170
 171     if (!cipher) {
 172         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_UNSUPPORTED_CIPHER);
 173         goto err;
 174     }
 175
 176     /* Fixup cipher based on AlgorithmIdentifier */
 177     if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
 178         goto err;
 179     if (EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
 180         EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_CIPHER_PARAMETER_ERROR);
 181         goto err;
 182     }
 183     rv = kdf(ctx, pass, passlen, pbe2->keyfunc->parameter, NULL, NULL, en_de);
 184  err:
 185     PBE2PARAM_free(pbe2);
 186     return rv;
 187 }
 188
 189 int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
 190                              int passlen, ASN1_TYPE *param,
 191                              const EVP_CIPHER *c, const EVP_MD *md, int en_de)
 192 {
 193     unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
 194     int saltlen, iter;
 195     int rv = 0;
 196     unsigned int keylen = 0;
 197     int prf_nid, hmac_md_nid;
 198     PBKDF2PARAM *kdf = NULL;
 199     const EVP_MD *prfmd;
 200
 201     if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
 202         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);
 203         goto err;
 204     }
 205     keylen = EVP_CIPHER_CTX_key_length(ctx);
 206     OPENSSL_assert(keylen <= sizeof key);
 207
 208     /* Decode parameter */
 209
 210     kdf = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), param);
 211
 212     if (kdf == NULL) {
 213         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
 214         goto err;
 215     }
 216
 217     keylen = EVP_CIPHER_CTX_key_length(ctx);
 218
 219     /* Now check the parameters of the kdf */
 220
 221     if (kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)) {
 222         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_KEYLENGTH);
 223         goto err;
 224     }
 225
 226     if (kdf->prf)
 227         prf_nid = OBJ_obj2nid(kdf->prf->algorithm);
 228     else
 229         prf_nid = NID_hmacWithSHA1;
 230
 231     if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {
 232         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
 233         goto err;
 234     }
 235
 236     prfmd = EVP_get_digestbynid(hmac_md_nid);
 237     if (prfmd == NULL) {
 238         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
 239         goto err;
 240     }
 241
 242     if (kdf->salt->type != V_ASN1_OCTET_STRING) {
 243         EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_SALT_TYPE);
 244         goto err;
 245     }
 246
 247     /* it seems that its all OK */
 248     salt = kdf->salt->value.octet_string->data;
 249     saltlen = kdf->salt->value.octet_string->length;
 250     iter = ASN1_INTEGER_get(kdf->iter);
 251     if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
 252                            keylen, key))
 253         goto err;
 254     rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
 255  err:
 256     OPENSSL_cleanse(key, keylen);
 257     PBKDF2PARAM_free(kdf);
 258     return rv;
 259 }
 260
 261 # ifdef OPENSSL_DEBUG_PKCS5V2
 262 static void h__dump(const unsigned char *p, int len)
 263 {
 264     for (; len--; p++)
 265         fprintf(stderr, "%02X ", *p);
 266     fprintf(stderr, "\n");
 267 }
 268 # endif