[thirdparty/openssl.git] / crypto / dh / dh_pmeth.c

/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2006.
 */
/* ====================================================================
 * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/asn1t.h>
#include <openssl/x509.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/dh.h>
#include <openssl/bn.h>
#include "evp_locl.h"

/* DH pkey context structure */

typedef struct
	{
	/* Parameter gen parameters */
	int prime_len;
	int generator;
	int use_dsa;
	/* Keygen callback info */
	int gentmp[2];
	/* message digest */
	} DH_PKEY_CTX;

static int pkey_dh_init(EVP_PKEY_CTX *ctx)
	{
	DH_PKEY_CTX *dctx;
	dctx = OPENSSL_malloc(sizeof(DH_PKEY_CTX));
	if (!dctx)
		return 0;
	dctx->prime_len = 1024;
	dctx->generator = 2;
	dctx->use_dsa = 0;

	ctx->data = dctx;
	ctx->keygen_info = dctx->gentmp;
	ctx->keygen_info_count = 2;
	
	return 1;
	}

static int pkey_dh_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
	{
	DH_PKEY_CTX *dctx, *sctx;
	if (!pkey_dh_init(dst))
		return 0;
       	sctx = src->data;
	dctx = dst->data;
	dctx->prime_len = sctx->prime_len;
	dctx->generator = sctx->generator;
	dctx->use_dsa = sctx->use_dsa;
	return 1;
	}

static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
	{
	DH_PKEY_CTX *dctx = ctx->data;
	if (dctx)
		OPENSSL_free(dctx);
	}

static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
	{
	DH_PKEY_CTX *dctx = ctx->data;
	switch (type)
		{
		case EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN:
		if (p1 < 256)
			return -2;
		dctx->prime_len = p1;
		return 1;

		case EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR:
		dctx->generator = p1;
		return 1;

		case EVP_PKEY_CTRL_PEER_KEY:
		/* Default behaviour is OK */
		return 1;

		default:
		return -2;

		}
	}

			
static int pkey_dh_ctrl_str(EVP_PKEY_CTX *ctx,
			const char *type, const char *value)
	{
	if (!strcmp(type, "dh_paramgen_prime_len"))
		{
		int len;
		len = atoi(value);
		return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len);
		}
	if (!strcmp(type, "dh_paramgen_generator"))
		{
		int len;
		len = atoi(value);
		return EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, len);
		}
	return -2;
	}

static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
	{
	DH *dh = NULL;
	DH_PKEY_CTX *dctx = ctx->data;
	BN_GENCB *pcb, cb;
	int ret;
	if (ctx->pkey_gencb)
		{
		pcb = &cb;
		evp_pkey_set_cb_translate(pcb, ctx);
		}
	else
		pcb = NULL;
	dh = DH_new();
	if (!dh)
		return 0;
	ret = DH_generate_parameters_ex(dh,
					dctx->prime_len, dctx->generator, pcb);
	if (ret)
		EVP_PKEY_assign_DH(pkey, dh);
	else
		DH_free(dh);
	return ret;
	}

static int pkey_dh_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
	{
	DH *dh = NULL;
	if (ctx->pkey == NULL)
		{
		DHerr(DH_F_PKEY_DH_KEYGEN, DH_R_NO_PARAMETERS_SET);
		return 0;
		}
	dh = DH_new();
	if (!dh)
		return 0;
	EVP_PKEY_assign_DH(pkey, dh);
	/* Note: if error return, pkey is freed by parent routine */
	if (!EVP_PKEY_copy_parameters(pkey, ctx->pkey))
		return 0;
	return DH_generate_key(pkey->pkey.dh);
	}

static int pkey_dh_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
	{
	int ret;
	if (!ctx->pkey || !ctx->peerkey)
		{
		DHerr(DH_F_PKEY_DH_DERIVE, DH_R_KEYS_NOT_SET);
		return 0;
		}
	ret = DH_compute_key(key, ctx->peerkey->pkey.dh->pub_key,
							ctx->pkey->pkey.dh);
	if (ret < 0)
		return ret;
	*keylen = ret;
	return 1;
	}

