[thirdparty/openssl.git] / crypto / evp / p5_crpt2.c

/*
 * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include <stdlib.h>
#include "internal/cryptlib.h"
#include <openssl/x509.h>
#include <openssl/evp.h>
#include <openssl/kdf.h>
#include <openssl/hmac.h>
#include <openssl/trace.h>
#include "internal/evp_int.h"
#include "evp_locl.h"

int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
                      const unsigned char *salt, int saltlen, int iter,
                      const EVP_MD *digest, int keylen, unsigned char *out)
{
    const char *empty = "";
    int rv = 1;
    EVP_KDF_CTX *kctx;

    /* Keep documented behaviour. */
    if (pass == NULL) {
        pass = empty;
        passlen = 0;
    } else if (passlen == -1) {
        passlen = strlen(pass);
    }
    if (salt == NULL && saltlen == 0)
        salt = (unsigned char *)empty;

    kctx = EVP_KDF_CTX_new_id(EVP_KDF_PBKDF2);
    if (kctx == NULL)
        return 0;
    if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, pass, (size_t)passlen) != 1
            || EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PBKDF2_PKCS5_MODE, 1) != 1
            || EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT,
                            salt, (size_t)saltlen) != 1
            || EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_ITER, iter) != 1
            || EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, digest) != 1
            || EVP_KDF_derive(kctx, out, keylen) != 1)
        rv = 0;

    EVP_KDF_CTX_free(kctx);

    OSSL_TRACE_BEGIN(PKCS5V2) {
        BIO_printf(trc_out, "Password:\n");
        BIO_hex_string(trc_out,
                       0, passlen, pass, passlen);
        BIO_printf(trc_out, "\n");
        BIO_printf(trc_out, "Salt:\n");
        BIO_hex_string(trc_out,
                       0, saltlen, salt, saltlen);
        BIO_printf(trc_out, "\n");
        BIO_printf(trc_out, "Iteration count %d\n", iter);
        BIO_printf(trc_out, "Key:\n");
        BIO_hex_string(trc_out,
                       0, keylen, out, keylen);
        BIO_printf(trc_out, "\n");
    } OSSL_TRACE_END(PKCS5V2);
    return rv;
}

int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
                           const unsigned char *salt, int saltlen, int iter,
                           int keylen, unsigned char *out)
{
    return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, EVP_sha1(),
                             keylen, out);
}

/*
 * Now the key derivation function itself. This is a bit evil because it has
 * to check the ASN1 parameters are valid: and there are quite a few of
 * them...
 */

int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                          ASN1_TYPE *param, const EVP_CIPHER *c,
                          const EVP_MD *md, int en_de)
{
    PBE2PARAM *pbe2 = NULL;
    const EVP_CIPHER *cipher;
    EVP_PBE_KEYGEN *kdf;

    int rv = 0;

    pbe2 = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBE2PARAM), param);
    if (pbe2 == NULL) {
        EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
        goto err;
    }

    /* See if we recognise the key derivation function */
    if (!EVP_PBE_find(EVP_PBE_TYPE_KDF, OBJ_obj2nid(pbe2->keyfunc->algorithm),
                        NULL, NULL, &kdf)) {
        EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
               EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
        goto err;
    }

    /*
     * lets see if we recognise the encryption algorithm.
     */

    cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);

    if (!cipher) {
        EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_UNSUPPORTED_CIPHER);
        goto err;
    }

    /* Fixup cipher based on AlgorithmIdentifier */
    if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
        goto err;
    if (EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
        EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_CIPHER_PARAMETER_ERROR);
        goto err;
    }
    rv = kdf(ctx, pass, passlen, pbe2->keyfunc->parameter, NULL, NULL, en_de);
 err:
    PBE2PARAM_free(pbe2);
    return rv;
}

