Implement internally opaque bn access from dh
[openssl.git] / crypto / dh / dh_key.c
1 /* crypto/dh/dh_key.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59
60
61 #include <stdio.h>
62 #include "cryptlib.h"
63 #include <openssl/rand.h>
64 #include <openssl/dh.h>
65 #include "internal/bn_int.h"
66
67 static int generate_key(DH *dh);
68 static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh);
69 static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
70                         const BIGNUM *a, const BIGNUM *p,
71                         const BIGNUM *m, BN_CTX *ctx,
72                         BN_MONT_CTX *m_ctx);
73 static int dh_init(DH *dh);
74 static int dh_finish(DH *dh);
75
76 int DH_generate_key(DH *dh)
77         {
78         return dh->meth->generate_key(dh);
79         }
80
81 int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
82         {
83         return dh->meth->compute_key(key, pub_key, dh);
84         }
85
86 int DH_compute_key_padded(unsigned char *key, const BIGNUM *pub_key, DH *dh)
87         {
88         int rv, pad;
89         rv = dh->meth->compute_key(key, pub_key, dh);
90         if (rv <= 0)
91                 return rv;
92         pad = BN_num_bytes(dh->p) - rv;
93         if (pad > 0)
94                 {
95                 memmove(key + pad, key, rv);
96                 memset(key, 0, pad);
97                 }
98         return rv + pad;
99         }
100
101 static DH_METHOD dh_ossl = {
102 "OpenSSL DH Method",
103 generate_key,
104 compute_key,
105 dh_bn_mod_exp,
106 dh_init,
107 dh_finish,
108 DH_FLAG_FIPS_METHOD,
109 NULL,
110 NULL
111 };
112
113 const DH_METHOD *DH_OpenSSL(void)
114 {
115         return &dh_ossl;
116 }
117
118 static int generate_key(DH *dh)
119         {
120         int ok=0;
121         int generate_new_key=0;
122         unsigned l;
123         BN_CTX *ctx;
124         BN_MONT_CTX *mont=NULL;
125         BIGNUM *pub_key=NULL,*priv_key=NULL;
126
127         ctx = BN_CTX_new();
128         if (ctx == NULL) goto err;
129
130         if (dh->priv_key == NULL)
131                 {
132                 priv_key=BN_new();
133                 if (priv_key == NULL) goto err;
134                 generate_new_key=1;
135                 }
136         else
137                 priv_key=dh->priv_key;
138
139         if (dh->pub_key == NULL)
140                 {
141                 pub_key=BN_new();
142                 if (pub_key == NULL) goto err;
143                 }
144         else
145                 pub_key=dh->pub_key;
146
147
148         if (dh->flags & DH_FLAG_CACHE_MONT_P)
149                 {
150                 mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
151                                 CRYPTO_LOCK_DH, dh->p, ctx);
152                 if (!mont)
153                         goto err;
154                 }
155
156         if (generate_new_key)
157                 {
158                 if (dh->q)
159                         {
160                         do
161                                 {
162                                 if (!BN_rand_range(priv_key, dh->q))
163                                         goto err;
164                                 }
165                         while (BN_is_zero(priv_key) || BN_is_one(priv_key));
166                         }
167                 else
168                         {
169                         /* secret exponent length */
170                         l = dh->length ? dh->length : BN_num_bits(dh->p)-1;
171                         if (!BN_rand(priv_key, l, 0, 0)) goto err;
172                         }
173                 }
174
175         {
176                 BIGNUM *local_prk = NULL;
177                 BIGNUM *prk;
178
179                 if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
180                         {
181                         local_prk = prk = BN_new();
182                         BN_with_flags(prk, priv_key, BN_FLG_CONSTTIME);
183                         }
184                 else
185                         prk = priv_key;
186
187                 if (!dh->meth->bn_mod_exp(dh, pub_key, dh->g, prk, dh->p, ctx, mont))
188                         {
189                         if(local_prk) BN_free(local_prk);
190                         goto err;
191                         }
192                 if(local_prk) BN_free(local_prk);
193         }
194                 
195         dh->pub_key=pub_key;
196         dh->priv_key=priv_key;
197         ok=1;
198 err:
199         if (ok != 1)
200                 DHerr(DH_F_GENERATE_KEY,ERR_R_BN_LIB);
201
202         if ((pub_key != NULL)  && (dh->pub_key == NULL))  BN_free(pub_key);
203         if ((priv_key != NULL) && (dh->priv_key == NULL)) BN_free(priv_key);
204         BN_CTX_free(ctx);
205         return(ok);
206         }
207
208 static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
209         {
210         BN_CTX *ctx=NULL;
211         BN_MONT_CTX *mont=NULL;
212         BIGNUM *tmp;
213         int ret= -1;
214         int check_result;
215
216         if (BN_num_bits(dh->p) > OPENSSL_DH_MAX_MODULUS_BITS)
217                 {
218                 DHerr(DH_F_COMPUTE_KEY,DH_R_MODULUS_TOO_LARGE);
219                 goto err;
220                 }
221
222         ctx = BN_CTX_new();
223         if (ctx == NULL) goto err;
224         BN_CTX_start(ctx);
225         tmp = BN_CTX_get(ctx);
226         
227         if (dh->priv_key == NULL)
228                 {
229                 DHerr(DH_F_COMPUTE_KEY,DH_R_NO_PRIVATE_VALUE);
230                 goto err;
231                 }
232
233         if (dh->flags & DH_FLAG_CACHE_MONT_P)
234                 {
235                 mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
236                                 CRYPTO_LOCK_DH, dh->p, ctx);
237                 if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
238                         {
239                         /* XXX */
240                         BN_set_flags(dh->priv_key, BN_FLG_CONSTTIME);
241                         }
242                 if (!mont)
243                         goto err;
244                 }
245
246         if (!DH_check_pub_key(dh, pub_key, &check_result) || check_result)
247                 {
248                 DHerr(DH_F_COMPUTE_KEY,DH_R_INVALID_PUBKEY);
249                 goto err;
250                 }
251
252         if (!dh->meth->bn_mod_exp(dh, tmp, pub_key, dh->priv_key,dh->p,ctx,mont))
253                 {
254                 DHerr(DH_F_COMPUTE_KEY,ERR_R_BN_LIB);
255                 goto err;
256                 }
257
258         ret=BN_bn2bin(tmp,key);
259 err:
260         if (ctx != NULL)
261                 {
262                 BN_CTX_end(ctx);
263                 BN_CTX_free(ctx);
264                 }
265         return(ret);
266         }
267
268 static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
269                         const BIGNUM *a, const BIGNUM *p,
270                         const BIGNUM *m, BN_CTX *ctx,
271                         BN_MONT_CTX *m_ctx)
272         {
273         /* If a is only one word long and constant time is false, use the faster
274          * exponenentiation function.
275          */
276         if (bn_get_top(a) == 1 && ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) != 0))
277                 {
278                 BN_ULONG A = bn_get_words(a)[0];
279                 return BN_mod_exp_mont_word(r,A,p,m,ctx,m_ctx);
280                 }
281         else
282                 return BN_mod_exp_mont(r,a,p,m,ctx,m_ctx);
283         }
284
285
286 static int dh_init(DH *dh)
287         {
288         dh->flags |= DH_FLAG_CACHE_MONT_P;
289         return(1);
290         }
291
292 static int dh_finish(DH *dh)
293         {
294         if(dh->method_mont_p)
295                 BN_MONT_CTX_free(dh->method_mont_p);
296         return(1);
297         }