?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
license change, XYSSL upgrade
[syren.git] / src / xyssl / ssl_cli.c
blob875dde0c5d0d1465a2e900e938839c89e5f1e9ce
1 /*
2 * SSLv3/TLSv1 client-side functions
3 *
4 * Copyright (C) 2006-2007 Christophe Devine
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "xyssl/config.h"
22
23 #if defined(XYSSL_SSL_CLI_C)
24
25 #include "xyssl/debug.h"
26 #include "xyssl/ssl.h"
27
28 #include <string.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <time.h>
32
33 static int ssl_write_client_hello( ssl_context *ssl )
34 {
35 int ret, i, n;
36 unsigned char *buf;
37 unsigned char *p;
38 time_t t;
39
40 SSL_DEBUG_MSG( 2, ( "=> write client hello" ) );
41
42 ssl->major_ver = SSL_MAJOR_VERSION_3;
43 ssl->minor_ver = SSL_MINOR_VERSION_0;
44
45 ssl->max_major_ver = SSL_MAJOR_VERSION_3;
46 ssl->max_minor_ver = SSL_MINOR_VERSION_1;
47
48 /*
49 * 0 . 0 handshake type
50 * 1 . 3 handshake length
51 * 4 . 5 highest version supported
52 * 6 . 9 current UNIX time
53 * 10 . 37 random bytes
54 */
55 buf = ssl->out_msg;
56 p = buf + 4;
57
58 *p++ = (unsigned char) ssl->max_major_ver;
59 *p++ = (unsigned char) ssl->max_minor_ver;
60
61 SSL_DEBUG_MSG( 3, ( "client hello, max version: [%d:%d]",
62 buf[4], buf[5] ) );
63
64 t = time( NULL );
65 *p++ = (unsigned char)( t >> 24 );
66 *p++ = (unsigned char)( t >> 16 );
67 *p++ = (unsigned char)( t >> 8 );
68 *p++ = (unsigned char)( t );
69
70 SSL_DEBUG_MSG( 3, ( "client hello, current time: %lu", t ) );
71
72 for( i = 28; i > 0; i-- )
73 *p++ = (unsigned char) ssl->f_rng( ssl->p_rng );
74
75 memcpy( ssl->randbytes, buf + 6, 32 );
76
77 SSL_DEBUG_BUF( 3, "client hello, random bytes", buf + 6, 32 );
78
79 /*
80 * 38 . 38 session id length
81 * 39 . 39+n session id
82 * 40+n . 41+n cipherlist length
83 * 42+n . .. cipherlist
84 * .. . .. compression alg. (0)
85 * .. . .. extensions (unused)
86 */
87 n = ssl->session->length;
88
89 if( n < 16 || n > 32 || ssl->resume == 0 ||
90 t - ssl->session->start < ssl->timeout )
91 n = 0;
92
93 *p++ = (unsigned char) n;
94
95 for( i = 0; i < n; i++ )
96 *p++ = ssl->session->id[i];
97
98 SSL_DEBUG_MSG( 3, ( "client hello, session id len.: %d", n ) );
99 SSL_DEBUG_BUF( 3, "client hello, session id", buf + 39, n );
100
101 for( n = 0; ssl->ciphers[n] != 0; n++ );
102 *p++ = (unsigned char)( n >> 7 );
103 *p++ = (unsigned char)( n << 1 );
104
105 SSL_DEBUG_MSG( 3, ( "client hello, got %d ciphers", n ) );
106
107 for( i = 0; i < n; i++ )
108 {
109 SSL_DEBUG_MSG( 3, ( "client hello, add cipher: %2d",
110 ssl->ciphers[i] ) );
111
112 *p++ = (unsigned char)( ssl->ciphers[i] >> 8 );
113 *p++ = (unsigned char)( ssl->ciphers[i] );
114 }
115
116 SSL_DEBUG_MSG( 3, ( "client hello, compress len.: %d", 1 ) );
117 SSL_DEBUG_MSG( 3, ( "client hello, compress alg.: %d", 0 ) );
118
119 *p++ = 1;
120 *p++ = SSL_COMPRESS_NULL;
121
122 if ( ssl->hostname != NULL ) {
123 SSL_DEBUG_MSG( 3, ( "client hello, server name extension: %s", ssl->hostname ) );
124
125 // Extensions length
126 *p++ = (unsigned char)( ( ( ssl->hostname_len + 9 ) >> 8 ) & 0xff );
127 *p++ = (unsigned char)( ( ( ssl->hostname_len + 9 ) ) & 0xff );
128
129 // Extension type
130 *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME >> 8 ) & 0xff );
131 *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME ) & 0xff );
132 // Extension length
133 *p++ = (unsigned char)( ( ( ssl->hostname_len + 5 ) >> 8 ) & 0xff );
134 *p++ = (unsigned char)( ( ( ssl->hostname_len + 5 ) ) & 0xff );
135
136 // Server name list length
137 *p++ = (unsigned char)( ( ( ssl->hostname_len + 3 ) >> 8 ) & 0xff );
138 *p++ = (unsigned char)( ( ( ssl->hostname_len + 3 ) ) & 0xff );
139
140 // Name type
141 *p++ = (unsigned char)( ( TLS_EXT_SERVERNAME_HOSTNAME ) & 0xff );
142 // Hostname length
143 *p++ = (unsigned char)( ( ( ssl->hostname_len ) >> 8 ) & 0xff );
144 *p++ = (unsigned char)( ( ( ssl->hostname_len ) ) & 0xff );
145 // Hostname
146 memcpy( p, ssl->hostname, ssl->hostname_len );
147 p += ssl->hostname_len;
148
149 }
150
151 ssl->out_msglen = p - buf;
152 ssl->out_msgtype = SSL_MSG_HANDSHAKE;
153 ssl->out_msg[0] = SSL_HS_CLIENT_HELLO;
154
155 ssl->state++;
156
157 if( ( ret = ssl_write_record( ssl ) ) != 0 )
158 {
159 SSL_DEBUG_RET( 1, "ssl_write_record", ret );
160 return( ret );
161 }
162
163 SSL_DEBUG_MSG( 2, ( "<= write client hello" ) );
164
165 return( 0 );
166 }
167
168 static int ssl_parse_server_hello( ssl_context *ssl )
169 {
170 time_t t;
171 int ret, i, n;
172 int ext_len;
173 unsigned char *buf;
174
175 SSL_DEBUG_MSG( 2, ( "=> parse server hello" ) );
176
177 /*
178 * 0 . 0 handshake type
179 * 1 . 3 handshake length
180 * 4 . 5 protocol version
181 * 6 . 9 UNIX time()
182 * 10 . 37 random bytes
183 */
184 buf = ssl->in_msg;
185
186 if( ( ret = ssl_read_record( ssl ) ) != 0 )
187 {
188 SSL_DEBUG_RET( 1, "ssl_read_record", ret );
189 return( ret );
190 }
191
192 if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
193 {
194 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
195 return( XYSSL_ERR_SSL_UNEXPECTED_MESSAGE );
196 }
197
198 SSL_DEBUG_MSG( 3, ( "server hello, chosen version: [%d:%d]",
199 buf[4], buf[5] ) );
200
201 if( ssl->in_hslen < 42 ||
202 buf[0] != SSL_HS_SERVER_HELLO ||
203 buf[4] != SSL_MAJOR_VERSION_3 )
204 {
205 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
206 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
207 }
208
209 if( buf[5] != SSL_MINOR_VERSION_0 &&
210 buf[5] != SSL_MINOR_VERSION_1 )
211 {
212 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
213 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
214 }
215
216 ssl->minor_ver = buf[5];
217
218 t = ( (time_t) buf[6] << 24 )
219 | ( (time_t) buf[7] << 16 )
220 | ( (time_t) buf[8] << 8 )
221 | ( (time_t) buf[9] );
222
223 memcpy( ssl->randbytes + 32, buf + 6, 32 );
224
225 n = buf[38];
226
227 SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
228 SSL_DEBUG_BUF( 3, "server hello, random bytes", buf + 6, 32 );
229
230 /*
231 * 38 . 38 session id length
232 * 39 . 38+n session id
233 * 39+n . 40+n chosen cipher
234 * 41+n . 41+n chosen compression alg.
235 * 42+n . 43+n extensions length
236 * 44+n . 44+n+m extensions
237 */
238 if( n < 0 || n > 32 || ssl->in_hslen > 42 + n )
239 {
240 ext_len = ( ( buf[42 + n] << 8 )
241 | ( buf[43 + n] ) ) + 2;
242 }
243 else
244 {
245 ext_len = 0;
246 }
247
248 if( n < 0 || n > 32 || ssl->in_hslen != 42 + n + ext_len )
249 {
250 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
251 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
252 }
253
254 i = ( buf[39 + n] << 8 ) | buf[40 + n];
255
256 SSL_DEBUG_MSG( 3, ( "server hello, session id len.: %d", n ) );
257 SSL_DEBUG_BUF( 3, "server hello, session id", buf + 39, n );
258
259 /*
260 * Check if the session can be resumed
261 */
262 if( ssl->resume == 0 ||
263 ssl->session->cipher != i ||
264 ssl->session->length != n ||
265 memcmp( ssl->session->id, buf + 39, n ) != 0 )
266 {
267 ssl->state++;
268 ssl->resume = 0;
269 ssl->session->start = time( NULL );
270 ssl->session->cipher = i;
271 ssl->session->length = n;
272 memcpy( ssl->session->id, buf + 39, n );
273 }
274 else
275 {
276 ssl->state = SSL_SERVER_CHANGE_CIPHER_SPEC;
277 ssl_derive_keys( ssl );
278 }
279
280 SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
281 ssl->resume ? "a" : "no" ) );
282
283 SSL_DEBUG_MSG( 3, ( "server hello, chosen cipher: %d", i ) );
284 SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: %d", buf[41 + n] ) );
285
286 i = 0;
287 while( 1 )
288 {
289 if( ssl->ciphers[i] == 0 )
290 {
291 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
292 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
293 }
294
295 if( ssl->ciphers[i++] == ssl->session->cipher )
296 break;
297 }
298
299 if( buf[41 + n] != SSL_COMPRESS_NULL )
300 {
301 SSL_DEBUG_MSG( 1, ( "bad server hello message" ) );
302 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO );
303 }
304
305 // TODO: Process extensions
306
307 SSL_DEBUG_MSG( 2, ( "<= parse server hello" ) );
308
309 return( 0 );
310 }
311
312 static int ssl_parse_server_key_exchange( ssl_context *ssl )
313 {
314 int ret, n;
315 unsigned char *p, *end;
316 unsigned char hash[36];
317 md5_context md5;
318 sha1_context sha1;
319
320 SSL_DEBUG_MSG( 2, ( "=> parse server key exchange" ) );
321
322 if( ssl->session->cipher != SSL_EDH_RSA_DES_168_SHA &&
323 ssl->session->cipher != SSL_EDH_RSA_AES_256_SHA )
324 {
325 SSL_DEBUG_MSG( 2, ( "<= skip parse server key exchange" ) );
326 ssl->state++;
327 return( 0 );
328 }
329
330 #if !defined(XYSSL_DHM_C)
331 SSL_DEBUG_MSG( 1, ( "support for dhm in not available" ) );
332 return( XYSSL_ERR_SSL_FEATURE_UNAVAILABLE );
333 #else
334 if( ( ret = ssl_read_record( ssl ) ) != 0 )
335 {
336 SSL_DEBUG_RET( 1, "ssl_read_record", ret );
337 return( ret );
338 }
339
340 if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
341 {
342 SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
343 return( XYSSL_ERR_SSL_UNEXPECTED_MESSAGE );
344 }
345
346 if( ssl->in_msg[0] != SSL_HS_SERVER_KEY_EXCHANGE )
347 {
348 SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
349 return( XYSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
350 }
351
352 /*
353 * Ephemeral DH parameters:
354 *
355 * struct {
356 * opaque dh_p<1..2^16-1>;
357 * opaque dh_g<1..2^16-1>;
358 * opaque dh_Ys<1..2^16-1>;
359 * } ServerDHParams;
360 */
361 p = ssl->in_msg + 4;
362 end = ssl->in_msg + ssl->in_hslen;
363
364 if( ( ret = dhm_read_params( &ssl->dhm_ctx, &p, end ) ) != 0 )
365 {
366 SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
367 return( XYSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
368 }
369
370 if( (int)( end - p ) != ssl->peer_cert->rsa.len )
371 {
372 SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
373 return( XYSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
374 }
375
376 if( ssl->dhm_ctx.len < 64 || ssl->dhm_ctx.len > 256 )
377 {
378 SSL_DEBUG_MSG( 1, ( "bad server key exchange message" ) );
379 return( XYSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE );
380 }
381
382 SSL_DEBUG_MPI( 3, "DHM: P ", &ssl->dhm_ctx.P );
383 SSL_DEBUG_MPI( 3, "DHM: G ", &ssl->dhm_ctx.G );
384 SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->dhm_ctx.GY );
385
386 /*
387 * digitally-signed struct {
388 * opaque md5_hash[16];
389 * opaque sha_hash[20];
390 * };
391 *
392 * md5_hash
393 * MD5(ClientHello.random + ServerHello.random
394 * + ServerParams);
395 * sha_hash
396 * SHA(ClientHello.random + ServerHello.random
397 * + ServerParams);
398 */
399 n = ssl->in_hslen - ( end - p ) - 6;
400
401 md5_starts( &md5 );
402 md5_update( &md5, ssl->randbytes, 64 );
403 md5_update( &md5, ssl->in_msg + 4, n );
404 md5_finish( &md5, hash );
405
406 sha1_starts( &sha1 );
407 sha1_update( &sha1, ssl->randbytes, 64 );
408 sha1_update( &sha1, ssl->in_msg + 4, n );
409 sha1_finish( &sha1, hash + 16 );
410
411 SSL_DEBUG_BUF( 3, "parameters hash", hash, 36 );
412
413 if( ( ret = rsa_pkcs1_verify( &ssl->peer_cert->rsa, RSA_PUBLIC,
414 RSA_RAW, 36, hash, p ) ) != 0 )
415 {
416 SSL_DEBUG_RET( 1, "rsa_pkcs1_verify", ret );
417 return( ret );
418 }
419
420 ssl->state++;
421
422 SSL_DEBUG_MSG( 2, ( "<= parse server key exchange" ) );
423
424 return( 0 );
425 #endif
426 }
427
428 static int ssl_parse_certificate_request( ssl_context *ssl )
429 {
430 int ret;
431
432 SSL_DEBUG_MSG( 2, ( "=> parse certificate request" ) );
433
434 /*
435 * 0 . 0 handshake type
436 * 1 . 3 handshake length
437 * 4 . 5 SSL version
438 * 6 . 6 cert type count
439 * 7 .. n-1 cert types
440 * n .. n+1 length of all DNs
441 * n+2 .. n+3 length of DN 1
442 * n+4 .. ... Distinguished Name #1
443 * ... .. ... length of DN 2, etc.
444 */
445 if( ( ret = ssl_read_record( ssl ) ) != 0 )
446 {
447 SSL_DEBUG_RET( 1, "ssl_read_record", ret );
448 return( ret );
449 }
450
451 if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
452 {
453 SSL_DEBUG_MSG( 1, ( "bad certificate request message" ) );
454 return( XYSSL_ERR_SSL_UNEXPECTED_MESSAGE );
455 }
456
457 ssl->client_auth = 0;
458 ssl->state++;
459
460 if( ssl->in_msg[0] == SSL_HS_CERTIFICATE_REQUEST )
461 ssl->client_auth++;
462
463 SSL_DEBUG_MSG( 3, ( "got %s certificate request",
464 ssl->client_auth ? "a" : "no" ) );
465
466 SSL_DEBUG_MSG( 2, ( "<= parse certificate request" ) );
467
468 return( 0 );
469 }
470
471 static int ssl_parse_server_hello_done( ssl_context *ssl )
472 {
473 int ret;
474
475 SSL_DEBUG_MSG( 2, ( "=> parse server hello done" ) );
476
477 if( ssl->client_auth != 0 )
478 {
479 if( ( ret = ssl_read_record( ssl ) ) != 0 )
480 {
481 SSL_DEBUG_RET( 1, "ssl_read_record", ret );
482 return( ret );
483 }
484
485 if( ssl->in_msgtype != SSL_MSG_HANDSHAKE )
486 {
487 SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
488 return( XYSSL_ERR_SSL_UNEXPECTED_MESSAGE );
489 }
490 }
491
492 if( ssl->in_hslen != 4 ||
493 ssl->in_msg[0] != SSL_HS_SERVER_HELLO_DONE )
494 {
495 SSL_DEBUG_MSG( 1, ( "bad server hello done message" ) );
496 return( XYSSL_ERR_SSL_BAD_HS_SERVER_HELLO_DONE );
497 }
498
499 ssl->state++;
500
501 SSL_DEBUG_MSG( 2, ( "<= parse server hello done" ) );
502
503 return( 0 );
504 }
505
506 static int ssl_write_client_key_exchange( ssl_context *ssl )
507 {
508 int ret, i, n;
509
510 SSL_DEBUG_MSG( 2, ( "=> write client key exchange" ) );
511
512 if( ssl->session->cipher == SSL_EDH_RSA_DES_168_SHA ||
513 ssl->session->cipher == SSL_EDH_RSA_AES_256_SHA )
514 {
515 #if !defined(XYSSL_DHM_C)
516 SSL_DEBUG_MSG( 1, ( "support for dhm in not available" ) );
517 return( XYSSL_ERR_SSL_FEATURE_UNAVAILABLE );
518 #else
519 /*
520 * DHM key exchange -- send G^X mod P
521 */
522 n = ssl->dhm_ctx.len;
523
524 ssl->out_msg[4] = (unsigned char)( n >> 8 );
525 ssl->out_msg[5] = (unsigned char)( n );
526 i = 6;
527
528 ret = dhm_make_public( &ssl->dhm_ctx, 256,
529 &ssl->out_msg[i], n,
530 ssl->f_rng, ssl->p_rng );
531 if( ret != 0 )
532 {
533 SSL_DEBUG_RET( 1, "dhm_make_public", ret );
534 return( ret );
535 }
536
537 SSL_DEBUG_MPI( 3, "DHM: X ", &ssl->dhm_ctx.X );
538 SSL_DEBUG_MPI( 3, "DHM: GX", &ssl->dhm_ctx.GX );
539
540 ssl->pmslen = ssl->dhm_ctx.len;
541
542 if( ( ret = dhm_calc_secret( &ssl->dhm_ctx,
543 ssl->premaster,
544 &ssl->pmslen ) ) != 0 )
545 {
546 SSL_DEBUG_RET( 1, "dhm_calc_secret", ret );
547 return( ret );
548 }
549
550 SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->dhm_ctx.K );
551 #endif
552 }
553 else
554 {
555 /*
556 * RSA key exchange -- send rsa_public(pkcs1 v1.5(premaster))
557 */
558 ssl->premaster[0] = (unsigned char) ssl->max_major_ver;
559 ssl->premaster[1] = (unsigned char) ssl->max_minor_ver;
560 ssl->pmslen = 48;
561
562 for( i = 2; i < ssl->pmslen; i++ )
563 ssl->premaster[i] = (unsigned char) ssl->f_rng( ssl->p_rng );
564
565 i = 4;
566 n = ssl->peer_cert->rsa.len;
567
568 if( ssl->minor_ver != SSL_MINOR_VERSION_0 )
569 {
570 i += 2;
571 ssl->out_msg[4] = (unsigned char)( n >> 8 );
572 ssl->out_msg[5] = (unsigned char)( n );
573 }
574
575 ret = rsa_pkcs1_encrypt( &ssl->peer_cert->rsa, RSA_PUBLIC,
576 ssl->pmslen, ssl->premaster,
577 ssl->out_msg + i );
578 if( ret != 0 )
579 {
580 SSL_DEBUG_RET( 1, "rsa_pkcs1_encrypt", ret );
581 return( ret );
582 }
583 }
584
585 ssl_derive_keys( ssl );
586
587 ssl->out_msglen = i + n;
588 ssl->out_msgtype = SSL_MSG_HANDSHAKE;
589 ssl->out_msg[0] = SSL_HS_CLIENT_KEY_EXCHANGE;
590
591 ssl->state++;
592
593 if( ( ret = ssl_write_record( ssl ) ) != 0 )
594 {
595 SSL_DEBUG_RET( 1, "ssl_write_record", ret );
596 return( ret );
597 }
598
599 SSL_DEBUG_MSG( 2, ( "<= write client key exchange" ) );
600
601 return( 0 );
602 }
603
604 static int ssl_write_certificate_verify( ssl_context *ssl )
605 {
606 int ret, n;
607 unsigned char hash[36];
608
609 SSL_DEBUG_MSG( 2, ( "=> write certificate verify" ) );
610
611 if( ssl->client_auth == 0 )
612 {
613 SSL_DEBUG_MSG( 2, ( "<= skip write certificate verify" ) );
614 ssl->state++;
615 return( 0 );
616 }
617
618 if( ssl->rsa_key == NULL )
619 {
620 SSL_DEBUG_MSG( 1, ( "got no private key" ) );
621 return( XYSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
622 }
623
624 /*
625 * Make an RSA signature of the handshake digests
626 */
627 ssl_calc_verify( ssl, hash );
628
629 n = ssl->rsa_key->len;
630 ssl->out_msg[4] = (unsigned char)( n >> 8 );
631 ssl->out_msg[5] = (unsigned char)( n );
632
633 if( ( ret = rsa_pkcs1_sign( ssl->rsa_key, RSA_PRIVATE, RSA_RAW,
634 36, hash, ssl->out_msg + 6 ) ) != 0 )
635 {
636 SSL_DEBUG_RET( 1, "rsa_pkcs1_sign", ret );
637 return( ret );
638 }
639
640 ssl->out_msglen = 6 + n;
641 ssl->out_msgtype = SSL_MSG_HANDSHAKE;
642 ssl->out_msg[0] = SSL_HS_CERTIFICATE_VERIFY;
643
644 ssl->state++;
645
646 if( ( ret = ssl_write_record( ssl ) ) != 0 )
647 {
648 SSL_DEBUG_RET( 1, "ssl_write_record", ret );
649 return( ret );
650 }
651
652 SSL_DEBUG_MSG( 2, ( "<= write certificate verify" ) );
653
654 return( 0 );
655 }
656
657 /*
658 * SSL handshake -- client side
659 */
660 int ssl_handshake_client( ssl_context *ssl )
661 {
662 int ret = 0;
663
664 SSL_DEBUG_MSG( 2, ( "=> handshake client" ) );
665
666 while( ssl->state != SSL_HANDSHAKE_OVER )
667 {
668 SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
669
670 if( ( ret = ssl_flush_output( ssl ) ) != 0 )
671 break;
672
673 switch( ssl->state )
674 {
675 case SSL_HELLO_REQUEST:
676 ssl->state = SSL_CLIENT_HELLO;
677 break;
678
679 /*
680 * ==> ClientHello
681 */
682 case SSL_CLIENT_HELLO:
683 ret = ssl_write_client_hello( ssl );
684 break;
685
686 /*
687 * <== ServerHello
688 * Certificate
689 * ( ServerKeyExchange )
690 * ( CertificateRequest )
691 * ServerHelloDone
692 */
693 case SSL_SERVER_HELLO:
694 ret = ssl_parse_server_hello( ssl );
695 break;
696
697 case SSL_SERVER_CERTIFICATE:
698 ret = ssl_parse_certificate( ssl );
699 break;
700
701 case SSL_SERVER_KEY_EXCHANGE:
702 ret = ssl_parse_server_key_exchange( ssl );
703 break;
704
705 case SSL_CERTIFICATE_REQUEST:
706 ret = ssl_parse_certificate_request( ssl );
707 break;
708
709 case SSL_SERVER_HELLO_DONE:
710 ret = ssl_parse_server_hello_done( ssl );
711 break;
712
713 /*
714 * ==> ( Certificate/Alert )
715 * ClientKeyExchange
716 * ( CertificateVerify )
717 * ChangeCipherSpec
718 * Finished
719 */
720 case SSL_CLIENT_CERTIFICATE:
721 ret = ssl_write_certificate( ssl );
722 break;
723
724 case SSL_CLIENT_KEY_EXCHANGE:
725 ret = ssl_write_client_key_exchange( ssl );
726 break;
727
728 case SSL_CERTIFICATE_VERIFY:
729 ret = ssl_write_certificate_verify( ssl );
730 break;
731
732 case SSL_CLIENT_CHANGE_CIPHER_SPEC:
733 ret = ssl_write_change_cipher_spec( ssl );
734 break;
735
736 case SSL_CLIENT_FINISHED:
737 ret = ssl_write_finished( ssl );
738 break;
739
740 /*
741 * <== ChangeCipherSpec
742 * Finished
743 */
744 case SSL_SERVER_CHANGE_CIPHER_SPEC:
745 ret = ssl_parse_change_cipher_spec( ssl );
746 break;
747
748 case SSL_SERVER_FINISHED:
749 ret = ssl_parse_finished( ssl );
750 break;
751
752 case SSL_FLUSH_BUFFERS:
753 SSL_DEBUG_MSG( 2, ( "handshake: done" ) );
754 ssl->state = SSL_HANDSHAKE_OVER;
755 break;
756
757 default:
758 SSL_DEBUG_MSG( 1, ( "invalid state %d", ssl->state ) );
759 return( XYSSL_ERR_SSL_BAD_INPUT_DATA );
760 }
761
762 if( ret != 0 )
763 break;
764 }
765
766 SSL_DEBUG_MSG( 2, ( "<= handshake client" ) );
767
768 return( ret );
769 }
770
771 #endif
syren