const EVP_PKEY_METHOD dh_pkey_meth = 
	{
	EVP_PKEY_DH,
	EVP_PKEY_FLAG_AUTOARGLEN,
	pkey_dh_init,
	pkey_dh_copy,
	pkey_dh_cleanup,

	0,
	pkey_dh_paramgen,

	0,
	pkey_dh_keygen,

	0,
	0,

	0,
	0,

	0,0,

	0,0,0,0,

	0,0,

	0,0,

	0,
	pkey_dh_derive,

	pkey_dh_ctrl,
	pkey_dh_ctrl_str

	};
Commit	Line	Data
2e597528	1	/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3ba0885a DSH	2	* project 2006.
	3	*/
	4	/* ====================================================================
	5	* Copyright (c) 2006 The OpenSSL Project. All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	*
	14	* 2. Redistributions in binary form must reproduce the above copyright
	15	* notice, this list of conditions and the following disclaimer in
	16	* the documentation and/or other materials provided with the
	17	* distribution.
	18	*
	19	* 3. All advertising materials mentioning features or use of this
	20	* software must display the following acknowledgment:
	21	* "This product includes software developed by the OpenSSL Project
	22	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	23	*
	24	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	25	* endorse or promote products derived from this software without
	26	* prior written permission. For written permission, please contact
	27	* licensing@OpenSSL.org.
	28	*
	29	* 5. Products derived from this software may not be called "OpenSSL"
	30	* nor may "OpenSSL" appear in their names without prior written
	31	* permission of the OpenSSL Project.
	32	*
	33	* 6. Redistributions of any form whatsoever must retain the following
	34	* acknowledgment:
	35	* "This product includes software developed by the OpenSSL Project
	36	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	37	*
	38	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
	39	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	40	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	41	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	42	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	43	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	44	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	45	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	46	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	47	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	48	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	49	* OF THE POSSIBILITY OF SUCH DAMAGE.
	50	* ====================================================================
	51	*
	52	* This product includes cryptographic software written by Eric Young
	53	* (eay@cryptsoft.com). This product includes software written by Tim
	54	* Hudson (tjh@cryptsoft.com).
	55	*
	56	*/
	57
	58	#include <stdio.h>
	59	#include "cryptlib.h"
	60	#include <openssl/asn1t.h>
	61	#include <openssl/x509.h>
	62	#include <openssl/rsa.h>
	63	#include <openssl/evp.h>
1e26a8ba GT	64	#include <openssl/dh.h>
1e26a8ba GT	65	#include <openssl/bn.h>
3ba0885a DSH	66	#include "evp_locl.h"
	67
	68	/* DH pkey context structure */
	69
	70	typedef struct
	71	{
	72	/* Parameter gen parameters */
	73	int prime_len;
	74	int generator;
	75	int use_dsa;
	76	/* Keygen callback info */
	77	int gentmp[2];
	78	/* message digest */
	79	} DH_PKEY_CTX;
	80
	81	static int pkey_dh_init(EVP_PKEY_CTX *ctx)
	82	{
	83	DH_PKEY_CTX *dctx;
	84	dctx = OPENSSL_malloc(sizeof(DH_PKEY_CTX));
	85	if (!dctx)
	86	return 0;
	87	dctx->prime_len = 1024;
	88	dctx->generator = 2;
	89	dctx->use_dsa = 0;
	90
	91	ctx->data = dctx;
	92	ctx->keygen_info = dctx->gentmp;
	93	ctx->keygen_info_count = 2;
	94
	95	return 1;
	96	}
	97
8bdcef40 DSH	98	static int pkey_dh_copy(EVP_PKEY_CTX dst, EVP_PKEY_CTX src)
	99	{
	100	DH_PKEY_CTX dctx, sctx;
	101	if (!pkey_dh_init(dst))
	102	return 0;
	103	sctx = src->data;
	104	dctx = dst->data;
	105	dctx->prime_len = sctx->prime_len;
	106	dctx->generator = sctx->generator;
	107	dctx->use_dsa = sctx->use_dsa;
	108	return 1;
	109	}
	110
3ba0885a DSH	111	static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
	112	{
	113	DH_PKEY_CTX *dctx = ctx->data;
	114	if (dctx)
	115	OPENSSL_free(dctx);
	116	}
	117
	118	static int pkey_dh_ctrl(EVP_PKEY_CTX ctx, int type, int p1, void p2)
	119	{
	120	DH_PKEY_CTX *dctx = ctx->data;
	121	switch (type)
	122	{
	123	case EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN:
	124	if (p1 < 256)
	125	return -2;
	126	dctx->prime_len = p1;
	127	return 1;
	128
	129	case EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR:
	130	dctx->generator = p1;
	131	return 1;
	132
ffb1ac67 DSH	133	case EVP_PKEY_CTRL_PEER_KEY:
	134	/* Default behaviour is OK */
	135	return 1;
	136
3ba0885a DSH	137	default:
	138	return -2;
	139
	140	}
	141	}
