1 /*
2 * TLS v1.0/v1.1/v1.2 server (RFC 2246, RFC 4346, RFC 5246)
3 * Copyright (c) 2006-2019, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "common.h"
12 #include "crypto/sha1.h"
13 #include "crypto/tls.h"
14 #include "tlsv1_common.h"
15 #include "tlsv1_record.h"
16 #include "tlsv1_server.h"
17 #include "tlsv1_server_i.h"
18
19 /* TODO:
20 * Support for a message fragmented across several records (RFC 2246, 6.2.1)
21 */
22
23
tlsv1_server_log(struct tlsv1_server * conn,const char * fmt,...)24 void tlsv1_server_log(struct tlsv1_server *conn, const char *fmt, ...)
25 {
26 va_list ap;
27 char *buf;
28 int buflen;
29
30 va_start(ap, fmt);
31 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
32 va_end(ap);
33
34 buf = os_malloc(buflen);
35 if (buf == NULL)
36 return;
37 va_start(ap, fmt);
38 vsnprintf(buf, buflen, fmt, ap);
39 va_end(ap);
40
41 wpa_printf(MSG_DEBUG, "TLSv1: %s", buf);
42 if (conn->log_cb)
43 conn->log_cb(conn->log_cb_ctx, buf);
44
45 os_free(buf);
46 }
47
48
tlsv1_server_alert(struct tlsv1_server * conn,u8 level,u8 description)49 void tlsv1_server_alert(struct tlsv1_server *conn, u8 level, u8 description)
50 {
51 conn->alert_level = level;
52 conn->alert_description = description;
53 }
54
55
tlsv1_server_derive_keys(struct tlsv1_server * conn,const u8 * pre_master_secret,size_t pre_master_secret_len)56 int tlsv1_server_derive_keys(struct tlsv1_server *conn,
57 const u8 *pre_master_secret,
58 size_t pre_master_secret_len)
59 {
60 u8 seed[2 * TLS_RANDOM_LEN];
61 u8 key_block[TLS_MAX_KEY_BLOCK_LEN];
62 u8 *pos;
63 size_t key_block_len;
64
65 if (pre_master_secret) {
66 wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: pre_master_secret",
67 pre_master_secret, pre_master_secret_len);
68 os_memcpy(seed, conn->client_random, TLS_RANDOM_LEN);
69 os_memcpy(seed + TLS_RANDOM_LEN, conn->server_random,
70 TLS_RANDOM_LEN);
71 if (tls_prf(conn->rl.tls_version,
72 pre_master_secret, pre_master_secret_len,
73 "master secret", seed, 2 * TLS_RANDOM_LEN,
74 conn->master_secret, TLS_MASTER_SECRET_LEN)) {
75 wpa_printf(MSG_DEBUG, "TLSv1: Failed to derive "
76 "master_secret");
77 return -1;
78 }
79 wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: master_secret",
80 conn->master_secret, TLS_MASTER_SECRET_LEN);
81 }
82
83 os_memcpy(seed, conn->server_random, TLS_RANDOM_LEN);
84 os_memcpy(seed + TLS_RANDOM_LEN, conn->client_random, TLS_RANDOM_LEN);
85 key_block_len = 2 * (conn->rl.hash_size + conn->rl.key_material_len +
86 conn->rl.iv_size);
87 if (tls_prf(conn->rl.tls_version,
88 conn->master_secret, TLS_MASTER_SECRET_LEN,
89 "key expansion", seed, 2 * TLS_RANDOM_LEN,
90 key_block, key_block_len)) {
91 wpa_printf(MSG_DEBUG, "TLSv1: Failed to derive key_block");
92 return -1;
93 }
94 wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: key_block",
95 key_block, key_block_len);
96
97 pos = key_block;
98
99 /* client_write_MAC_secret */
100 os_memcpy(conn->rl.read_mac_secret, pos, conn->rl.hash_size);
101 pos += conn->rl.hash_size;
102 /* server_write_MAC_secret */
103 os_memcpy(conn->rl.write_mac_secret, pos, conn->rl.hash_size);
104 pos += conn->rl.hash_size;
105
106 /* client_write_key */
107 os_memcpy(conn->rl.read_key, pos, conn->rl.key_material_len);
108 pos += conn->rl.key_material_len;
109 /* server_write_key */
110 os_memcpy(conn->rl.write_key, pos, conn->rl.key_material_len);
111 pos += conn->rl.key_material_len;
112
113 /* client_write_IV */
114 os_memcpy(conn->rl.read_iv, pos, conn->rl.iv_size);
115 pos += conn->rl.iv_size;
116 /* server_write_IV */
117 os_memcpy(conn->rl.write_iv, pos, conn->rl.iv_size);
118 pos += conn->rl.iv_size;
119
120 return 0;
121 }
122
123
124 /**
125 * tlsv1_server_handshake - Process TLS handshake
126 * @conn: TLSv1 server connection data from tlsv1_server_init()
127 * @in_data: Input data from TLS peer
128 * @in_len: Input data length
129 * @out_len: Length of the output buffer.
130 * Returns: Pointer to output data, %NULL on failure
131 */
tlsv1_server_handshake(struct tlsv1_server * conn,const u8 * in_data,size_t in_len,size_t * out_len)132 u8 * tlsv1_server_handshake(struct tlsv1_server *conn,
133 const u8 *in_data, size_t in_len,
134 size_t *out_len)
135 {
136 const u8 *pos, *end;
137 u8 *msg = NULL, *in_msg, *in_pos, *in_end, alert, ct;
138 size_t in_msg_len;
139 int used;
140
141 if (in_data == NULL || in_len == 0) {
142 wpa_printf(MSG_DEBUG, "TLSv1: No input data to server");
143 return NULL;
144 }
145
146 pos = in_data;
147 end = in_data + in_len;
148 in_msg = os_malloc(in_len);
149 if (in_msg == NULL)
150 return NULL;
151
152 /* Each received packet may include multiple records */
153 while (pos < end) {
154 in_msg_len = in_len;
155 used = tlsv1_record_receive(&conn->rl, pos, end - pos,
156 in_msg, &in_msg_len, &alert);
157 if (used < 0) {
158 wpa_printf(MSG_DEBUG, "TLSv1: Processing received "
159 "record failed");
160 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);
161 goto failed;
162 }
163 if (used == 0) {
164 /* need more data */
165 wpa_printf(MSG_DEBUG, "TLSv1: Partial processing not "
166 "yet supported");
167 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
168 TLS_ALERT_INTERNAL_ERROR);
169 goto failed;
170 }
171 ct = pos[0];
172
173 in_pos = in_msg;
174 in_end = in_msg + in_msg_len;
175
176 /* Each received record may include multiple messages of the
177 * same ContentType. */
178 while (in_pos < in_end) {
179 in_msg_len = in_end - in_pos;
180 if (tlsv1_server_process_handshake(conn, ct, in_pos,
181 &in_msg_len) < 0)
182 goto failed;
183 in_pos += in_msg_len;
184 }
185
186 pos += used;
187 }
188
189 os_free(in_msg);
190 in_msg = NULL;
191
192 msg = tlsv1_server_handshake_write(conn, out_len);
193
194 failed:
195 os_free(in_msg);
196 if (conn->alert_level) {
197 if (conn->state == FAILED) {
198 /* Avoid alert loops */
199 wpa_printf(MSG_DEBUG, "TLSv1: Drop alert loop");
200 os_free(msg);
201 return NULL;
202 }
203 conn->state = FAILED;
204 os_free(msg);
205 msg = tlsv1_server_send_alert(conn, conn->alert_level,
206 conn->alert_description,
207 out_len);
208 conn->write_alerts++;
209 }
210
211 return msg;
212 }
213
214
215 /**
216 * tlsv1_server_encrypt - Encrypt data into TLS tunnel
217 * @conn: TLSv1 server connection data from tlsv1_server_init()
218 * @in_data: Pointer to plaintext data to be encrypted
219 * @in_len: Input buffer length
220 * @out_data: Pointer to output buffer (encrypted TLS data)
221 * @out_len: Maximum out_data length
222 * Returns: Number of bytes written to out_data, -1 on failure
223 *
224 * This function is used after TLS handshake has been completed successfully to
225 * send data in the encrypted tunnel.
226 */
tlsv1_server_encrypt(struct tlsv1_server * conn,const u8 * in_data,size_t in_len,u8 * out_data,size_t out_len)227 int tlsv1_server_encrypt(struct tlsv1_server *conn,
228 const u8 *in_data, size_t in_len,
229 u8 *out_data, size_t out_len)
230 {
231 size_t rlen;
232
233 wpa_hexdump_key(MSG_MSGDUMP, "TLSv1: Plaintext AppData",
234 in_data, in_len);
235
236 if (tlsv1_record_send(&conn->rl, TLS_CONTENT_TYPE_APPLICATION_DATA,
237 out_data, out_len, in_data, in_len, &rlen) < 0) {
238 wpa_printf(MSG_DEBUG, "TLSv1: Failed to create a record");
239 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
240 TLS_ALERT_INTERNAL_ERROR);
241 return -1;
242 }
243
244 return rlen;
245 }
246
247
248 /**
249 * tlsv1_server_decrypt - Decrypt data from TLS tunnel
250 * @conn: TLSv1 server connection data from tlsv1_server_init()
251 * @in_data: Pointer to input buffer (encrypted TLS data)
252 * @in_len: Input buffer length
253 * @out_data: Pointer to output buffer (decrypted data from TLS tunnel)
254 * @out_len: Maximum out_data length
255 * Returns: Number of bytes written to out_data, -1 on failure
256 *
257 * This function is used after TLS handshake has been completed successfully to
258 * receive data from the encrypted tunnel.
259 */
tlsv1_server_decrypt(struct tlsv1_server * conn,const u8 * in_data,size_t in_len,u8 * out_data,size_t out_len)260 int tlsv1_server_decrypt(struct tlsv1_server *conn,
261 const u8 *in_data, size_t in_len,
262 u8 *out_data, size_t out_len)
263 {
264 const u8 *in_end, *pos;
265 int used;
266 u8 alert, *out_end, *out_pos, ct;
267 size_t olen;
268
269 pos = in_data;
270 in_end = in_data + in_len;
271 out_pos = out_data;
272 out_end = out_data + out_len;
273
274 while (pos < in_end) {
275 ct = pos[0];
276 olen = out_end - out_pos;
277 used = tlsv1_record_receive(&conn->rl, pos, in_end - pos,
278 out_pos, &olen, &alert);
279 if (used < 0) {
280 tlsv1_server_log(conn, "Record layer processing failed");
281 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);
282 return -1;
283 }
284 if (used == 0) {
285 /* need more data */
286 wpa_printf(MSG_DEBUG, "TLSv1: Partial processing not "
287 "yet supported");
288 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL, alert);
289 return -1;
290 }
291
292 if (ct == TLS_CONTENT_TYPE_ALERT) {
293 if (olen < 2) {
294 tlsv1_server_log(conn, "Alert underflow");
295 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
296 TLS_ALERT_DECODE_ERROR);
297 return -1;
298 }
299 tlsv1_server_log(conn, "Received alert %d:%d",
300 out_pos[0], out_pos[1]);
301 conn->read_alerts++;
302 if (out_pos[0] == TLS_ALERT_LEVEL_WARNING) {
303 /* Continue processing */
304 pos += used;
305 continue;
306 }
307
308 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
309 out_pos[1]);
310 return -1;
311 }
312
313 if (ct != TLS_CONTENT_TYPE_APPLICATION_DATA) {
314 tlsv1_server_log(conn, "Unexpected content type 0x%x",
315 pos[0]);
316 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
317 TLS_ALERT_UNEXPECTED_MESSAGE);
318 return -1;
319 }
320
321 #ifdef CONFIG_TESTING_OPTIONS
322 if ((conn->test_flags &
323 (TLS_BREAK_VERIFY_DATA | TLS_BREAK_SRV_KEY_X_HASH |
324 TLS_BREAK_SRV_KEY_X_SIGNATURE)) &&
325 !conn->test_failure_reported) {
326 tlsv1_server_log(conn, "TEST-FAILURE: Client ApplData received after invalid handshake");
327 conn->test_failure_reported = 1;
328 }
329 #endif /* CONFIG_TESTING_OPTIONS */
330
331 out_pos += olen;
332 if (out_pos > out_end) {
333 wpa_printf(MSG_DEBUG, "TLSv1: Buffer not large enough "
334 "for processing the received record");
335 tlsv1_server_alert(conn, TLS_ALERT_LEVEL_FATAL,
336 TLS_ALERT_INTERNAL_ERROR);
337 return -1;
338 }
339
340 pos += used;
341 }
342
343 return out_pos - out_data;
344 }
345
346
347 /**
348 * tlsv1_server_global_init - Initialize TLSv1 server
349 * Returns: 0 on success, -1 on failure
350 *
351 * This function must be called before using any other TLSv1 server functions.
352 */
tlsv1_server_global_init(void)353 int tlsv1_server_global_init(void)
354 {
355 return crypto_global_init();
356 }
357
358
359 /**
360 * tlsv1_server_global_deinit - Deinitialize TLSv1 server
361 *
362 * This function can be used to deinitialize the TLSv1 server that was
363 * initialized by calling tlsv1_server_global_init(). No TLSv1 server functions
364 * can be called after this before calling tlsv1_server_global_init() again.
365 */
tlsv1_server_global_deinit(void)366 void tlsv1_server_global_deinit(void)
367 {
368 crypto_global_deinit();
369 }
370
371
372 /**
373 * tlsv1_server_init - Initialize TLSv1 server connection
374 * @cred: Pointer to server credentials from tlsv1_server_cred_alloc()
375 * Returns: Pointer to TLSv1 server connection data or %NULL on failure
376 */
tlsv1_server_init(struct tlsv1_credentials * cred)377 struct tlsv1_server * tlsv1_server_init(struct tlsv1_credentials *cred)
378 {
379 struct tlsv1_server *conn;
380 size_t count;
381 u16 *suites;
382
383 conn = os_zalloc(sizeof(*conn));
384 if (conn == NULL)
385 return NULL;
386
387 conn->cred = cred;
388
389 conn->state = CLIENT_HELLO;
390
391 if (tls_verify_hash_init(&conn->verify) < 0) {
392 wpa_printf(MSG_DEBUG, "TLSv1: Failed to initialize verify "
393 "hash");
394 os_free(conn);
395 return NULL;
396 }
397
398 count = 0;
399 suites = conn->cipher_suites;
400 suites[count++] = TLS_DHE_RSA_WITH_AES_256_CBC_SHA256;
401 suites[count++] = TLS_RSA_WITH_AES_256_CBC_SHA256;
402 suites[count++] = TLS_DHE_RSA_WITH_AES_256_CBC_SHA;
403 suites[count++] = TLS_RSA_WITH_AES_256_CBC_SHA;
404 suites[count++] = TLS_DHE_RSA_WITH_AES_128_CBC_SHA256;
405 suites[count++] = TLS_RSA_WITH_AES_128_CBC_SHA256;
406 suites[count++] = TLS_DHE_RSA_WITH_AES_128_CBC_SHA;
407 suites[count++] = TLS_RSA_WITH_AES_128_CBC_SHA;
408 suites[count++] = TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA;
409 suites[count++] = TLS_RSA_WITH_3DES_EDE_CBC_SHA;
410 suites[count++] = TLS_RSA_WITH_RC4_128_SHA;
411 suites[count++] = TLS_RSA_WITH_RC4_128_MD5;
412 conn->num_cipher_suites = count;
413
414 return conn;
415 }
416
417
tlsv1_server_clear_data(struct tlsv1_server * conn)418 static void tlsv1_server_clear_data(struct tlsv1_server *conn)
419 {
420 tlsv1_record_set_cipher_suite(&conn->rl, TLS_NULL_WITH_NULL_NULL);
421 tlsv1_record_change_write_cipher(&conn->rl);
422 tlsv1_record_change_read_cipher(&conn->rl);
423 tls_verify_hash_free(&conn->verify);
424
425 crypto_public_key_free(conn->client_rsa_key);
426 conn->client_rsa_key = NULL;
427
428 os_free(conn->session_ticket);
429 conn->session_ticket = NULL;
430 conn->session_ticket_len = 0;
431 conn->use_session_ticket = 0;
432
433 os_free(conn->dh_secret);
434 conn->dh_secret = NULL;
435 conn->dh_secret_len = 0;
436 }
437
438
439 /**
440 * tlsv1_server_deinit - Deinitialize TLSv1 server connection
441 * @conn: TLSv1 server connection data from tlsv1_server_init()
442 */
tlsv1_server_deinit(struct tlsv1_server * conn)443 void tlsv1_server_deinit(struct tlsv1_server *conn)
444 {
445 tlsv1_server_clear_data(conn);
446 os_free(conn);
447 }
448
449
450 /**
451 * tlsv1_server_established - Check whether connection has been established
452 * @conn: TLSv1 server connection data from tlsv1_server_init()
453 * Returns: 1 if connection is established, 0 if not
454 */
tlsv1_server_established(struct tlsv1_server * conn)455 int tlsv1_server_established(struct tlsv1_server *conn)
456 {
457 return conn->state == ESTABLISHED;
458 }
459
460
461 /**
462 * tlsv1_server_prf - Use TLS-PRF to derive keying material
463 * @conn: TLSv1 server connection data from tlsv1_server_init()
464 * @label: Label (e.g., description of the key) for PRF
465 * @context: Optional extra upper-layer context (max len 2^16)
466 * @context_len: The length of the context value
467 * @server_random_first: seed is 0 = client_random|server_random,
468 * 1 = server_random|client_random
469 * @out: Buffer for output data from TLS-PRF
470 * @out_len: Length of the output buffer
471 * Returns: 0 on success, -1 on failure
472 */
tlsv1_server_prf(struct tlsv1_server * conn,const char * label,const u8 * context,size_t context_len,int server_random_first,u8 * out,size_t out_len)473 int tlsv1_server_prf(struct tlsv1_server *conn, const char *label,
474 const u8 *context, size_t context_len,
475 int server_random_first, u8 *out, size_t out_len)
476 {
477 u8 *seed, *pos;
478 size_t seed_len = 2 * TLS_RANDOM_LEN;
479 int res;
480
481 if (conn->state != ESTABLISHED)
482 return -1;
483
484 if (context_len > 65535)
485 return -1;
486
487 if (context)
488 seed_len += 2 + context_len;
489
490 seed = os_malloc(seed_len);
491 if (!seed)
492 return -1;
493
494 if (server_random_first) {
495 os_memcpy(seed, conn->server_random, TLS_RANDOM_LEN);
496 os_memcpy(seed + TLS_RANDOM_LEN, conn->client_random,
497 TLS_RANDOM_LEN);
498 } else {
499 os_memcpy(seed, conn->client_random, TLS_RANDOM_LEN);
500 os_memcpy(seed + TLS_RANDOM_LEN, conn->server_random,
501 TLS_RANDOM_LEN);
502 }
503
504 if (context) {
505 pos = seed + 2 * TLS_RANDOM_LEN;
506 WPA_PUT_BE16(pos, context_len);
507 pos += 2;
508 os_memcpy(pos, context, context_len);
509 }
510
511 res = tls_prf(conn->rl.tls_version,
512 conn->master_secret, TLS_MASTER_SECRET_LEN,
513 label, seed, seed_len, out, out_len);
514 os_free(seed);
515 return res;
516 }
517
518
519 /**
520 * tlsv1_server_get_cipher - Get current cipher name
521 * @conn: TLSv1 server connection data from tlsv1_server_init()
522 * @buf: Buffer for the cipher name
523 * @buflen: buf size
524 * Returns: 0 on success, -1 on failure
525 *
526 * Get the name of the currently used cipher.
527 */
tlsv1_server_get_cipher(struct tlsv1_server * conn,char * buf,size_t buflen)528 int tlsv1_server_get_cipher(struct tlsv1_server *conn, char *buf,
529 size_t buflen)
530 {
531 char *cipher;
532
533 switch (conn->rl.cipher_suite) {
534 case TLS_RSA_WITH_RC4_128_MD5:
535 cipher = "RC4-MD5";
536 break;
537 case TLS_RSA_WITH_RC4_128_SHA:
538 cipher = "RC4-SHA";
539 break;
540 case TLS_RSA_WITH_DES_CBC_SHA:
541 cipher = "DES-CBC-SHA";
542 break;
543 case TLS_RSA_WITH_3DES_EDE_CBC_SHA:
544 cipher = "DES-CBC3-SHA";
545 break;
546 case TLS_DHE_RSA_WITH_DES_CBC_SHA:
547 cipher = "DHE-RSA-DES-CBC-SHA";
548 break;
549 case TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
550 cipher = "DHE-RSA-DES-CBC3-SHA";
551 break;
552 case TLS_DH_anon_WITH_RC4_128_MD5:
553 cipher = "ADH-RC4-MD5";
554 break;
555 case TLS_DH_anon_WITH_DES_CBC_SHA:
556 cipher = "ADH-DES-SHA";
557 break;
558 case TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
559 cipher = "ADH-DES-CBC3-SHA";
560 break;
561 case TLS_RSA_WITH_AES_128_CBC_SHA:
562 cipher = "AES-128-SHA";
563 break;
564 case TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
565 cipher = "DHE-RSA-AES-128-SHA";
566 break;
567 case TLS_DH_anon_WITH_AES_128_CBC_SHA:
568 cipher = "ADH-AES-128-SHA";
569 break;
570 case TLS_RSA_WITH_AES_256_CBC_SHA:
571 cipher = "AES-256-SHA";
572 break;
573 case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
574 cipher = "DHE-RSA-AES-256-SHA";
575 break;
576 case TLS_DH_anon_WITH_AES_256_CBC_SHA:
577 cipher = "ADH-AES-256-SHA";
578 break;
579 case TLS_RSA_WITH_AES_128_CBC_SHA256:
580 cipher = "AES-128-SHA256";
581 break;
582 case TLS_RSA_WITH_AES_256_CBC_SHA256:
583 cipher = "AES-256-SHA256";
584 break;
585 case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:
586 cipher = "DHE-RSA-AES-128-SHA256";
587 break;
588 case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:
589 cipher = "DHE-RSA-AES-256-SHA256";
590 break;
591 case TLS_DH_anon_WITH_AES_128_CBC_SHA256:
592 cipher = "ADH-AES-128-SHA256";
593 break;
594 case TLS_DH_anon_WITH_AES_256_CBC_SHA256:
595 cipher = "ADH-AES-256-SHA256";
596 break;
597 default:
598 return -1;
599 }
600
601 if (os_strlcpy(buf, cipher, buflen) >= buflen)
602 return -1;
603 return 0;
604 }
605
606
607 /**
608 * tlsv1_server_shutdown - Shutdown TLS connection
609 * @conn: TLSv1 server connection data from tlsv1_server_init()
610 * Returns: 0 on success, -1 on failure
611 */
tlsv1_server_shutdown(struct tlsv1_server * conn)612 int tlsv1_server_shutdown(struct tlsv1_server *conn)
613 {
614 conn->state = CLIENT_HELLO;
615
616 if (tls_verify_hash_init(&conn->verify) < 0) {
617 wpa_printf(MSG_DEBUG, "TLSv1: Failed to re-initialize verify "
618 "hash");
619 return -1;
620 }
621
622 tlsv1_server_clear_data(conn);
623
624 return 0;
625 }
626
627
628 /**
629 * tlsv1_server_resumed - Was session resumption used
630 * @conn: TLSv1 server connection data from tlsv1_server_init()
631 * Returns: 1 if current session used session resumption, 0 if not
632 */
tlsv1_server_resumed(struct tlsv1_server * conn)633 int tlsv1_server_resumed(struct tlsv1_server *conn)
634 {
635 return 0;
636 }
637
638
639 /**
640 * tlsv1_server_get_random - Get random data from TLS connection
641 * @conn: TLSv1 server connection data from tlsv1_server_init()
642 * @keys: Structure of random data (filled on success)
643 * Returns: 0 on success, -1 on failure
644 */
tlsv1_server_get_random(struct tlsv1_server * conn,struct tls_random * keys)645 int tlsv1_server_get_random(struct tlsv1_server *conn, struct tls_random *keys)
646 {
647 os_memset(keys, 0, sizeof(*keys));
648 if (conn->state == CLIENT_HELLO)
649 return -1;
650
651 keys->client_random = conn->client_random;
652 keys->client_random_len = TLS_RANDOM_LEN;
653
654 if (conn->state != SERVER_HELLO) {
655 keys->server_random = conn->server_random;
656 keys->server_random_len = TLS_RANDOM_LEN;
657 }
658
659 return 0;
660 }
661
662
663 /**
664 * tlsv1_server_get_keyblock_size - Get TLS key_block size
665 * @conn: TLSv1 server connection data from tlsv1_server_init()
666 * Returns: Size of the key_block for the negotiated cipher suite or -1 on
667 * failure
668 */
tlsv1_server_get_keyblock_size(struct tlsv1_server * conn)669 int tlsv1_server_get_keyblock_size(struct tlsv1_server *conn)
670 {
671 if (conn->state == CLIENT_HELLO || conn->state == SERVER_HELLO)
672 return -1;
673
674 return 2 * (conn->rl.hash_size + conn->rl.key_material_len +
675 conn->rl.iv_size);
676 }
677
678
679 /**
680 * tlsv1_server_set_cipher_list - Configure acceptable cipher suites
681 * @conn: TLSv1 server connection data from tlsv1_server_init()
682 * @ciphers: Zero (TLS_CIPHER_NONE) terminated list of allowed ciphers
683 * (TLS_CIPHER_*).
684 * Returns: 0 on success, -1 on failure
685 */
tlsv1_server_set_cipher_list(struct tlsv1_server * conn,u8 * ciphers)686 int tlsv1_server_set_cipher_list(struct tlsv1_server *conn, u8 *ciphers)
687 {
688 size_t count;
689 u16 *suites;
690
691 /* TODO: implement proper configuration of cipher suites */
692 if (ciphers[0] == TLS_CIPHER_ANON_DH_AES128_SHA) {
693 count = 0;
694 suites = conn->cipher_suites;
695 suites[count++] = TLS_RSA_WITH_AES_256_CBC_SHA;
696 suites[count++] = TLS_RSA_WITH_AES_128_CBC_SHA;
697 suites[count++] = TLS_RSA_WITH_3DES_EDE_CBC_SHA;
698 suites[count++] = TLS_RSA_WITH_RC4_128_SHA;
699 suites[count++] = TLS_RSA_WITH_RC4_128_MD5;
700 suites[count++] = TLS_DH_anon_WITH_AES_256_CBC_SHA;
701 suites[count++] = TLS_DH_anon_WITH_AES_128_CBC_SHA;
702 suites[count++] = TLS_DH_anon_WITH_3DES_EDE_CBC_SHA;
703 suites[count++] = TLS_DH_anon_WITH_RC4_128_MD5;
704 suites[count++] = TLS_DH_anon_WITH_DES_CBC_SHA;
705 conn->num_cipher_suites = count;
706 }
707
708 return 0;
709 }
710
711
tlsv1_server_set_verify(struct tlsv1_server * conn,int verify_peer)712 int tlsv1_server_set_verify(struct tlsv1_server *conn, int verify_peer)
713 {
714 conn->verify_peer = verify_peer;
715 return 0;
716 }
717
718
tlsv1_server_set_session_ticket_cb(struct tlsv1_server * conn,tlsv1_server_session_ticket_cb cb,void * ctx)719 void tlsv1_server_set_session_ticket_cb(struct tlsv1_server *conn,
720 tlsv1_server_session_ticket_cb cb,
721 void *ctx)
722 {
723 wpa_printf(MSG_DEBUG, "TLSv1: SessionTicket callback set %p (ctx %p)",
724 cb, ctx);
725 conn->session_ticket_cb = cb;
726 conn->session_ticket_cb_ctx = ctx;
727 }
728
729
tlsv1_server_set_log_cb(struct tlsv1_server * conn,void (* cb)(void * ctx,const char * msg),void * ctx)730 void tlsv1_server_set_log_cb(struct tlsv1_server *conn,
731 void (*cb)(void *ctx, const char *msg), void *ctx)
732 {
733 conn->log_cb = cb;
734 conn->log_cb_ctx = ctx;
735 }
736
737
tlsv1_server_get_failed(struct tlsv1_server * conn)738 int tlsv1_server_get_failed(struct tlsv1_server *conn)
739 {
740 return conn->state == FAILED;
741 }
742
743
tlsv1_server_get_read_alerts(struct tlsv1_server * conn)744 int tlsv1_server_get_read_alerts(struct tlsv1_server *conn)
745 {
746 return conn->read_alerts;
747 }
748
749
tlsv1_server_get_write_alerts(struct tlsv1_server * conn)750 int tlsv1_server_get_write_alerts(struct tlsv1_server *conn)
751 {
752 return conn->write_alerts;
753 }
754
755
756 #ifdef CONFIG_TESTING_OPTIONS
tlsv1_server_set_test_flags(struct tlsv1_server * conn,u32 flags)757 void tlsv1_server_set_test_flags(struct tlsv1_server *conn, u32 flags)
758 {
759 conn->test_flags = flags;
760 }
761
762
763 static const u8 test_tls_prime15[1] = {
764 15
765 };
766
767 static const u8 test_tls_prime511b[64] = {
768 0x50, 0xfb, 0xf1, 0xae, 0x01, 0xf1, 0xfe, 0xe6,
769 0xe1, 0xae, 0xdc, 0x1e, 0xbe, 0xfb, 0x9e, 0x58,
770 0x9a, 0xd7, 0x54, 0x9d, 0x6b, 0xb3, 0x78, 0xe2,
771 0x39, 0x7f, 0x30, 0x01, 0x25, 0xa1, 0xf9, 0x7c,
772 0x55, 0x0e, 0xa1, 0x15, 0xcc, 0x36, 0x34, 0xbb,
773 0x6c, 0x8b, 0x64, 0x45, 0x15, 0x7f, 0xd3, 0xe7,
774 0x31, 0xc8, 0x8e, 0x56, 0x8e, 0x95, 0xdc, 0xea,
775 0x9e, 0xdf, 0xf7, 0x56, 0xdd, 0xb0, 0x34, 0xdb
776 };
777
778 static const u8 test_tls_prime767b[96] = {
779 0x4c, 0xdc, 0xb8, 0x21, 0x20, 0x9d, 0xe8, 0xa3,
780 0x53, 0xd9, 0x1c, 0x18, 0xc1, 0x3a, 0x58, 0x67,
781 0xa7, 0x85, 0xf9, 0x28, 0x9b, 0xce, 0xc0, 0xd1,
782 0x05, 0x84, 0x61, 0x97, 0xb2, 0x86, 0x1c, 0xd0,
783 0xd1, 0x96, 0x23, 0x29, 0x8c, 0xc5, 0x30, 0x68,
784 0x3e, 0xf9, 0x05, 0xba, 0x60, 0xeb, 0xdb, 0xee,
785 0x2d, 0xdf, 0x84, 0x65, 0x49, 0x87, 0x90, 0x2a,
786 0xc9, 0x8e, 0x34, 0x63, 0x6d, 0x9a, 0x2d, 0x32,
787 0x1c, 0x46, 0xd5, 0x4e, 0x20, 0x20, 0x90, 0xac,
788 0xd5, 0x48, 0x79, 0x99, 0x0c, 0xe6, 0xed, 0xbf,
789 0x79, 0xc2, 0x47, 0x50, 0x95, 0x38, 0x38, 0xbc,
790 0xde, 0xb0, 0xd2, 0xe8, 0x97, 0xcb, 0x22, 0xbb
791 };
792
793 static const u8 test_tls_prime58[128] = {
794 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
795 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
796 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
797 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
798 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
799 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
800 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
801 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
802 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
803 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
804 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
805 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
806 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
807 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
808 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
809 0x03, 0xc1, 0xba, 0xc8, 0x25, 0xbe, 0x2d, 0xf3
810 };
811
812 static const u8 test_tls_non_prime[] = {
813 /*
814 * This is not a prime and the value has the following factors:
815 * 13736783488716579923 * 16254860191773456563 * 18229434976173670763 *
816 * 11112313018289079419 * 10260802278580253339 * 12394009491575311499 *
817 * 12419059668711064739 * 14317973192687985827 * 10498605410533203179 *
818 * 16338688760390249003 * 11128963991123878883 * 12990532258280301419 *
819 * 3
820 */
821 0x0C, 0x8C, 0x36, 0x9C, 0x6F, 0x71, 0x2E, 0xA7,
822 0xAB, 0x32, 0xD3, 0x0F, 0x68, 0x3D, 0xB2, 0x6D,
823 0x81, 0xDD, 0xC4, 0x84, 0x0D, 0x9C, 0x6E, 0x36,
824 0x29, 0x70, 0xF3, 0x1E, 0x9A, 0x42, 0x0B, 0x67,
825 0x82, 0x6B, 0xB1, 0xF2, 0xAF, 0x55, 0x28, 0xE7,
826 0xDB, 0x67, 0x6C, 0xF7, 0x6B, 0xAC, 0xAC, 0xE5,
827 0xF7, 0x9F, 0xD4, 0x63, 0x55, 0x70, 0x32, 0x7C,
828 0x70, 0xFB, 0xAF, 0xB8, 0xEB, 0x37, 0xCF, 0x3F,
829 0xFE, 0x94, 0x73, 0xF9, 0x7A, 0xC7, 0x12, 0x2E,
830 0x9B, 0xB4, 0x7D, 0x08, 0x60, 0x83, 0x43, 0x52,
831 0x83, 0x1E, 0xA5, 0xFC, 0xFA, 0x87, 0x12, 0xF4,
832 0x64, 0xE2, 0xCE, 0x71, 0x17, 0x72, 0xB6, 0xAB
833 };
834
835 #endif /* CONFIG_TESTING_OPTIONS */
836
837
tlsv1_server_get_dh_p(struct tlsv1_server * conn,const u8 ** dh_p,size_t * dh_p_len)838 void tlsv1_server_get_dh_p(struct tlsv1_server *conn, const u8 **dh_p,
839 size_t *dh_p_len)
840 {
841 *dh_p = conn->cred->dh_p;
842 *dh_p_len = conn->cred->dh_p_len;
843
844 #ifdef CONFIG_TESTING_OPTIONS
845 if (conn->test_flags & TLS_DHE_PRIME_511B) {
846 tlsv1_server_log(conn, "TESTING: Use short 511-bit prime with DHE");
847 *dh_p = test_tls_prime511b;
848 *dh_p_len = sizeof(test_tls_prime511b);
849 } else if (conn->test_flags & TLS_DHE_PRIME_767B) {
850 tlsv1_server_log(conn, "TESTING: Use short 767-bit prime with DHE");
851 *dh_p = test_tls_prime767b;
852 *dh_p_len = sizeof(test_tls_prime767b);
853 } else if (conn->test_flags & TLS_DHE_PRIME_15) {
854 tlsv1_server_log(conn, "TESTING: Use bogus 15 \"prime\" with DHE");
855 *dh_p = test_tls_prime15;
856 *dh_p_len = sizeof(test_tls_prime15);
857 } else if (conn->test_flags & TLS_DHE_PRIME_58B) {
858 tlsv1_server_log(conn, "TESTING: Use short 58-bit prime in long container with DHE");
859 *dh_p = test_tls_prime58;
860 *dh_p_len = sizeof(test_tls_prime58);
861 } else if (conn->test_flags & TLS_DHE_NON_PRIME) {
862 tlsv1_server_log(conn, "TESTING: Use claim non-prime as the DHE prime");
863 *dh_p = test_tls_non_prime;
864 *dh_p_len = sizeof(test_tls_non_prime);
865 }
866 #endif /* CONFIG_TESTING_OPTIONS */
867 }
868
