FIPS140 mode is detected on run-time.
[gnutls:gnutls.git] / lib / gnutls_int.h
1 /*
2  * Copyright (C) 2000-2012 Free Software Foundation, Inc.
3  *
4  * Author: Nikos Mavrogiannopoulos
5  *
6  * This file is part of GnuTLS.
7  *
8  * The GnuTLS is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
20  *
21  */
22
23 #ifndef GNUTLS_INT_H
24 #define GNUTLS_INT_H
25
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29
30 #include <stddef.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <ctype.h>
35 #include <limits.h>
36 #include <stdint.h>
37 #include <stdbool.h>
38
39 #ifdef NO_SSIZE_T
40 #define HAVE_SSIZE_T
41 typedef int ssize_t;
42 #endif
43
44 #include <sys/types.h>
45 #include <unistd.h>
46 #include <sys/stat.h>
47 #if HAVE_SYS_SOCKET_H
48 #include <sys/socket.h>
49 #elif HAVE_WS2TCPIP_H
50 #include <ws2tcpip.h>
51 #endif
52 #include <time.h>
53 #include <u64.h>                /* gnulib for uint64_t */
54
55 #ifdef HAVE_LIBNETTLE
56 #include <nettle/memxor.h>
57 #else
58 #include <gl/memxor.h>
59 #define memxor gl_memxor
60 #endif
61
62 #ifdef __GNUC__
63 #ifndef _GNUTLS_GCC_VERSION
64 #define _GNUTLS_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
65 #endif
66 #if _GNUTLS_GCC_VERSION >= 30100
67 #define likely(x)      __builtin_expect((x), 1)
68 #define unlikely(x)    __builtin_expect((x), 0)
69 #endif
70 #endif
71
72 #ifndef likely
73 #define likely
74 #define unlikely
75 #endif
76
77 /* some systems had problems with long long int, thus,
78  * it is not used.
79  */
80 typedef struct {
81         unsigned char i[8];
82 } uint64;
83
84 #include <gnutls/gnutls.h>
85 #include <gnutls/dtls.h>
86 #include <gnutls/abstract.h>
87 #include <system.h>
88
89 /*
90  * They are not needed any more. You can simply enable
91  * the gnutls_log callback to get error descriptions.
92
93 #define BUFFERS_DEBUG
94 #define WRITE_DEBUG
95 #define READ_DEBUG
96 #define HANDSHAKE_DEBUG // Prints some information on handshake 
97 #define COMPRESSION_DEBUG
98 #define DEBUG
99 */
100
101 /* The size of a handshake message should not
102  * be larger than this value.
103  */
104 #define MAX_HANDSHAKE_PACKET_SIZE 48*1024
105
106 #define TLS_MAX_SESSION_ID_SIZE 32
107
108 /* The maximum digest size of hash algorithms. 
109  */
110 #define MAX_FILENAME 512
111 #define MAX_HASH_SIZE 64
112 #define MAX_CIPHER_BLOCK_SIZE 16
113 #define MAX_CIPHER_KEY_SIZE 32
114
115 #define MAX_USERNAME_SIZE 128
116 #define MAX_SERVER_NAME_SIZE 128
117
118 #define SESSION_TICKET_KEY_NAME_SIZE 16
119 #define SESSION_TICKET_KEY_SIZE 16
120
121 #define AEAD_EXPLICIT_DATA_SIZE 8
122 #define AEAD_IMPLICIT_DATA_SIZE 4
123
124 #define GNUTLS_MASTER_SIZE 48
125 #define GNUTLS_RANDOM_SIZE 32
126
127 /* DTLS */
128 #define DTLS_RECORD_WINDOW_SIZE 64
129
130 /* TLS Extensions */
131 /* we can receive up to MAX_EXT_TYPES extensions.
132  */
133 #define MAX_EXT_TYPES 32
134
135   /**
136    * gnutls_ext_parse_type_t:
137    * @GNUTLS_EXT_NONE: Never parsed
138    * @GNUTLS_EXT_ANY: Any extension type.
139    * @GNUTLS_EXT_APPLICATION: Application extension.
140    * @GNUTLS_EXT_TLS: TLS-internal extension.
141    * @GNUTLS_EXT_MANDATORY: Extension parsed even if resuming (or extensions are disabled).
142    *
143    * Enumeration of different TLS extension types.  This flag
144    * indicates for an extension whether it is useful to application
145    * level or TLS level only.  This is (only) used to parse the
146    * application level extensions before the "client_hello" callback
147    * is called.
148    */
149 typedef enum {
150         GNUTLS_EXT_ANY = 0,
151         GNUTLS_EXT_APPLICATION = 1,
152         GNUTLS_EXT_TLS = 2,
153         GNUTLS_EXT_MANDATORY = 3,
154         GNUTLS_EXT_NONE = 4
155 } gnutls_ext_parse_type_t;
156
157
158 /* expire time for resuming sessions */
159 #define DEFAULT_EXPIRE_TIME 3600
160
161 typedef enum transport_t {
162         GNUTLS_STREAM,
163         GNUTLS_DGRAM
164 } transport_t;
165
166 typedef enum record_flush_t {
167         RECORD_FLUSH = 0,
168         RECORD_CORKED,
169 } record_flush_t;
170
171 /* the maximum size of encrypted packets */
172 #define IS_DTLS(session) (session->internals.transport == GNUTLS_DGRAM)
173
174 #define DEFAULT_MAX_RECORD_SIZE 16384
175 #define TLS_RECORD_HEADER_SIZE 5
176 #define DTLS_RECORD_HEADER_SIZE (TLS_RECORD_HEADER_SIZE+8)
177 #define RECORD_HEADER_SIZE(session) (IS_DTLS(session) ? DTLS_RECORD_HEADER_SIZE : TLS_RECORD_HEADER_SIZE)
178 #define MAX_RECORD_HEADER_SIZE DTLS_RECORD_HEADER_SIZE
179
180 /* The following macro is used to calculate the overhead when sending.
181  * when receiving we use a different way as there are implementations that
182  * store more data than allowed.
183  */
184 #define MAX_RECORD_SEND_OVERHEAD(session) (MAX_CIPHER_BLOCK_SIZE/*iv*/+MAX_PAD_SIZE+(gnutls_compression_get(session)!=GNUTLS_COMP_NULL)?EXTRA_COMP_SIZE:0+MAX_HASH_SIZE/*MAC*/)
185 #define MAX_RECORD_SEND_SIZE(session) (IS_DTLS(session)?((size_t)gnutls_dtls_get_mtu(session)):(size_t)session->security_parameters.max_record_send_size+MAX_RECORD_SEND_OVERHEAD(session))
186 #define MAX_PAD_SIZE 255
187 #define EXTRA_COMP_SIZE 2048
188
189 #define TLS_HANDSHAKE_HEADER_SIZE 4
190 #define DTLS_HANDSHAKE_HEADER_SIZE (TLS_HANDSHAKE_HEADER_SIZE+8)
191 #define HANDSHAKE_HEADER_SIZE(session) (IS_DTLS(session) ? DTLS_HANDSHAKE_HEADER_SIZE : TLS_HANDSHAKE_HEADER_SIZE)
192 #define MAX_HANDSHAKE_HEADER_SIZE DTLS_HANDSHAKE_HEADER_SIZE
193
194 /* This is the maximum handshake message size we send without
195    fragmentation. This currently ignores record layer overhead. */
196 #define DTLS_DEFAULT_MTU 1200
197
198 /* the maximum size of the DTLS cookie */
199 #define DTLS_MAX_COOKIE_SIZE 32
200
201 /* The maximum number of HELLO_VERIFY_REQUEST messages the client
202    processes before aborting. */
203 #define MAX_HANDSHAKE_HELLO_VERIFY_REQUESTS 5
204
205 /* defaults for verification functions
206  */
207 #define DEFAULT_MAX_VERIFY_DEPTH 16
208 #define DEFAULT_MAX_VERIFY_BITS 16*1024
209 #define MAX_VERIFY_DEPTH 4096
210
211 #include <gnutls_mem.h>
212
213 #define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
214
215 #define DECR_LEN(len, x) do { len-=x; if (len<0) {gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
216 #define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {gnutls_assert(); return RET;} } while (0)
217 #define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {gnutls_assert(); COM;} } while (0)
218
219 #define GNUTLS_POINTER_TO_INT(_) ((int) GNUTLS_POINTER_TO_INT_CAST (_))
220 #define GNUTLS_INT_TO_POINTER(_) ((void*) GNUTLS_POINTER_TO_INT_CAST (_))
221
222 typedef struct {
223         uint8_t pint[3];
224 } uint24;
225
226 #include <gnutls_mpi.h>
227
228 typedef enum handshake_state_t { STATE0 = 0, STATE1, STATE2,
229         STATE3, STATE4, STATE5, STATE6, STATE7, STATE8,
230         STATE9, STATE10, STATE11, STATE12, STATE13, STATE14,
231         STATE15, STATE16, STATE17,
232         STATE20 = 20, STATE21, STATE22,
233         STATE30 = 30, STATE31, STATE40 = 40, STATE41, STATE50 = 50,
234         STATE60 = 60, STATE61, STATE62, STATE70, STATE71
235 } handshake_state_t;
236
237 typedef enum heartbeat_state_t {
238         SHB_SEND1 = 0,
239         SHB_SEND2,
240         SHB_RECV,
241 } heartbeat_state_t;
242
243 typedef enum recv_state_t {
244         RECV_STATE_0 = 0,
245         RECV_STATE_DTLS_RETRANSMIT,
246 } recv_state_t;
247
248 #include <gnutls_str.h>
249
250 /* This is the maximum number of algorithms (ciphers or macs etc).
251  * keep it synced with GNUTLS_MAX_ALGORITHM_NUM in gnutls.h
252  */
253 #define MAX_ALGOS GNUTLS_MAX_ALGORITHM_NUM
254
255 typedef enum extensions_t {
256         GNUTLS_EXTENSION_SERVER_NAME = 0,
257         GNUTLS_EXTENSION_MAX_RECORD_SIZE = 1,
258         GNUTLS_EXTENSION_STATUS_REQUEST = 5,
259         GNUTLS_EXTENSION_CERT_TYPE = 9,
260         GNUTLS_EXTENSION_SUPPORTED_ECC = 10,
261         GNUTLS_EXTENSION_SUPPORTED_ECC_PF = 11,
262         GNUTLS_EXTENSION_SRP = 12,
263         GNUTLS_EXTENSION_SIGNATURE_ALGORITHMS = 13,
264         GNUTLS_EXTENSION_SRTP = 14,
265         GNUTLS_EXTENSION_HEARTBEAT = 15,
266         GNUTLS_EXTENSION_ALPN = 16,
267         GNUTLS_EXTENSION_SESSION_TICKET = 35,
268         GNUTLS_EXTENSION_NEW_RECORD_PADDING = 48015,    /* aka: 0xbeaf */
269         GNUTLS_EXTENSION_DUMBFW = 48016,
270         GNUTLS_EXTENSION_SAFE_RENEGOTIATION = 65281     /* aka: 0xff01 */
271 } extensions_t;
272
273 typedef enum { CIPHER_STREAM, CIPHER_BLOCK } cipher_type_t;
274
275 #define RESUME_TRUE 1
276 #define RESUME_FALSE 0
277
278 /* Record Protocol */
279 typedef enum content_type_t {
280         GNUTLS_CHANGE_CIPHER_SPEC = 20, GNUTLS_ALERT,
281         GNUTLS_HANDSHAKE, GNUTLS_APPLICATION_DATA,
282         GNUTLS_HEARTBEAT
283 } content_type_t;
284
285
286 #define GNUTLS_PK_ANY (gnutls_pk_algorithm_t)-1
287 #define GNUTLS_PK_NONE (gnutls_pk_algorithm_t)-2
288
289 /* Message buffers (mbuffers) structures */
290
291 /* this is actually the maximum number of distinct handshake
292  * messages that can arrive in a single flight
293  */
294 #define MAX_HANDSHAKE_MSGS 6
295 typedef struct {
296         /* Handshake layer type and sequence of message */
297         gnutls_handshake_description_t htype;
298         uint32_t length;
299
300         /* valid in DTLS */
301         uint16_t sequence;
302
303         /* indicate whether that message is complete.
304          * complete means start_offset == 0 and end_offset == length
305          */
306         uint32_t start_offset;
307         uint32_t end_offset;
308
309         uint8_t header[MAX_HANDSHAKE_HEADER_SIZE];
310         int header_size;
311
312         gnutls_buffer_st data;
313 } handshake_buffer_st;
314
315 typedef struct mbuffer_st {
316         /* when used in mbuffer_head_st */
317         struct mbuffer_st *next;
318         struct mbuffer_st *prev;
319
320         /* msg->size - mark = number of bytes left to process in this
321            message. Mark should only be non-zero when this buffer is the
322            head of the queue. */
323         size_t mark;
324
325
326         /* the data */
327         gnutls_datum_t msg;
328         size_t maximum_size;
329
330         /* used during fill in, to separate header from data
331          * body. */
332         unsigned int uhead_mark;
333
334         /* Filled in by record layer on recv:
335          * type, record_sequence
336          */
337
338         /* record layer content type */
339         content_type_t type;
340
341         /* record layer sequence */
342         uint64 record_sequence;
343
344         /* Filled in by handshake layer on send:
345          * type, epoch, htype, handshake_sequence
346          */
347
348         /* Record layer epoch of message */
349         uint16_t epoch;
350
351         /* Handshake layer type and sequence of message */
352         gnutls_handshake_description_t htype;
353         uint16_t handshake_sequence;
354 } mbuffer_st;
355
356 typedef struct mbuffer_head_st {
357         mbuffer_st *head;
358         mbuffer_st *tail;
359
360         unsigned int length;
361         size_t byte_length;
362 } mbuffer_head_st;
363
364 /* Store & Retrieve functions defines: 
365  */
366
367 typedef struct auth_cred_st {
368         gnutls_credentials_type_t algorithm;
369
370         /* the type of credentials depends on algorithm 
371          */
372         void *credentials;
373         struct auth_cred_st *next;
374 } auth_cred_st;
375
376 struct gnutls_key_st {
377         /* For ECDH KX */
378         gnutls_pk_params_st ecdh_params;
379         bigint_t ecdh_x;
380         bigint_t ecdh_y;
381
382         /* For DH KX */
383         gnutls_datum_t key;
384         
385         /* For DH KX */
386         gnutls_pk_params_st dh_params;
387         bigint_t client_Y;
388         /* for SRP */
389
390         bigint_t srp_key;
391         bigint_t srp_g;
392         bigint_t srp_p;
393         bigint_t A;
394         bigint_t B;
395         bigint_t u;
396         bigint_t b;
397         bigint_t a;
398         bigint_t x;
399         /* RSA: e, m
400          */
401         bigint_t rsa[2];
402
403         /* this is used to hold the peers authentication data 
404          */
405         /* auth_info_t structures SHOULD NOT contain malloced 
406          * elements. Check gnutls_session_pack.c, and gnutls_auth.c.
407          * Remember that this should be calloced!
408          */
409         void *auth_info;
410         gnutls_credentials_type_t auth_info_type;
411         int auth_info_size;     /* needed in order to store to db for restoring 
412                                  */
413         uint8_t crypt_algo;
414
415         auth_cred_st *cred;     /* used to specify keys/certificates etc */
416
417         int crt_requested;
418         /* some ciphersuites use this
419          * to provide client authentication.
420          * 1 if client auth was requested
421          * by the peer, 0 otherwise
422          *** In case of a server this
423          * holds 1 if we should wait
424          * for a client certificate verify
425          */
426 };
427 typedef struct gnutls_key_st gnutls_key_st;
428
429 struct pin_info_st {
430         gnutls_pin_callback_t cb;
431         void *data;
432 };
433
434 struct record_state_st;
435 typedef struct record_state_st record_state_st;
436
437 struct record_parameters_st;
438 typedef struct record_parameters_st record_parameters_st;
439
440 /* cipher and mac parameters */
441 typedef struct cipher_entry_st {
442         const char *name;
443         gnutls_cipher_algorithm_t id;
444         uint16_t blocksize;
445         uint16_t keysize;
446         bool block;
447         uint16_t iv;            /* the size of implicit IV - TLS related */
448         uint16_t cipher_iv;     /* the size of IV needed by the cipher */
449         bool aead;      /* Whether it is authenc cipher */
450 } cipher_entry_st;
451
452 typedef struct mac_entry_st {
453         const char *name;
454         const char *oid;        /* OID of the hash - if it is a hash */
455         gnutls_mac_algorithm_t id;
456         unsigned output_size;
457         unsigned key_size;
458         unsigned nonce_size;
459         unsigned placeholder;   /* if set, then not a real MAC */
460         unsigned secure;        /* if set the this algorithm is secure as hash */
461         unsigned block_size;    /* internal block size for HMAC */
462 } mac_entry_st;
463
464 typedef struct {
465         const char *name;
466         gnutls_protocol_t id;   /* gnutls internal version number */
467         uint8_t major;          /* defined by the protocol */
468         uint8_t minor;          /* defined by the protocol */
469         transport_t transport;  /* Type of transport, stream or datagram */
470         bool supported; /* 0 not supported, > 0 is supported */
471         bool explicit_iv;
472         bool extensions;        /* whether it supports extensions */
473         bool selectable_sighash;        /* whether signatures can be selected */
474         bool selectable_prf;    /* whether the PRF is ciphersuite-defined */
475 } version_entry_st;
476
477
478 /* STATE (cont) */
479
480 #include <gnutls_hash_int.h>
481 #include <gnutls_cipher_int.h>
482 #include <gnutls_compress.h>
483
484 typedef struct {
485         uint8_t hash_algorithm;
486         uint8_t sign_algorithm; /* pk algorithm actually */
487 } sign_algorithm_st;
488
489 /* This structure holds parameters got from TLS extension
490  * mechanism. (some extensions may hold parameters in auth_info_t
491  * structures also - see SRP).
492  */
493
494 #define MAX_SIGNATURE_ALGORITHMS 16
495 #define MAX_SIGN_ALGO_SIZE (2 + MAX_SIGNATURE_ALGORITHMS * 2)
496
497 #define MAX_VERIFY_DATA_SIZE 36 /* in SSL 3.0, 12 in TLS 1.0 */
498
499 /* auth_info_t structures now MAY contain malloced 
500  * elements.
501  */
502
503 /* This structure and auth_info_t, are stored in the resume database,
504  * and are restored, in case of resume.
505  * Holds all the required parameters to resume the current 
506  * session.
507  */
508
509 /* if you add anything in Security_Parameters struct, then
510  * also modify CPY_COMMON in gnutls_constate.c. 
511  */
512
513 /* Note that the security parameters structure is set up after the
514  * handshake has finished. The only value you may depend on while
515  * the handshake is in progress is the cipher suite value.
516  */
517 typedef struct {
518         unsigned int entity;    /* GNUTLS_SERVER or GNUTLS_CLIENT */
519         gnutls_kx_algorithm_t kx_algorithm;
520
521         /* The epoch used to read and write */
522         uint16_t epoch_read;
523         uint16_t epoch_write;
524
525         /* The epoch that the next handshake will initialize. */
526         uint16_t epoch_next;
527
528         /* The epoch at index 0 of record_parameters. */
529         uint16_t epoch_min;
530
531         /* this is the ciphersuite we are going to use 
532          * moved here from internals in order to be restored
533          * on resume;
534          */
535         uint8_t cipher_suite[2];
536         gnutls_compression_method_t compression_method;
537         uint8_t master_secret[GNUTLS_MASTER_SIZE];
538         uint8_t client_random[GNUTLS_RANDOM_SIZE];
539         uint8_t server_random[GNUTLS_RANDOM_SIZE];
540         uint8_t session_id[TLS_MAX_SESSION_ID_SIZE];
541         uint8_t session_id_size;
542         time_t timestamp;
543
544         /* if non-zero the new record padding is used */
545         uint8_t new_record_padding;
546
547         /* The send size is the one requested by the programmer.
548          * The recv size is the one negotiated with the peer.
549          */
550         uint16_t max_record_send_size;
551         uint16_t max_record_recv_size;
552         /* holds the negotiated certificate type */
553         gnutls_certificate_type_t cert_type;
554         gnutls_ecc_curve_t ecc_curve;   /* holds the first supported ECC curve requested by client */
555
556         /* Holds the signature algorithm used in this session - If any */
557         gnutls_sign_algorithm_t server_sign_algo;
558         gnutls_sign_algorithm_t client_sign_algo;
559
560         /* FIXME: The following are not saved in the session storage
561          * for session resumption.
562          */
563
564         /* Used by extensions that enable supplemental data: Which ones
565          * do that? Do they belong in security parameters?
566          */
567         int do_recv_supplemental, do_send_supplemental;
568         const version_entry_st *pversion;
569 } security_parameters_st;
570
571 struct record_state_st {
572         gnutls_datum_t mac_secret;
573         gnutls_datum_t IV;
574         gnutls_datum_t key;
575         auth_cipher_hd_st cipher_state;
576         comp_hd_st compression_state;
577         uint64 sequence_number;
578         uint8_t new_record_padding;
579 };
580
581
582 /* These are used to resolve relative epochs. These values are just
583    outside the 16 bit range to prevent off-by-one errors. An absolute
584    epoch may be referred to by its numeric id in the range
585    0x0000-0xffff. */
586 #define EPOCH_READ_CURRENT  70000
587 #define EPOCH_WRITE_CURRENT 70001
588 #define EPOCH_NEXT          70002
589
590 struct record_parameters_st {
591         uint16_t epoch;
592         int initialized;
593
594         gnutls_compression_method_t compression_algorithm;
595
596         const cipher_entry_st *cipher;
597         const mac_entry_st *mac;
598
599         /* for DTLS */
600         uint64_t record_sw[DTLS_RECORD_WINDOW_SIZE];
601         unsigned int record_sw_head_idx;
602         unsigned int record_sw_size;
603
604         record_state_st read;
605         record_state_st write;
606
607         /* Whether this state is in use, i.e., if there is
608            a pending handshake message waiting to be encrypted
609            under this epoch's parameters.
610          */
611         int usage_cnt;
612 };
613
614 typedef struct {
615         unsigned int priority[MAX_ALGOS];
616         unsigned int algorithms;
617 } priority_st;
618
619 typedef enum {
620         SR_DISABLED,
621         SR_UNSAFE,
622         SR_PARTIAL,
623         SR_SAFE
624 } safe_renegotiation_t;
625
626 /* For the external api */
627 struct gnutls_priority_st {
628         priority_st cipher;
629         priority_st mac;
630         priority_st kx;
631         priority_st compression;
632         priority_st protocol;
633         priority_st cert_type;
634         priority_st sign_algo;
635         priority_st supported_ecc;
636
637         /* to disable record padding */
638         bool no_extensions;
639         bool allow_large_records;
640         bool new_record_padding;
641         unsigned int max_empty_records;
642         unsigned int dumbfw;
643         safe_renegotiation_t sr;
644         bool ssl3_record_version;
645         bool server_precedence;
646         bool allow_weak_keys;
647         bool allow_wrong_pms;
648         /* Whether stateless compression will be used */
649         bool stateless_compression;
650         unsigned int additional_verify_flags;
651
652         /* The session's expected security level.
653          * Will be used to determine the minimum DH bits,
654          * (or the acceptable certificate security level).
655          */
656         gnutls_sec_param_t level;
657         unsigned int dh_prime_bits;     /* old (deprecated) variable */
658 };
659
660 /* Allow around 50KB of length-hiding padding
661  * when using legacy padding,
662  * or around 3.2MB when using new padding. */
663 #define DEFAULT_MAX_EMPTY_RECORDS 200
664
665 #define ENABLE_COMPAT(x) \
666               (x)->allow_large_records = 1; \
667               (x)->allow_wrong_pms = 1; \
668               (x)->allow_weak_keys = 1
669
670 /* DH and RSA parameters types.
671  */
672 typedef struct gnutls_dh_params_int {
673         /* [0] is the prime, [1] is the generator.
674          */
675         bigint_t params[2];
676         int q_bits;             /* length of q in bits. If zero then length is unknown.
677                                  */
678 } dh_params_st;
679
680 typedef struct {
681         gnutls_dh_params_t dh_params;
682         int free_dh_params;
683 } internal_params_st;
684
685 /* DTLS session state
686  */
687 typedef struct {
688         /* HelloVerifyRequest DOS prevention cookie */
689         uint8_t cookie[DTLS_MAX_COOKIE_SIZE];
690         uint8_t cookie_len;
691
692         /* For DTLS handshake fragmentation and reassembly. */
693         uint16_t hsk_write_seq;
694         /* the sequence number of the expected packet */
695         unsigned int hsk_read_seq;
696         uint16_t mtu;
697
698         /* a flight transmission is in process */
699         bool flight_init;
700         /* whether this is the last flight in the protocol  */
701         bool last_flight;
702
703         /* the retransmission timeout in milliseconds */
704         unsigned int retrans_timeout_ms;
705         /* the connection timeout in milliseconds */
706         unsigned int total_timeout_ms;
707
708         unsigned int hsk_hello_verify_requests;
709
710         /* non blocking stuff variables */
711         bool blocking;
712         /* starting time of current handshake */
713         struct timespec handshake_start_time;
714
715         /* The actual retrans_timeout for the next message (e.g. doubled or so) 
716          */
717         unsigned int actual_retrans_timeout_ms;
718
719         /* timers to handle async handshake after gnutls_handshake()
720          * has terminated. Required to handle retransmissions.
721          */
722         time_t async_term;
723
724         /* last retransmission triggered by record layer */
725         struct timespec last_retransmit;
726         unsigned int packets_dropped;
727 } dtls_st;
728
729 typedef union {
730         void *ptr;
731         uint32_t num;
732 } extension_priv_data_t;
733
734 typedef struct {
735         /* holds all the parsed data received by the record layer */
736         mbuffer_head_st record_buffer;
737
738         int handshake_hash_buffer_prev_len;     /* keeps the length of handshake_hash_buffer, excluding
739                                                  * the last received message */
740         gnutls_buffer_st handshake_hash_buffer; /* used to keep the last received handshake 
741                                                  * message */
742         bool resumable; /* TRUE or FALSE - if we can resume that session */
743         bool ticket_sent;       /* whether a session ticket was sent */
744         handshake_state_t handshake_final_state;
745         handshake_state_t handshake_state;      /* holds
746                                                  * a number which indicates where
747                                                  * the handshake procedure has been
748                                                  * interrupted. If it is 0 then
749                                                  * no interruption has happened.
750                                                  */
751
752         bool invalid_connection;        /* true or FALSE - if this session is valid */
753
754         bool may_not_read;      /* if it's 0 then we can read/write, otherwise it's forbiden to read/write
755                                  */
756         bool may_not_write;
757         bool read_eof;          /* non-zero if we have received a closure alert. */
758
759         int last_alert;         /* last alert received */
760
761         /* The last handshake messages sent or received.
762          */
763         int last_handshake_in;
764         int last_handshake_out;
765
766         /* priorities */
767         struct gnutls_priority_st priorities;
768
769         /* resumed session */
770         bool resumed;   /* RESUME_TRUE or FALSE - if we are resuming a session */
771         bool resumption_requested;      /* non-zero if resumption was requested by client */
772         security_parameters_st resumed_security_parameters;
773
774         /* These buffers are used in the handshake
775          * protocol only. freed using _gnutls_handshake_io_buffer_clear();
776          */
777         mbuffer_head_st handshake_send_buffer;
778         handshake_buffer_st handshake_recv_buffer[MAX_HANDSHAKE_MSGS];
779         int handshake_recv_buffer_size;
780
781         /* this buffer holds a record packet -mostly used for
782          * non blocking IO.
783          */
784         mbuffer_head_st record_recv_buffer;     /* buffer holding the unparsed record that is currently 
785                                                  * being received */
786         mbuffer_head_st record_send_buffer;     /* holds cached data
787                                                  * for the gnutls_io_write_buffered()
788                                                  * function.
789                                                  */
790         size_t record_send_buffer_user_size;    /* holds the
791                                                  * size of the user specified data to
792                                                  * send.
793                                                  */
794
795         record_flush_t record_flush_mode;       /* GNUTLS_FLUSH or GNUTLS_CORKED */
796         gnutls_buffer_st record_presend_buffer; /* holds cached data
797                                                  * for the gnutls_record_send()
798                                                  * function.
799                                                  */
800
801         unsigned expire_time;   /* after expire_time seconds this session will expire */
802         struct mod_auth_st_int *auth_struct;    /* used in handshake packets and KX algorithms */
803
804         /* this is the highest version available
805          * to the peer. (advertized version).
806          * This is obtained by the Handshake Client Hello 
807          * message. (some implementations read the Record version)
808          */
809         uint8_t adv_version_major;
810         uint8_t adv_version_minor;
811
812         /* if this is non zero a certificate request message
813          * will be sent to the client. - only if the ciphersuite
814          * supports it. In server side it contains GNUTLS_CERT_REQUIRE
815          * or similar.
816          */
817         unsigned send_cert_req;
818
819         size_t max_handshake_data_buffer_size;
820
821         /* PUSH & PULL functions.
822          */
823         gnutls_pull_timeout_func pull_timeout_func;
824         gnutls_pull_func pull_func;
825         gnutls_push_func push_func;
826         gnutls_vec_push_func vec_push_func;
827         gnutls_errno_func errno_func;
828         /* Holds the first argument of PUSH and PULL
829          * functions;
830          */
831         gnutls_transport_ptr_t transport_recv_ptr;
832         gnutls_transport_ptr_t transport_send_ptr;
833
834         /* STORE & RETRIEVE functions. Only used if other
835          * backend than gdbm is used.
836          */
837         gnutls_db_store_func db_store_func;
838         gnutls_db_retr_func db_retrieve_func;
839         gnutls_db_remove_func db_remove_func;
840         void *db_ptr;
841
842         /* post client hello callback (server side only)
843          */
844         gnutls_handshake_post_client_hello_func user_hello_func;
845         /* handshake hook function */
846         gnutls_handshake_hook_func h_hook;
847         unsigned int h_type;    /* the hooked type */
848         int16_t h_post;         /* whether post-generation/receive */
849
850         /* holds the selected certificate and key.
851          * use _gnutls_selected_certs_deinit() and _gnutls_selected_certs_set()
852          * to change them.
853          */
854         gnutls_pcert_st *selected_cert_list;
855         int16_t selected_cert_list_length;
856         struct gnutls_privkey_st *selected_key;
857         bool selected_need_free;
858
859         /* holds the extensions we sent to the peer
860          * (in case of a client)
861          */
862         uint16_t extensions_sent[MAX_EXT_TYPES];
863         uint16_t extensions_sent_size;
864
865         /* is 0 if we are to send the whole PGP key, or non zero
866          * if the fingerprint is to be sent.
867          */
868         bool pgp_fingerprint;
869
870         /* This holds the default version that our first
871          * record packet will have. */
872         uint8_t default_record_version[2];
873
874         void *user_ptr;
875
876         bool enable_private;    /* non zero to
877                                          * enable cipher suites
878                                          * which have 0xFF status.
879                                          */
880
881         /* Holds 0 if the last called function was interrupted while
882          * receiving, and non zero otherwise.
883          */
884         bool direction;
885
886         /* This callback will be used (if set) to receive an
887          * openpgp key. (if the peer sends a fingerprint)
888          */
889         gnutls_openpgp_recv_key_func openpgp_recv_key_func;
890
891         /* If non zero the server will not advertise the CA's he
892          * trusts (do not send an RDN sequence).
893          */
894         bool ignore_rdn_sequence;
895
896         /* This is used to set an arbitary version in the RSA
897          * PMS secret. Can be used by clients to test whether the
898          * server checks that version. (** only used in gnutls-cli-debug)
899          */
900         uint8_t rsa_pms_version[2];
901
902         /* Here we cache the DH or RSA parameters got from the
903          * credentials structure, or from a callback. That is to
904          * minimize external calls.
905          */
906         internal_params_st params;
907
908         /* To avoid using global variables, and especially on Windows where
909          * the application may use a different errno variable than GnuTLS,
910          * it is possible to use gnutls_transport_set_errno to set a
911          * session-specific errno variable in the user-replaceable push/pull
912          * functions.  This value is used by the send/recv functions.  (The
913          * strange name of this variable is because 'errno' is typically
914          * #define'd.)
915          */
916         int errnum;
917
918         /* Function used to perform public-key signing operation during
919            handshake.  Used by gnutls_sig.c:_gnutls_tls_sign(), see also
920            gnutls_sign_callback_set(). */
921         gnutls_sign_func sign_func;
922         void *sign_func_userdata;
923
924         /* minimum bits to allow for SRP
925          * use gnutls_srp_set_prime_bits() to adjust it.
926          */
927         uint16_t srp_prime_bits;
928
929         /* A handshake process has been completed */
930         bool initial_negotiation_completed;
931
932         struct {
933                 uint16_t type;
934                 extension_priv_data_t priv;
935                 bool set;
936         } extension_int_data[MAX_EXT_TYPES];
937
938         struct {
939                 uint16_t type;
940                 extension_priv_data_t priv;
941                 bool set;
942         } resumed_extension_int_data[MAX_EXT_TYPES];
943         /* The type of transport protocol; stream or datagram */
944         transport_t transport;
945
946         /* DTLS session state */
947         dtls_st dtls;
948
949         /* if set it means that the master key was set using
950          * gnutls_session_set_master() rather than being negotiated. */
951         bool premaster_set;
952
953         unsigned int cb_tls_unique_len;
954         unsigned char cb_tls_unique[MAX_VERIFY_DATA_SIZE];
955
956         time_t handshake_endtime;       /* end time in seconds */
957         unsigned int handshake_timeout_ms;      /* timeout in milliseconds */
958         unsigned int record_timeout_ms; /* timeout in milliseconds */
959
960         gnutls_buffer_st hb_local_data;
961         gnutls_buffer_st hb_remote_data;
962         struct timespec hb_ping_start;  /* timestamp: when first HeartBeat ping was sent */
963         struct timespec hb_ping_sent;   /* timestamp: when last HeartBeat ping was sent */
964         unsigned int hb_actual_retrans_timeout_ms;      /* current timeout, in milliseconds */
965         unsigned int hb_retrans_timeout_ms;     /* the default timeout, in milliseconds */
966         unsigned int hb_total_timeout_ms;       /* the total timeout, in milliseconds */
967
968         bool ocsp_check_ok;     /* will be zero if the OCSP response TLS extension
969                                          * check failed (OCSP was old/unrelated or so). */
970
971         heartbeat_state_t hb_state;     /* for ping */
972
973         recv_state_t recv_state;        /* state of the receive function */
974
975         bool sc_random_set;
976         bool no_replay_protection;      /* DTLS replay protection */
977
978         /* If you add anything here, check _gnutls_handshake_internal_state_clear().
979          */
980 } internals_st;
981
982 /* Maximum number of epochs we keep around. */
983 #define MAX_EPOCH_INDEX 16
984
985 struct gnutls_session_int {
986         security_parameters_st security_parameters;
987         record_parameters_st *record_parameters[MAX_EPOCH_INDEX];
988         internals_st internals;
989         gnutls_key_st key;
990 };
991
992
993 /* functions 
994  */
995 void _gnutls_free_auth_info(gnutls_session_t session);
996
997 /* These two macros return the advertised TLS version of
998  * the peer.
999  */
1000 #define _gnutls_get_adv_version_major( session) \
1001         session->internals.adv_version_major
1002
1003 #define _gnutls_get_adv_version_minor( session) \
1004         session->internals.adv_version_minor
1005
1006 #define set_adv_version( session, major, minor) \
1007         session->internals.adv_version_major = major; \
1008         session->internals.adv_version_minor = minor
1009
1010 int _gnutls_is_secure_mem_null(const void *);
1011
1012 inline static const version_entry_st *get_version(gnutls_session_t session)
1013 {
1014         return session->security_parameters.pversion;
1015 }
1016
1017 inline static unsigned get_num_version(gnutls_session_t session)
1018 {
1019         if (likely(session->security_parameters.pversion != NULL))
1020                 return session->security_parameters.pversion->id;
1021         else
1022                 return GNUTLS_VERSION_UNKNOWN;
1023 }
1024
1025 void _gnutls_priority_update_fips(void);
1026
1027 #define _gnutls_set_current_version(s, v) { \
1028   s->security_parameters.pversion = version_to_entry(v); \
1029   }
1030
1031 #define timespec_sub_ms _gnutls_timespec_sub_ms
1032 unsigned int
1033 /* returns a-b in ms */
1034  timespec_sub_ms(struct timespec *a, struct timespec *b);
1035
1036 #include <algorithms.h>
1037 inline static size_t max_user_send_size(gnutls_session_t session,
1038                                         record_parameters_st *
1039                                         record_params)
1040 {
1041         size_t max;
1042
1043         if (IS_DTLS(session))
1044                 max = gnutls_dtls_get_data_mtu(session);
1045         else {
1046                 max = session->security_parameters.max_record_send_size;
1047                 /* DTLS data MTU accounts for those */
1048
1049                 if (record_params->write.new_record_padding != 0)
1050                         max -= 2;
1051
1052                 if (_gnutls_cipher_is_block(record_params->cipher))
1053                         max -=
1054                             _gnutls_cipher_get_block_size(record_params->
1055                                                           cipher);
1056         }
1057
1058         return max;
1059 }
1060
1061 #endif                          /* GNUTLS_INT_H */