ffb1ac67	142
3ba0885a DSH	143
	144	static int pkey_dh_ctrl_str(EVP_PKEY_CTX *ctx,
	145	const char type, const char value)
	146	{
	147	if (!strcmp(type, "dh_paramgen_prime_len"))
	148	{
	149	int len;
	150	len = atoi(value);
	151	return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len);
	152	}
	153	if (!strcmp(type, "dh_paramgen_generator"))
	154	{
	155	int len;
	156	len = atoi(value);
	157	return EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, len);
	158	}
	159	return -2;
	160	}
	161
	162	static int pkey_dh_paramgen(EVP_PKEY_CTX ctx, EVP_PKEY pkey)
	163	{
	164	DH *dh = NULL;
	165	DH_PKEY_CTX *dctx = ctx->data;
	166	BN_GENCB *pcb, cb;
	167	int ret;
	168	if (ctx->pkey_gencb)
	169	{
	170	pcb = &cb;
	171	evp_pkey_set_cb_translate(pcb, ctx);
	172	}
	173	else
	174	pcb = NULL;
	175	dh = DH_new();
	176	if (!dh)
	177	return 0;
	178	ret = DH_generate_parameters_ex(dh,
	179	dctx->prime_len, dctx->generator, pcb);
	180	if (ret)
	181	EVP_PKEY_assign_DH(pkey, dh);
	182	else
	183	DH_free(dh);
	184	return ret;
	185	}
	186
	187	static int pkey_dh_keygen(EVP_PKEY_CTX ctx, EVP_PKEY pkey)
	188	{
	189	DH *dh = NULL;
	190	if (ctx->pkey == NULL)
	191	{
52c11dce	192	DHerr(DH_F_PKEY_DH_KEYGEN, DH_R_NO_PARAMETERS_SET);
3ba0885a DSH	193	return 0;
	194	}
	195	dh = DH_new();
	196	if (!dh)
	197	return 0;
	198	EVP_PKEY_assign_DH(pkey, dh);
	199	/* Note: if error return, pkey is freed by parent routine */
	200	if (!EVP_PKEY_copy_parameters(pkey, ctx->pkey))
	201	return 0;
	202	return DH_generate_key(pkey->pkey.dh);
	203	}
	204
eaff5a14	205	static int pkey_dh_derive(EVP_PKEY_CTX ctx, unsigned char key, size_t *keylen)
ffb1ac67 DSH	206	{
	207	int ret;
	208	if (!ctx->pkey \|\| !ctx->peerkey)
	209	{
	210	DHerr(DH_F_PKEY_DH_DERIVE, DH_R_KEYS_NOT_SET);
	211	return 0;
	212	}
	213	ret = DH_compute_key(key, ctx->peerkey->pkey.dh->pub_key,
	214	ctx->pkey->pkey.dh);
	215	if (ret < 0)
	216	return ret;
	217	*keylen = ret;
	218	return 1;
	219	}
	220
3ba0885a DSH	221	const EVP_PKEY_METHOD dh_pkey_meth =
	222	{
	223	EVP_PKEY_DH,
b010b7c4	224	EVP_PKEY_FLAG_AUTOARGLEN,
3ba0885a	225	pkey_dh_init,
8bdcef40	226	pkey_dh_copy,
3ba0885a DSH	227	pkey_dh_cleanup,
	228
	229	0,
	230	pkey_dh_paramgen,
	231
	232	0,
	233	pkey_dh_keygen,
	234
	235	0,
	236	0,
	237
	238	0,
	239	0,
	240
	241	0,0,
	242
	243	0,0,0,0,
	244
	245	0,0,
	246
	247	0,0,
	248
ffb1ac67 DSH	249	0,
ffb1ac67 DSH	250	pkey_dh_derive,
d87e6152	251
3ba0885a DSH	252	pkey_dh_ctrl,
	253	pkey_dh_ctrl_str
	254
	255	};