Bug Summary

File:/home/anal/dolphin-emu/Externals/polarssl/library/dhm.c
Location:line 297, column 13
Description:Value stored to 'verbose' is never read

Annotated Source Code

1/*
2 * Diffie-Hellman-Merkle key exchange
3 *
4 * Copyright (C) 2006-2010, Brainspark B.V.
5 *
6 * This file is part of PolarSSL (http://www.polarssl.org)
7 * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
8 *
9 * All rights reserved.
10 *
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.
15 *
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.
20 *
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.
24 */
25/*
26 * Reference:
27 *
28 * http://www.cacr.math.uwaterloo.ca/hac/ (chapter 12)
29 */
30
31#include "polarssl/config.h"
32
33#if defined(POLARSSL_DHM_C)
34
35#include "polarssl/dhm.h"
36
37/*
38 * helper to validate the mpi size and import it
39 */
40static int dhm_read_bignum( mpi *X,
41 unsigned char **p,
42 const unsigned char *end )
43{
44 int ret, n;
45
46 if( end - *p < 2 )
47 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
48
49 n = ( (*p)[0] << 8 ) | (*p)[1];
50 (*p) += 2;
51
52 if( (int)( end - *p ) < n )
53 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
54
55 if( ( ret = mpi_read_binary( X, *p, n ) ) != 0 )
56 return( POLARSSL_ERR_DHM_READ_PARAMS_FAILED-0x3100 + ret );
57
58 (*p) += n;
59
60 return( 0 );
61}
62
63/*
64 * Verify sanity of parameter with regards to P
65 *
66 * Parameter should be: 2 <= public_param <= P - 2
67 *
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
71 */
72static int dhm_check_range( const mpi *param, const mpi *P )
73{
74 mpi L, U;
75 int ret = POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080;
76
77 mpi_init( &L ); mpi_init( &U );
78 mpi_lset( &L, 2 );
79 mpi_sub_int( &U, P, 2 );
80
81 if( mpi_cmp_mpi( param, &L ) >= 0 &&
82 mpi_cmp_mpi( param, &U ) <= 0 )
83 {
84 ret = 0;
85 }
86
87 mpi_free( &L ); mpi_free( &U );
88
89 return( ret );
90}
91
92/*
93 * Parse the ServerKeyExchange parameters
94 */
95int dhm_read_params( dhm_context *ctx,
96 unsigned char **p,
97 const unsigned char *end )
98{
99 int ret;
100
101 memset( ctx, 0, sizeof( dhm_context ) );
102
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 )
106 return( ret );
107
108 if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
109 return( ret );
110
111 ctx->len = mpi_size( &ctx->P );
112
113 if( end - *p < 2 )
114 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
115
116 return( 0 );
117}
118
119/*
120 * Setup and write the ServerKeyExchange parameters
121 */
122int 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),
125 void *p_rng )
126{
127 int ret, count = 0;
128 size_t n1, n2, n3;
129 unsigned char *p;
130
131 if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
132 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
133
134 /*
135 * Generate X as large as possible ( < P )
136 */
137 do
138 {
139 mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
140
141 while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
142 mpi_shift_r( &ctx->X, 1 );
143
144 if( count++ > 10 )
145 return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED-0x3180 );
146 }
147 while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
148
149 /*
150 * Calculate GX = G^X mod P
151 */
152 MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,if( ( ret = mpi_exp_mod( &ctx->GX, &ctx->G, &
ctx->X, &ctx->P , &ctx->RP ) ) != 0 ) goto cleanup
153 &ctx->P , &ctx->RP ) )if( ( ret = mpi_exp_mod( &ctx->GX, &ctx->G, &
ctx->X, &ctx->P , &ctx->RP ) ) != 0 ) goto cleanup;
154
155 if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
156 return( ret );
157
158 /*
159 * export P, G, GX
160 */
161#define DHM_MPI_EXPORT(X,n)if( ( ret = mpi_write_binary( X, p + 2, n ) ) != 0 ) goto cleanup
; *p++ = (unsigned char)( n >> 8 ); *p++ = (unsigned char
)( n ); p += n; \
162 MPI_CHK( mpi_write_binary( X, p + 2, n ) )if( ( ret = mpi_write_binary( X, p + 2, n ) ) != 0 ) goto cleanup; \
163 *p++ = (unsigned char)( n >> 8 ); \
164 *p++ = (unsigned char)( n ); p += n;
165
166 n1 = mpi_size( &ctx->P );
167 n2 = mpi_size( &ctx->G );
168 n3 = mpi_size( &ctx->GX );
169
170 p = output;
171 DHM_MPI_EXPORT( &ctx->P , n1 )if( ( ret = mpi_write_binary( &ctx->P, p + 2, n1 ) ) !=
0 ) goto cleanup; *p++ = (unsigned char)( n1 >> 8 ); *
p++ = (unsigned char)( n1 ); p += n1;;
172 DHM_MPI_EXPORT( &ctx->G , n2 )if( ( ret = mpi_write_binary( &ctx->G, p + 2, n2 ) ) !=
0 ) goto cleanup; *p++ = (unsigned char)( n2 >> 8 ); *
p++ = (unsigned char)( n2 ); p += n2;;
173 DHM_MPI_EXPORT( &ctx->GX, n3 )if( ( ret = mpi_write_binary( &ctx->GX, p + 2, n3 ) ) !=
0 ) goto cleanup; *p++ = (unsigned char)( n3 >> 8 ); *
p++ = (unsigned char)( n3 ); p += n3;;
174
175 *olen = p - output;
176
177 ctx->len = n1;
178
179cleanup:
180
181 if( ret != 0 )
182 return( POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED-0x3180 + ret );
183
184 return( 0 );
185}
186
187/*
188 * Import the peer's public value G^Y
189 */
190int dhm_read_public( dhm_context *ctx,
191 const unsigned char *input, size_t ilen )
192{
193 int ret;
194
195 if( ctx == NULL((void*)0) || ilen < 1 || ilen > ctx->len )
196 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
197
198 if( ( ret = mpi_read_binary( &ctx->GY, input, ilen ) ) != 0 )
199 return( POLARSSL_ERR_DHM_READ_PUBLIC_FAILED-0x3200 + ret );
200
201 return( 0 );
202}
203
204/*
205 * Create own private value X and export G^X
206 */
207int 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),
210 void *p_rng )
211{
212 int ret, count = 0;
213
214 if( ctx == NULL((void*)0) || olen < 1 || olen > ctx->len )
215 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
216
217 if( mpi_cmp_int( &ctx->P, 0 ) == 0 )
218 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
219
220 /*
221 * generate X and calculate GX = G^X mod P
222 */
223 do
224 {
225 mpi_fill_random( &ctx->X, x_size, f_rng, p_rng );
226
227 while( mpi_cmp_mpi( &ctx->X, &ctx->P ) >= 0 )
228 mpi_shift_r( &ctx->X, 1 );
229
230 if( count++ > 10 )
231 return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED-0x3280 );
232 }
233 while( dhm_check_range( &ctx->X, &ctx->P ) != 0 );
234
235 MPI_CHK( mpi_exp_mod( &ctx->GX, &ctx->G, &ctx->X,if( ( ret = mpi_exp_mod( &ctx->GX, &ctx->G, &
ctx->X, &ctx->P , &ctx->RP ) ) != 0 ) goto cleanup
236 &ctx->P , &ctx->RP ) )if( ( ret = mpi_exp_mod( &ctx->GX, &ctx->G, &
ctx->X, &ctx->P , &ctx->RP ) ) != 0 ) goto cleanup;
237
238 if( ( ret = dhm_check_range( &ctx->GX, &ctx->P ) ) != 0 )
239 return( ret );
240
241 MPI_CHK( mpi_write_binary( &ctx->GX, output, olen ) )if( ( ret = mpi_write_binary( &ctx->GX, output, olen )
) != 0 ) goto cleanup;
242
243cleanup:
244
245 if( ret != 0 )
246 return( POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED-0x3280 + ret );
247
248 return( 0 );
249}
250
251/*
252 * Derive and export the shared secret (G^Y)^X mod P
253 */
254int dhm_calc_secret( dhm_context *ctx,
255 unsigned char *output, size_t *olen )
256{
257 int ret;
258
259 if( ctx == NULL((void*)0) || *olen < ctx->len )
260 return( POLARSSL_ERR_DHM_BAD_INPUT_DATA-0x3080 );
261
262 MPI_CHK( mpi_exp_mod( &ctx->K, &ctx->GY, &ctx->X,if( ( ret = mpi_exp_mod( &ctx->K, &ctx->GY, &
ctx->X, &ctx->P, &ctx->RP ) ) != 0 ) goto cleanup
263 &ctx->P, &ctx->RP ) )if( ( ret = mpi_exp_mod( &ctx->K, &ctx->GY, &
ctx->X, &ctx->P, &ctx->RP ) ) != 0 ) goto cleanup;
264
265 if( ( ret = dhm_check_range( &ctx->GY, &ctx->P ) ) != 0 )
266 return( ret );
267
268 *olen = mpi_size( &ctx->K );
269
270 MPI_CHK( mpi_write_binary( &ctx->K, output, *olen ) )if( ( ret = mpi_write_binary( &ctx->K, output, *olen )
) != 0 ) goto cleanup;
271
272cleanup:
273
274 if( ret != 0 )
275 return( POLARSSL_ERR_DHM_CALC_SECRET_FAILED-0x3300 + ret );
276
277 return( 0 );
278}
279
280/*
281 * Free the components of a DHM key
282 */
283void dhm_free( dhm_context *ctx )
284{
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 );
287 mpi_free( &ctx->P );
288}
289
290#if defined(POLARSSL_SELF_TEST)
291
292/*
293 * Checkup routine
294 */
295int dhm_self_test( int verbose )
296{
297 return( verbose++ );
Value stored to 'verbose' is never read
298}
299
300#endif
301
302#endif