int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
                             int passlen, ASN1_TYPE *param,
                             const EVP_CIPHER *c, const EVP_MD *md, int en_de)
{
    unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
    int saltlen, iter, t;
    int rv = 0;
    unsigned int keylen = 0;
    int prf_nid, hmac_md_nid;
    PBKDF2PARAM *kdf = NULL;
    const EVP_MD *prfmd;

    if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);
        goto err;
    }
    keylen = EVP_CIPHER_CTX_key_length(ctx);
    OPENSSL_assert(keylen <= sizeof(key));

    /* Decode parameter */

    kdf = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), param);

    if (kdf == NULL) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
        goto err;
    }

    t = EVP_CIPHER_CTX_key_length(ctx);
    if (t < 0) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_INVALID_KEY_LENGTH);
        goto err;
    }
    keylen = t;

    /* Now check the parameters of the kdf */

    if (kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_KEYLENGTH);
        goto err;
    }

    if (kdf->prf)
        prf_nid = OBJ_obj2nid(kdf->prf->algorithm);
    else
        prf_nid = NID_hmacWithSHA1;

    if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
        goto err;
    }

    prfmd = EVP_get_digestbynid(hmac_md_nid);
    if (prfmd == NULL) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
        goto err;
    }

    if (kdf->salt->type != V_ASN1_OCTET_STRING) {
        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_SALT_TYPE);
        goto err;
    }

    /* it seems that its all OK */
    salt = kdf->salt->value.octet_string->data;
    saltlen = kdf->salt->value.octet_string->length;
    iter = ASN1_INTEGER_get(kdf->iter);
    if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
                           keylen, key))
        goto err;
    rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
 err:
    OPENSSL_cleanse(key, keylen);
    PBKDF2PARAM_free(kdf);
    return rv;
}
Commit	Line	Data
0f113f3e	1	/*
f0efeea2	2	* Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved.
97e4a932	3	*
4a8b0c55	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
62867571 RS	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
97e4a932	8	*/
62867571	9
97e4a932 DSH	10	#include <stdio.h>
97e4a932 DSH	11	#include <stdlib.h>
b39fc560	12	#include "internal/cryptlib.h"
5a285add DM	13	#include <openssl/x509.h>
	14	#include <openssl/evp.h>
	15	#include <openssl/kdf.h>
	16	#include <openssl/hmac.h>
3a9b3d2d	17	#include <openssl/trace.h>
5a285add DM	18	#include "internal/evp_int.h"
5a285add DM	19	#include "evp_locl.h"
97e4a932	20
856640b5	21	int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
0f113f3e MC	22	const unsigned char *salt, int saltlen, int iter,
	23	const EVP_MD digest, int keylen, unsigned char out)
	24	{
fa013b65	25	const char *empty = "";
5a285add DM	26	int rv = 1;
5a285add DM	27	EVP_KDF_CTX *kctx;
0f113f3e	28
5a285add	29	/* Keep documented behaviour. */
fa013b65 PB	30	if (pass == NULL) {
fa013b65 PB	31	pass = empty;
0f113f3e	32	passlen = 0;
fa013b65	33	} else if (passlen == -1) {
0f113f3e	34	passlen = strlen(pass);
fa013b65	35	}
5a285add DM	36	if (salt == NULL && saltlen == 0)
	37	salt = (unsigned char *)empty;
	38
	39	kctx = EVP_KDF_CTX_new_id(EVP_KDF_PBKDF2);
	40	if (kctx == NULL)
0f113f3e	41	return 0;
5a285add	42	if (EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PASS, pass, (size_t)passlen) != 1
f0efeea2	43	\|\| EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_PBKDF2_PKCS5_MODE, 1) != 1
5a285add DM	44	\|\| EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_SALT,
	45	salt, (size_t)saltlen) != 1
	46	\|\| EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_ITER, iter) != 1
	47	\|\| EVP_KDF_ctrl(kctx, EVP_KDF_CTRL_SET_MD, digest) != 1
	48	\|\| EVP_KDF_derive(kctx, out, keylen) != 1)
	49	rv = 0;
	50
	51	EVP_KDF_CTX_free(kctx);
	52
3a9b3d2d RL	53	OSSL_TRACE_BEGIN(PKCS5V2) {
	54	BIO_printf(trc_out, "Password:\n");
	55	BIO_hex_string(trc_out,
	56	0, passlen, pass, passlen);
	57	BIO_printf(trc_out, "\n");
	58	BIO_printf(trc_out, "Salt:\n");
	59	BIO_hex_string(trc_out,
	60	0, saltlen, salt, saltlen);
	61	BIO_printf(trc_out, "\n");
	62	BIO_printf(trc_out, "Iteration count %d\n", iter);
	63	BIO_printf(trc_out, "Key:\n");
	64	BIO_hex_string(trc_out,
	65	0, keylen, out, keylen);
	66	BIO_printf(trc_out, "\n");
	67	} OSSL_TRACE_END(PKCS5V2);
5a285add	68	return rv;
0f113f3e	69	}
856640b5 DSH	70
856640b5 DSH	71	int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
0f113f3e MC	72	const unsigned char *salt, int saltlen, int iter,
	73	int keylen, unsigned char *out)
	74	{
	75	return PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, EVP_sha1(),
	76	keylen, out);
	77	}
	78
0f113f3e MC	79	/*
	80	* Now the key derivation function itself. This is a bit evil because it has
	81	* to check the ASN1 parameters are valid: and there are quite a few of
	82	* them...
97e4a932 DSH	83	*/
	84
	85	int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX ctx, const char pass, int passlen,
