2
* Diffie-Hellman-Merkle key exchange
4
* Copyright (C) 2006-2010, Brainspark B.V.
6
* This file is part of PolarSSL (http://www.polarssl.org)
7
* Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
11
* This program is free software; you can redistribute it and/or modify
12
* it under the terms of the GNU General Public License as published by
13
* the Free Software Foundation; either version 2 of the License, or
14
* (at your option) any later version.
16
* This program is distributed in the hope that it will be useful,
17
* but WITHOUT ANY WARRANTY; without even the implied warranty of
18
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
* GNU General Public License for more details.
21
* You should have received a copy of the GNU General Public License along
22
* with this program; if not, write to the Free Software Foundation, Inc.,
23
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
28
* http://www.cacr.math.uwaterloo.ca/hac/ (chapter 12)
31
#include "polarssl/config.h"
33
#if defined(POLARSSL_DHM_C)
35
#include "polarssl/dhm.h"
38
* helper to validate the mpi size and import it
40
static int dhm_read_bignum( mpi *X,
42
const unsigned char *end )
47
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
49
n = ( (*p)[0] << 8 ) | (*p)[1];
52
if( (int)( end - *p ) < n )
53
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
55
if( ( ret = mpi_read_binary( X, *p, n ) ) != 0 )
56
return( POLARSSL_ERR_DHM_READ_PARAMS_FAILED + ret );
64
* Verify sanity of parameter with regards to P
66
* Parameter should be: 2 <= public_param <= P - 2
68
* For more information on the attack, see:
69
* http://www.cl.cam.ac.uk/~rja14/Papers/psandqs.pdf
70
* http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2005-2643
72
static int dhm_check_range( const mpi *param, const mpi *P )
75
int ret = POLARSSL_ERR_DHM_BAD_INPUT_DATA;
77
mpi_init( &L ); mpi_init( &U );
79
mpi_sub_int( &U, P, 2 );
81
if( mpi_cmp_mpi( param, &L ) >= 0 &&
82
mpi_cmp_mpi( param, &U ) <= 0 )
87
mpi_free( &L ); mpi_free( &U );
93
* Parse the ServerKeyExchange parameters
95
int dhm_read_params( dhm_context *ctx,
97
const unsigned char *end )
101
memset( ctx, 0, sizeof( dhm_context ) );
103
if( ( ret = dhm_read_bignum( &ctx->P, p, end ) ) != 0 ||
104
( ret = dhm_read_bignum( &ctx->G, p, end ) ) != 0 ||
105
( ret = dhm_read_bignum( &ctx->GY, p, end ) ) != 0 )
108
if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
111
ctx->len = mpi_size( &ctx->P );
114
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
120
* Setup and write the ServerKeyExchange parameters
122
int dhm_make_params( dhm_context *ctx, int x_size,
123
unsigned char *output, size_t *olen,
124
int (*f_rng)(void *, unsigned char *, size_t),
131
if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
132
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
135
* Generate X as large as possible ( < P )
139
mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
141
while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
142
mpi_shift_r( &ctx->X, 1 );
145
return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED );
147
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
150
* Calculate GX = G^X mod P
152
MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
153
&ctx->P , &ctx->RP ) );
155
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
161
#define DHM_MPI_EXPORT(X,n) \
162
MPI_CHK( mpi_write_binary( X, p + 2, n ) ); \
163
*p++ = (unsigned char)( n >> 8 ); \
164
*p++ = (unsigned char)( n ); p += n;
166
n1 = mpi_size( &ctx->P );
167
n2 = mpi_size( &ctx->G );
168
n3 = mpi_size( &ctx->GX );
171
DHM_MPI_EXPORT( &ctx->P , n1 );
172
DHM_MPI_EXPORT( &ctx->G , n2 );
173
DHM_MPI_EXPORT( &ctx->GX, n3 );
182
return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED + ret );
188
* Import the peer's public value G^Y
190
int dhm_read_public( dhm_context *ctx,
191
const unsigned char *input, size_t ilen )
195
if( ctx == NULL || ilen < 1 || ilen > ctx->len )
196
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
198
if( ( ret = mpi_read_binary( &ctx->GY, input, ilen ) ) != 0 )
199
return( POLARSSL_ERR_DHM_READ_PUBLIC_FAILED + ret );
205
* Create own private value X and export G^X
207
int dhm_make_public( dhm_context *ctx, int x_size,
208
unsigned char *output, size_t olen,
209
int (*f_rng)(void *, unsigned char *, size_t),
214
if( ctx == NULL || olen < 1 || olen > ctx->len )
215
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
217
if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
218
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
221
* generate X and calculate GX = G^X mod P
225
mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
227
while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
228
mpi_shift_r( &ctx->X, 1 );
231
return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED );
233
while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
235
MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,
236
&ctx->P , &ctx->RP ) );
238
if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
241
MPI_CHK( mpi_write_binary( &ctx->GX, output, olen ) );
246
return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED + ret );
252
* Derive and export the shared secret (G^Y)^X mod P
254
int dhm_calc_secret( dhm_context *ctx,
255
unsigned char *output, size_t *olen )
259
if( ctx == NULL || *olen < ctx->len )
260
return( POLARSSL_ERR_DHM_BAD_INPUT_DATA );
262
MPI_CHK( mpi_exp_mod( &ctx->K, &ctx->GY, &ctx->X,
263
&ctx->P, &ctx->RP ) );
265
if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
268
*olen = mpi_size( &ctx->K );
270
MPI_CHK( mpi_write_binary( &ctx->K, output, *olen ) );
275
return( POLARSSL_ERR_DHM_CALC_SECRET_FAILED + ret );
281
* Free the components of a DHM key
283
void dhm_free( dhm_context *ctx )
285
mpi_free( &ctx->RP ); mpi_free( &ctx->K ); mpi_free( &ctx->GY );
286
mpi_free( &ctx->GX ); mpi_free( &ctx->X ); mpi_free( &ctx->G );
290
#if defined(POLARSSL_SELF_TEST)
295
int dhm_self_test( int verbose )