2 * Copyright (C) 2000-2012 Free Software Foundation, Inc.
4 * Author: Nikos Mavrogiannopoulos
6 * This file is part of GnuTLS.
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 3 of
11 * the License, or (at your option) any later version.
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.
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/>
43 #include <sys/types.h>
47 # include <sys/socket.h>
49 # include <ws2tcpip.h>
52 #include <u64.h> /* gnulib for uint64_t */
55 # include <nettle/memxor.h>
57 # include <gl/memxor.h>
58 # define memxor gl_memxor
62 # ifndef _GNUTLS_GCC_VERSION
63 # define _GNUTLS_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
65 # if _GNUTLS_GCC_VERSION >= 30100
66 # define likely(x) __builtin_expect((x), 1)
67 # define unlikely(x) __builtin_expect((x), 0)
76 /* some systems had problems with long long int, thus,
84 #include <gnutls/gnutls.h>
85 #include <gnutls/dtls.h>
86 #include <gnutls/abstract.h>
90 * They are not needed any more. You can simply enable
91 * the gnutls_log callback to get error descriptions.
96 #define HANDSHAKE_DEBUG // Prints some information on handshake
97 #define COMPRESSION_DEBUG
101 /* The size of a handshake message should not
102 * be larger than this value.
104 #define MAX_HANDSHAKE_PACKET_SIZE 48*1024
106 #define TLS_MAX_SESSION_ID_SIZE 32
108 /* The maximum digest size of hash algorithms.
110 #define MAX_HASH_SIZE 64
111 #define MAX_CIPHER_BLOCK_SIZE 16
112 #define MAX_CIPHER_KEY_SIZE 32
114 #define MAX_USERNAME_SIZE 128
115 #define MAX_SERVER_NAME_SIZE 128
117 #define SESSION_TICKET_KEY_NAME_SIZE 16
118 #define SESSION_TICKET_KEY_SIZE 16
119 #define SESSION_TICKET_IV_SIZE 16
120 #define SESSION_TICKET_MAC_SECRET_SIZE 32
122 #define AEAD_EXPLICIT_DATA_SIZE 8
123 #define AEAD_IMPLICIT_DATA_SIZE 4
125 #define GNUTLS_MASTER_SIZE 48
126 #define GNUTLS_RANDOM_SIZE 32
129 #define DTLS_RECORD_WINDOW_SIZE 64
132 /* we can receive up to MAX_EXT_TYPES extensions.
134 #define MAX_EXT_TYPES 32
137 * gnutls_ext_parse_type_t:
138 * @GNUTLS_EXT_NONE: Never parsed
139 * @GNUTLS_EXT_ANY: Any extension type.
140 * @GNUTLS_EXT_APPLICATION: Application extension.
141 * @GNUTLS_EXT_TLS: TLS-internal extension.
142 * @GNUTLS_EXT_MANDATORY: Extension parsed even if resuming (or extensions are disabled).
144 * Enumeration of different TLS extension types. This flag
145 * indicates for an extension whether it is useful to application
146 * level or TLS level only. This is (only) used to parse the
147 * application level extensions before the "client_hello" callback
153 GNUTLS_EXT_APPLICATION
= 1,
155 GNUTLS_EXT_MANDATORY
= 3,
157 } gnutls_ext_parse_type_t
;
160 /* expire time for resuming sessions */
161 #define DEFAULT_EXPIRE_TIME 3600
163 typedef enum transport_t
169 /* the maximum size of encrypted packets */
170 #define IS_DTLS(session) (session->internals.transport == GNUTLS_DGRAM)
172 #define DEFAULT_MAX_RECORD_SIZE 16384
173 #define TLS_RECORD_HEADER_SIZE 5
174 #define DTLS_RECORD_HEADER_SIZE (TLS_RECORD_HEADER_SIZE+8)
175 #define RECORD_HEADER_SIZE(session) (IS_DTLS(session) ? DTLS_RECORD_HEADER_SIZE : TLS_RECORD_HEADER_SIZE)
176 #define MAX_RECORD_HEADER_SIZE DTLS_RECORD_HEADER_SIZE
178 #define MAX_RECORD_SEND_SIZE(session) (IS_DTLS(session)?((size_t)gnutls_dtls_get_data_mtu(session)):(size_t)session->security_parameters.max_record_send_size)
179 #define MAX_RECORD_RECV_SIZE(session) ((size_t)session->security_parameters.max_record_recv_size)
180 #define MAX_PAD_SIZE 255
181 #define EXTRA_COMP_SIZE 2048
182 #define MAX_RECORD_OVERHEAD (MAX_CIPHER_BLOCK_SIZE/*iv*/+MAX_PAD_SIZE+EXTRA_COMP_SIZE+MAX_HASH_SIZE/*MAC*/)
183 #define MAX_RECV_SIZE(session) (MAX_RECORD_OVERHEAD+MAX_RECORD_RECV_SIZE(session)+RECORD_HEADER_SIZE(session))
185 #define TLS_HANDSHAKE_HEADER_SIZE 4
186 #define DTLS_HANDSHAKE_HEADER_SIZE (TLS_HANDSHAKE_HEADER_SIZE+8)
187 #define HANDSHAKE_HEADER_SIZE(session) (IS_DTLS(session) ? DTLS_HANDSHAKE_HEADER_SIZE : TLS_HANDSHAKE_HEADER_SIZE)
188 #define MAX_HANDSHAKE_HEADER_SIZE DTLS_HANDSHAKE_HEADER_SIZE
190 /* This is the maximum handshake message size we send without
191 fragmentation. This currently ignores record layer overhead. */
192 #define DTLS_DEFAULT_MTU 1200
194 /* the maximum size of the DTLS cookie */
195 #define DTLS_MAX_COOKIE_SIZE 32
197 /* The maximum number of HELLO_VERIFY_REQUEST messages the client
198 processes before aborting. */
199 #define MAX_HANDSHAKE_HELLO_VERIFY_REQUESTS 5
201 /* defaults for verification functions
203 #define DEFAULT_VERIFY_DEPTH 32
204 #define DEFAULT_VERIFY_BITS 16*1024
206 #include <gnutls_mem.h>
208 #define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
210 #define DECR_LEN(len, x) do { len-=x; if (len<0) {gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
211 #define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {gnutls_assert(); return RET;} } while (0)
212 #define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {gnutls_assert(); COM;} } while (0)
214 #define GNUTLS_POINTER_TO_INT(_) ((int) GNUTLS_POINTER_TO_INT_CAST (_))
215 #define GNUTLS_INT_TO_POINTER(_) ((void*) GNUTLS_POINTER_TO_INT_CAST (_))
222 #include <gnutls_mpi.h>
224 typedef enum handshake_state_t
225 { STATE0
= 0, STATE1
, STATE2
,
226 STATE3
, STATE4
, STATE5
,
227 STATE6
, STATE7
, STATE8
, STATE9
, STATE11
= 11,
228 STATE20
= 20, STATE21
, STATE22
,
229 STATE30
= 30, STATE31
, STATE40
= 40, STATE41
, STATE50
= 50,
230 STATE60
= 60, STATE61
, STATE62
, STATE70
, STATE71
233 typedef enum recv_state_t
236 RECV_STATE_DTLS_RETRANSMIT
,
239 #include <gnutls_str.h>
241 /* This is the maximum number of algorithms (ciphers or macs etc).
242 * keep it synced with GNUTLS_MAX_ALGORITHM_NUM in gnutls.h
244 #define MAX_ALGOS GNUTLS_MAX_ALGORITHM_NUM
246 typedef enum extensions_t
248 GNUTLS_EXTENSION_SERVER_NAME
= 0,
249 GNUTLS_EXTENSION_MAX_RECORD_SIZE
= 1,
250 GNUTLS_EXTENSION_CERT_TYPE
= 9,
251 GNUTLS_EXTENSION_SUPPORTED_ECC
= 10,
252 GNUTLS_EXTENSION_SUPPORTED_ECC_PF
= 11,
253 GNUTLS_EXTENSION_SRP
= 12,
254 GNUTLS_EXTENSION_SIGNATURE_ALGORITHMS
= 13,
255 GNUTLS_EXTENSION_SESSION_TICKET
= 35,
256 GNUTLS_EXTENSION_SAFE_RENEGOTIATION
= 65281 /* aka: 0xff01 */
260 { CIPHER_STREAM
, CIPHER_BLOCK
} cipher_type_t
;
262 #define RESUME_TRUE 1
263 #define RESUME_FALSE 0
265 /* Record Protocol */
266 typedef enum content_type_t
268 GNUTLS_CHANGE_CIPHER_SPEC
= 20, GNUTLS_ALERT
,
269 GNUTLS_HANDSHAKE
, GNUTLS_APPLICATION_DATA
,
273 #define GNUTLS_PK_ANY (gnutls_pk_algorithm_t)-1
274 #define GNUTLS_PK_NONE (gnutls_pk_algorithm_t)-2
276 /* Message buffers (mbuffers) structures */
278 /* this is actually the maximum number of distinct handshake
279 * messages that can arrive in a single flight
281 #define MAX_HANDSHAKE_MSGS 6
284 /* Handshake layer type and sequence of message */
285 gnutls_handshake_description_t htype
;
291 /* indicate whether that message is complete.
292 * complete means start_offset == 0 and end_offset == length
294 uint32_t start_offset
;
297 uint8_t header
[MAX_HANDSHAKE_HEADER_SIZE
];
300 gnutls_buffer_st data
;
301 } handshake_buffer_st
;
303 typedef struct mbuffer_st
305 /* when used in mbuffer_head_st */
306 struct mbuffer_st
*next
;
307 struct mbuffer_st
*prev
;
309 /* msg->size - mark = number of bytes left to process in this
310 message. Mark should only be non-zero when this buffer is the
311 head of the queue. */
319 /* used during fill in, to separate header from data
321 unsigned int user_mark
;
323 /* Filled in by record layer on recv:
324 * type, record_sequence
327 /* record layer content type */
330 /* record layer sequence */
331 uint64 record_sequence
;
333 /* Filled in by handshake layer on send:
334 * type, epoch, htype, handshake_sequence
337 /* Record layer epoch of message */
340 /* Handshake layer type and sequence of message */
341 gnutls_handshake_description_t htype
;
342 uint16_t handshake_sequence
;
345 typedef struct mbuffer_head_st
354 /* Store & Retrieve functions defines:
357 typedef struct auth_cred_st
359 gnutls_credentials_type_t algorithm
;
361 /* the type of credentials depends on algorithm
364 struct auth_cred_st
*next
;
370 gnutls_pk_params_st ecdh_params
;
392 /* this is used to hold the peers authentication data
394 /* auth_info_t structures SHOULD NOT contain malloced
395 * elements. Check gnutls_session_pack.c, and gnutls_auth.c.
396 * Remember that this should be calloced!
399 gnutls_credentials_type_t auth_info_type
;
400 int auth_info_size
; /* needed in order to store to db for restoring
404 auth_cred_st
*cred
; /* used to specify keys/certificates etc */
407 /* some ciphersuites use this
408 * to provide client authentication.
409 * 1 if client auth was requested
410 * by the peer, 0 otherwise
411 *** In case of a server this
412 * holds 1 if we should wait
413 * for a client certificate verify
416 typedef struct gnutls_key_st
*gnutls_key_st
;
419 struct record_state_st
;
420 typedef struct record_state_st record_state_st
;
422 struct record_parameters_st
;
423 typedef struct record_parameters_st record_parameters_st
;
427 #include <gnutls_hash_int.h>
428 #include <gnutls_cipher_int.h>
429 #include <gnutls_compress.h>
433 uint8_t hash_algorithm
;
434 uint8_t sign_algorithm
; /* pk algorithm actually */
437 /* This structure holds parameters got from TLS extension
438 * mechanism. (some extensions may hold parameters in auth_info_t
439 * structures also - see SRP).
442 #define MAX_SIGNATURE_ALGORITHMS 16
443 #define MAX_SIGN_ALGO_SIZE (2 + MAX_SIGNATURE_ALGORITHMS * 2)
445 #define MAX_VERIFY_DATA_SIZE 36 /* in SSL 3.0, 12 in TLS 1.0 */
447 /* auth_info_t structures now MAY contain malloced
451 /* This structure and auth_info_t, are stored in the resume database,
452 * and are restored, in case of resume.
453 * Holds all the required parameters to resume the current
457 /* if you add anything in Security_Parameters struct, then
458 * also modify CPY_COMMON in gnutls_constate.c.
461 /* Note that the security parameters structure is set up after the
462 * handshake has finished. The only value you may depend on while
463 * the handshake is in progress is the cipher suite value.
467 unsigned int entity
; /* GNUTLS_SERVER or GNUTLS_CLIENT */
468 gnutls_kx_algorithm_t kx_algorithm
;
470 /* The epoch used to read and write */
472 uint16_t epoch_write
;
474 /* The epoch that the next handshake will initialize. */
477 /* The epoch at index 0 of record_parameters. */
480 /* this is the ciphersuite we are going to use
481 * moved here from internals in order to be restored
484 uint8_t cipher_suite
[2];
485 gnutls_compression_method_t compression_method
;
486 uint8_t master_secret
[GNUTLS_MASTER_SIZE
];
487 uint8_t client_random
[GNUTLS_RANDOM_SIZE
];
488 uint8_t server_random
[GNUTLS_RANDOM_SIZE
];
489 uint8_t session_id
[TLS_MAX_SESSION_ID_SIZE
];
490 uint8_t session_id_size
;
493 /* The send size is the one requested by the programmer.
494 * The recv size is the one negotiated with the peer.
496 uint16_t max_record_send_size
;
497 uint16_t max_record_recv_size
;
498 /* holds the negotiated certificate type */
499 gnutls_certificate_type_t cert_type
;
500 gnutls_ecc_curve_t ecc_curve
; /* holds the first supported ECC curve requested by client */
501 gnutls_protocol_t version
; /* moved here */
503 /* FIXME: The following are not saved in the session storage
504 * for session resumption.
507 /* Used by extensions that enable supplemental data: Which ones
508 * do that? Do they belong in security parameters?
510 int do_recv_supplemental
, do_send_supplemental
;
511 } security_parameters_st
;
513 struct record_state_st
515 gnutls_datum_t mac_secret
;
518 auth_cipher_hd_st cipher_state
;
519 comp_hd_st compression_state
;
520 uint64 sequence_number
;
523 /* These are used to resolve relative epochs. These values are just
524 outside the 16 bit range to prevent off-by-one errors. An absolute
525 epoch may be referred to by its numeric id in the range
527 #define EPOCH_READ_CURRENT 70000
528 #define EPOCH_WRITE_CURRENT 70001
529 #define EPOCH_NEXT 70002
531 struct record_parameters_st
536 gnutls_cipher_algorithm_t cipher_algorithm
;
537 gnutls_mac_algorithm_t mac_algorithm
;
538 gnutls_compression_method_t compression_algorithm
;
541 uint64_t record_sw
[DTLS_RECORD_WINDOW_SIZE
];
542 unsigned int record_sw_size
;
544 record_state_st read
;
545 record_state_st write
;
547 /* Whether this state is in use, i.e., if there is
548 a pending handshake message waiting to be encrypted
549 under this epoch's parameters.
556 unsigned int priority
[MAX_ALGOS
];
557 unsigned int algorithms
;
566 } safe_renegotiation_t
;
568 /* For the external api */
569 struct gnutls_priority_st
574 priority_st compression
;
575 priority_st protocol
;
576 priority_st cert_type
;
577 priority_st sign_algo
;
578 priority_st supported_ecc
;
580 /* to disable record padding */
581 unsigned int no_extensions
:1;
582 unsigned int no_padding
:1;
583 unsigned int allow_large_records
:1;
584 safe_renegotiation_t sr
;
585 unsigned int ssl3_record_version
:1;
586 unsigned int server_precedence
:1;
587 unsigned int allow_key_usage_violation
:1;
588 /* Whether stateless compression will be used */
589 unsigned int stateless_compression
:1;
590 unsigned int additional_verify_flags
;
594 /* DH and RSA parameters types.
596 typedef struct gnutls_dh_params_int
598 /* [0] is the prime, [1] is the generator.
601 int q_bits
; /* length of q in bits. If zero then length is unknown.
607 gnutls_dh_params_t dh_params
;
609 gnutls_rsa_params_t rsa_params
;
611 } internal_params_st
;
613 /* DTLS session state
617 /* HelloVerifyRequest DOS prevention cookie */
618 uint8_t cookie
[DTLS_MAX_COOKIE_SIZE
];
621 /* For DTLS handshake fragmentation and reassembly. */
622 uint16_t hsk_write_seq
;
623 /* the sequence number of the expected packet */
624 unsigned int hsk_read_seq
;
627 /* a flight transmission is in process */
628 unsigned int flight_init
:1;
629 /* whether this is the last flight in the protocol */
630 unsigned int last_flight
:1;
632 /* the retransmission timeout in milliseconds */
633 unsigned int retrans_timeout_ms
;
634 /* the connection timeout in milliseconds */
635 unsigned int total_timeout_ms
;
637 unsigned int hsk_hello_verify_requests
;
639 /* non blocking stuff variables */
640 unsigned int blocking
:1;
641 /* starting time of current handshake */
642 struct timespec handshake_start_time
;
644 /* The actual retrans_timeout for the next message (e.g. doubled or so)
646 unsigned int actual_retrans_timeout_ms
;
648 /* timers to handle async handshake after gnutls_handshake()
649 * has terminated. Required to handle retransmissions.
653 /* last retransmission triggered by record layer */
654 struct timespec last_retransmit
;
655 unsigned int packets_dropped
;
663 } extension_priv_data_t
;
667 /* holds all the parsed data received by the record layer */
668 mbuffer_head_st record_buffer
;
670 int handshake_hash_buffer_prev_len
; /* keeps the length of handshake_hash_buffer, excluding
671 * the last received message */
672 gnutls_buffer_st handshake_hash_buffer
; /* used to keep the last received handshake
674 unsigned int resumable
:1; /* TRUE or FALSE - if we can resume that session */
675 unsigned int ticket_sent
:1; /* whether a session ticket was sent */
676 handshake_state_t handshake_state
; /* holds
677 * a number which indicates where
678 * the handshake procedure has been
679 * interrupted. If it is 0 then
680 * no interruption has happened.
683 int invalid_connection
:1; /* true or FALSE - if this session is valid */
685 int may_not_read
:1; /* if it's 0 then we can read/write, otherwise it's forbiden to read/write
688 int read_eof
:1; /* non-zero if we have received a closure alert. */
690 int last_alert
; /* last alert received */
692 /* The last handshake messages sent or received.
694 int last_handshake_in
;
695 int last_handshake_out
;
698 struct gnutls_priority_st priorities
;
700 /* resumed session */
701 unsigned int resumed
:1; /* RESUME_TRUE or FALSE - if we are resuming a session */
702 unsigned int resumption_requested
:1; /* non-zero if resumption was requested by client */
703 security_parameters_st resumed_security_parameters
;
705 /* These buffers are used in the handshake
706 * protocol only. freed using _gnutls_handshake_io_buffer_clear();
708 mbuffer_head_st handshake_send_buffer
;
709 handshake_buffer_st handshake_recv_buffer
[MAX_HANDSHAKE_MSGS
];
710 int handshake_recv_buffer_size
;
712 /* this buffer holds a record packet -mostly used for
715 mbuffer_head_st record_recv_buffer
; /* buffer holding the unparsed record that is currently
717 mbuffer_head_st record_send_buffer
; /* holds cached data
718 * for the gnutls_io_write_buffered()
721 size_t record_send_buffer_user_size
; /* holds the
722 * size of the user specified data to
726 int expire_time
; /* after expire_time seconds this session will expire */
727 struct mod_auth_st_int
*auth_struct
; /* used in handshake packets and KX algorithms */
729 /* this is the highest version available
730 * to the peer. (advertized version).
731 * This is obtained by the Handshake Client Hello
732 * message. (some implementations read the Record version)
734 uint8_t adv_version_major
;
735 uint8_t adv_version_minor
;
737 /* if this is non zero a certificate request message
738 * will be sent to the client. - only if the ciphersuite
743 /* bits to use for DHE and DHA
744 * use _gnutls_dh_get_prime_bits() and gnutls_dh_set_prime_bits()
747 uint16_t dh_prime_bits
;
749 size_t max_handshake_data_buffer_size
;
751 /* PUSH & PULL functions.
753 gnutls_pull_timeout_func pull_timeout_func
;
754 gnutls_pull_func pull_func
;
755 gnutls_push_func push_func
;
756 gnutls_vec_push_func vec_push_func
;
757 gnutls_errno_func errno_func
;
758 /* Holds the first argument of PUSH and PULL
761 gnutls_transport_ptr_t transport_recv_ptr
;
762 gnutls_transport_ptr_t transport_send_ptr
;
764 /* STORE & RETRIEVE functions. Only used if other
765 * backend than gdbm is used.
767 gnutls_db_store_func db_store_func
;
768 gnutls_db_retr_func db_retrieve_func
;
769 gnutls_db_remove_func db_remove_func
;
772 /* post client hello callback (server side only)
774 gnutls_handshake_post_client_hello_func user_hello_func
;
776 /* holds the selected certificate and key.
777 * use _gnutls_selected_certs_deinit() and _gnutls_selected_certs_set()
780 gnutls_pcert_st
*selected_cert_list
;
781 int selected_cert_list_length
;
782 struct gnutls_privkey_st
*selected_key
;
783 int selected_need_free
:1;
785 /* holds the extensions we sent to the peer
786 * (in case of a client)
788 uint16_t extensions_sent
[MAX_EXT_TYPES
];
789 uint16_t extensions_sent_size
;
791 /* is 0 if we are to send the whole PGP key, or non zero
792 * if the fingerprint is to be sent.
796 /* This holds the default version that our first
797 * record packet will have. */
798 uint8_t default_record_version
[2];
802 int enable_private
; /* non zero to
803 * enable cipher suites
804 * which have 0xFF status.
807 /* Holds 0 if the last called function was interrupted while
808 * receiving, and non zero otherwise.
812 /* This callback will be used (if set) to receive an
813 * openpgp key. (if the peer sends a fingerprint)
815 gnutls_openpgp_recv_key_func openpgp_recv_key_func
;
817 /* If non zero the server will not advertise the CA's he
818 * trusts (do not send an RDN sequence).
820 int ignore_rdn_sequence
;
822 /* This is used to set an arbitary version in the RSA
823 * PMS secret. Can be used by clients to test whether the
824 * server checks that version. (** only used in gnutls-cli-debug)
826 uint8_t rsa_pms_version
[2];
828 /* Here we cache the DH or RSA parameters got from the
829 * credentials structure, or from a callback. That is to
830 * minimize external calls.
832 internal_params_st params
;
834 /* To avoid using global variables, and especially on Windows where
835 * the application may use a different errno variable than GnuTLS,
836 * it is possible to use gnutls_transport_set_errno to set a
837 * session-specific errno variable in the user-replaceable push/pull
838 * functions. This value is used by the send/recv functions. (The
839 * strange name of this variable is because 'errno' is typically
844 /* Function used to perform public-key signing operation during
845 handshake. Used by gnutls_sig.c:_gnutls_tls_sign(), see also
846 gnutls_sign_callback_set(). */
847 gnutls_sign_func sign_func
;
848 void *sign_func_userdata
;
850 /* minimum bits to allow for SRP
851 * use gnutls_srp_set_prime_bits() to adjust it.
853 uint16_t srp_prime_bits
;
855 /* A handshake process has been completed */
856 unsigned int initial_negotiation_completed
:1;
861 extension_priv_data_t priv
;
863 } extension_int_data
[MAX_EXT_TYPES
];
868 extension_priv_data_t priv
;
870 } resumed_extension_int_data
[MAX_EXT_TYPES
];
871 /* The type of transport protocol; stream or datagram */
872 transport_t transport
;
874 /* DTLS session state */
877 /* if set it means that the master key was set using
878 * gnutls_session_set_master() rather than being negotiated. */
879 unsigned int premaster_set
:1;
881 unsigned int cb_tls_unique_len
;
882 unsigned char cb_tls_unique
[MAX_VERIFY_DATA_SIZE
];
884 recv_state_t recv_state
; /* state of the receive function */
886 /* If you add anything here, check _gnutls_handshake_internal_state_clear().
890 /* Maximum number of epochs we keep around. */
891 #define MAX_EPOCH_INDEX 16
893 struct gnutls_session_int
895 security_parameters_st security_parameters
;
896 record_parameters_st
*record_parameters
[MAX_EPOCH_INDEX
];
897 internals_st internals
;
904 void _gnutls_free_auth_info (gnutls_session_t session
);
906 /* These two macros return the advertised TLS version of
909 #define _gnutls_get_adv_version_major( session) \
910 session->internals.adv_version_major
912 #define _gnutls_get_adv_version_minor( session) \
913 session->internals.adv_version_minor
915 #define set_adv_version( session, major, minor) \
916 session->internals.adv_version_major = major; \
917 session->internals.adv_version_minor = minor
919 void _gnutls_set_adv_version (gnutls_session_t
, gnutls_protocol_t
);
920 gnutls_protocol_t
_gnutls_get_adv_version (gnutls_session_t
);
922 int _gnutls_is_secure_mem_null (const void *);
924 inline static gnutls_protocol_t
925 _gnutls_protocol_get_version (gnutls_session_t session
)
927 return session
->security_parameters
.version
;
930 #define gnutls_protocol_get_version _gnutls_protocol_get_version
933 _gnutls_set_current_version (gnutls_session_t session
,
934 gnutls_protocol_t version
)
936 session
->security_parameters
.version
= version
;
939 #endif /* GNUTLS_INT_H */