0f113f3e MC	86	ASN1_TYPE param, const EVP_CIPHER c,
0f113f3e MC	87	const EVP_MD *md, int en_de)
97e4a932	88	{
0f113f3e MC	89	PBE2PARAM *pbe2 = NULL;
0f113f3e MC	90	const EVP_CIPHER *cipher;
d6c5462e	91	EVP_PBE_KEYGEN *kdf;
0f113f3e MC	92
	93	int rv = 0;
	94
e93c8748 DSH	95	pbe2 = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBE2PARAM), param);
e93c8748 DSH	96	if (pbe2 == NULL) {
0f113f3e MC	97	EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_DECODE_ERROR);
	98	goto err;
	99	}
	100
	101	/* See if we recognise the key derivation function */
d6c5462e	102	if (!EVP_PBE_find(EVP_PBE_TYPE_KDF, OBJ_obj2nid(pbe2->keyfunc->algorithm),
dccd20d1	103	NULL, NULL, &kdf)) {
0f113f3e MC	104	EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN,
	105	EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION);
	106	goto err;
	107	}
	108
	109	/*
	110	* lets see if we recognise the encryption algorithm.
	111	*/
	112
	113	cipher = EVP_get_cipherbyobj(pbe2->encryption->algorithm);
	114
	115	if (!cipher) {
	116	EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_UNSUPPORTED_CIPHER);
	117	goto err;
	118	}
	119
	120	/* Fixup cipher based on AlgorithmIdentifier */
	121	if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, en_de))
	122	goto err;
	123	if (EVP_CIPHER_asn1_to_param(ctx, pbe2->encryption->parameter) < 0) {
	124	EVPerr(EVP_F_PKCS5_V2_PBE_KEYIVGEN, EVP_R_CIPHER_PARAMETER_ERROR);
	125	goto err;
	126	}
d6c5462e	127	rv = kdf(ctx, pass, passlen, pbe2->keyfunc->parameter, NULL, NULL, en_de);
0f113f3e MC	128	err:
	129	PBE2PARAM_free(pbe2);
	130	return rv;
3d63b396 DSH	131	}
3d63b396 DSH	132
0f113f3e MC	133	int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX ctx, const char pass,
	134	int passlen, ASN1_TYPE *param,
	135	const EVP_CIPHER c, const EVP_MD md, int en_de)
3d63b396	136	{
0f113f3e	137	unsigned char *salt, key[EVP_MAX_KEY_LENGTH];
ea053ec9	138	int saltlen, iter, t;
0f113f3e MC	139	int rv = 0;
	140	unsigned int keylen = 0;
	141	int prf_nid, hmac_md_nid;
	142	PBKDF2PARAM *kdf = NULL;
	143	const EVP_MD *prfmd;
	144
	145	if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {
	146	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);
	147	goto err;
	148	}
	149	keylen = EVP_CIPHER_CTX_key_length(ctx);
cbe29648	150	OPENSSL_assert(keylen <= sizeof(key));
0f113f3e MC	151
	152	/* Decode parameter */
	153
e93c8748	154	kdf = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), param);
0f113f3e	155
e93c8748	156	if (kdf == NULL) {
0f113f3e MC	157	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);
	158	goto err;
	159	}
	160
ea053ec9 P	161	t = EVP_CIPHER_CTX_key_length(ctx);
	162	if (t < 0) {
	163	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_INVALID_KEY_LENGTH);
	164	goto err;
	165	}
	166	keylen = t;
0f113f3e MC	167
	168	/* Now check the parameters of the kdf */
	169
	170	if (kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)) {
	171	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_KEYLENGTH);
	172	goto err;
	173	}
	174
	175	if (kdf->prf)
	176	prf_nid = OBJ_obj2nid(kdf->prf->algorithm);
	177	else
	178	prf_nid = NID_hmacWithSHA1;
	179
	180	if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {
	181	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
	182	goto err;
	183	}
	184
	185	prfmd = EVP_get_digestbynid(hmac_md_nid);
	186	if (prfmd == NULL) {
	187	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);
	188	goto err;
	189	}
	190
	191	if (kdf->salt->type != V_ASN1_OCTET_STRING) {
	192	EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_SALT_TYPE);
	193	goto err;
	194	}
	195
	196	/* it seems that its all OK */
	197	salt = kdf->salt->value.octet_string->data;
	198	saltlen = kdf->salt->value.octet_string->length;
	199	iter = ASN1_INTEGER_get(kdf->iter);
	200	if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,
	201	keylen, key))
	202	goto err;
	203	rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de);
	204	err:
	205	OPENSSL_cleanse(key, keylen);
	206	PBKDF2PARAM_free(kdf);
	207	return rv;
97e4a932	208	}