RSA BSAFE Micro Edition Suite	Streamlined security for mobile and embedded devices

---

ssl_st.h

Go to the documentation of this file.

/* $Id: ssl_st.h,v 1.89 2005/07/19 03:56:13 gsingh Exp $ */
/*
 * Copyright (C) 1999-2003 RSA Security Inc. All rights reserved.
 *
 * This work contains proprietary information of RSA Security.
 * Distribution is limited to authorized licensees of RSA
 * Security. Any unauthorized reproduction, distribution or
 * modification of this work is strictly prohibited.
 */

#ifndef HEADER_SSL_ST_H
#define HEADER_SSL_ST_H

#if !defined(SSLC_SMALL_CODE) && !defined(SSLCME)
#include "hmac.h"
#include "ex_data.h"
#include "buffer.h"
#include "evp.h"
#endif /* !SSLC_SMALL_CODE && !SSLCME  */

#include "cert.h"

/*
 * ssl.h is included here so that the structure definitions are visible
 * as typedefs to doxygen so it will format the output in a clearer manner.
 *
 */
#include "ssl.h"

#if !defined(NO_COMP)
#define NO_COMP
#endif /* NO_COMP */

#ifndef HEADER_COMMON_HMAC_H
#define HEADER_COMMON_HMAC_H
typedef struct hmac_ctx_st HMAC_CTX;
#endif /* HEADER_COMMON_HMAC_H */

#ifndef HEADER_COMMON_BUFFER_H
# ifndef INCLUDE_COMMON_BUFFER_H
#  define HEADER_COMMON_BUFFER_H
typedef struct buf_mem_st BUF_MEM;
# else
#  include "buffer.h"
# endif /* INCLUDE_COMMON_BUFFER_H */
#endif /* HEADER_COMMON_BUFFER_H */

typedef union ssl_mac_ctx_un
{
    char *ptr;
    HMAC_CTX *hmac;
    EVP_MD_CTX *md;
} SSL_MAC_CTX;

typedef struct ssl_enc_st
{
    int mac_size;
    SSL_MAC_CTX mac_ctx;
    EVP_CIPHER_CTX *enc_ctx;
#ifndef NO_COMP
    COMP_CTX *comp;                        /* compression */
#endif
} SSL_ENC;

struct ssl_st
{
    int version;

    int type;

    SSL_METHOD *method;

    /*
     * There are two BIOs so data can be read and written to different
     * handlers. Typically these are both the same.
     */

    BIO *rbio;

    BIO *wbio;

    BIO *bbio;

    int rwstate;

    int in_handshake;

    int (*handshake_func)(SSL *ssl);

    int server;

    int new_session;

    int shutdown;

    int state;

    int cstate;

    int rstate;

    BUF_MEM *init_buf;

    int init_num;

    int init_off;

    unsigned char *packet;

    unsigned int packet_length;

    struct ssl2_ctx_st *s2;

    struct ssl3_ctx_st *s3;

    int read_ahead;

    int hit;

    STACK *cipher_list;

    STACK *cipher_list_by_id;

    SSL_ENC read;
    SSL_ENC write;

    void (*mac_cleanup)(SSL_MAC_CTX *ptr);

    struct cert_st *cert;

    STACK *cert_chain;

    unsigned int sid_ctx_length;
    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];

    SSL_SESSION *session; /* also in the session once established */

    /* Used in SSL2 and SSL3 */

    /* 0 indicates to ignore the verification failure. Otherwise, fail. */
    int verify_mode;

    int verify_depth;


#ifndef SSLC_SMALL_CODE

    SSL_VERIFY_CB_T *verify_cb;
#endif

    SSL_INFO_CB_T *info_cb;

#if (!defined(SSLC_SMALL_CODE) && !defined(SSL_INFO_CB_ONLY))
    SSL_ALERT_INFO_CB_T *alert_info_cb;

    char *alert_info_arg;
#endif

#ifndef SSLC_SMALL_CODE
    SSL_APP_DATA_CB_T *app_data_cb;
    char *app_data_arg;
#endif /* SSLC_SMALL_CODE */

    int error;

    int error_code;

    SSL_CTX *ctx;

    int debug;

    long verify_result;
#ifndef NO_EX_DATA

    CRYPTO_EX_DATA ex_data;
#endif /* NO_EX_DATA */

#ifndef NO_CA_LIST
    /* For the server side, keep the list of CA_dn available for use */

    STACK *client_CA;
#endif /* NO_CA_LIST */

    int references;

    unsigned long options;
    unsigned long user_options;

    int first_packet;

    int client_version;

    int write_buf_size;
    int read_buf_size;

    long client_cert_sz;
    long server_cert_sz;

    int blinding;

    EVP_MD_CTX *tmp_md;
    R_LIB_CTX *lib_ctx;
    void *r_cr_switch;

    unsigned long max_rsa_n;
    unsigned long max_rsa_e;
};

#ifndef NO_SSL2
typedef struct ssl2_ctx_st
{
    int three_byte_header;
    int clear_text; 
    int escape; 
    int ssl2_rollback; 
    unsigned int wnum;        
    int wpend_tot;
    char *wpend_buf;

    int wpend_off; 
    int wpend_len; 
    int wpend_ret; 
    int rbuf_left;
    int rbuf_offs;
    unsigned char *rbuf;
    unsigned char *wbuf;
    unsigned char *write_ptr;

    int alert_dispatch;

    unsigned int padding;
    unsigned int rlength; 
    int ract_data_length; 
    unsigned int wlength; 
    int wact_data_length; 
    unsigned char *ract_data;
    unsigned char *wact_data;
    unsigned char *mac_data;
    unsigned char *pad_data;

    unsigned char *read_key;
    unsigned char *write_key;

    unsigned int challenge_length;
    unsigned char challenge[SSL2_MAX_CHALLENGE_LENGTH];
    unsigned int conn_id_length;
    unsigned char conn_id[SSL2_MAX_CONNECTION_ID_LENGTH];
    unsigned int key_material_length;
    unsigned char key_material[SSL2_MAX_KEY_MATERIAL_LENGTH*2];

    unsigned long read_sequence;
    unsigned long write_sequence;

    struct
    {
        unsigned int conn_id_length;
        unsigned int cert_type;
        unsigned int cert_length;
        int csl;
        int clear;
        unsigned int enc;
        unsigned char ccl[SSL2_MAX_CERT_CHALLENGE_LENGTH];
        int cipher_spec_length;
        unsigned int session_id_length;
        unsigned int clen;
        unsigned int rlen;
    } tmp;
} SSL2_CTX;
#endif /* NO_SSL2 */

typedef struct ssl3_record_st
{
    int type;             
    /*int state;*/        /* any data in it? */
    unsigned int length;  
    unsigned int off;     
    unsigned char *data;  
    unsigned char *input; 
    unsigned char *comp;  
} SSL3_RECORD;

typedef struct ssl3_buffer_st
{
    int total;           
    int wanted;          
    int left;            
    int offset;          
    unsigned char *buf;  
    int buf_size;
} SSL3_BUFFER;

typedef struct ssl3_ctx_st
{
    long flags;
    int delay_buf_pop_ret;

    unsigned char read_sequence[8];
    unsigned char read_mac_secret[SSL_MAX_MD_SIZE];
    unsigned char write_sequence[8];
    unsigned char write_mac_secret[SSL_MAX_MD_SIZE];

    unsigned char server_random[SSL3_RANDOM_SIZE];
    unsigned char client_random[SSL3_RANDOM_SIZE];

    SSL3_BUFFER rbuf;        
    SSL3_BUFFER wbuf;        
    SSL3_RECORD rrec;        
    SSL3_RECORD wrec;        
    unsigned int wnum;  
    int wpend_tot;      
    int wpend_type;
    int wpend_ret;      
    char *wpend_buf;

    EVP_MD_CTX *finish_dgst1; 
    EVP_MD_CTX *finish_dgst2; 
    int change_cipher_spec; 
    int warn_alert;
    int fatal_alert;
    int alert_dispatch;
    char send_alert[2];

    int renegotiate; 
    int total_renegotiations;
    int num_renegotiations;

    int in_read_app_data;

    struct
    {
        unsigned char finish_md[SSL_MAX_MD_SIZE*2];

        unsigned long message_size;
        int message_type;

        SSL_CIPHER *new_cipher; 
#ifndef NO_DH
        DH *dh;
#endif /* !NO_DH */

        int next_state; 
        int reuse_message; 
        int cert_req; 
        int ctype_num;
        char ctype[SSL3_CT_NUMBER];
        STACK *ca_names;

        int use_rsa_tmp;

        int key_block_length;
        unsigned char *key_block;

        EVP_CIPHER *new_sym_enc;
        EVP_MD *new_hash;
#ifndef NO_COMP
        COMP_METHOD *new_compression;
#endif
        int cert_request;
    } tmp;

} SSL3_CTX;

#endif /* HEADER_SSL_ST_H */

---

Copyright (c) 1999-2005 RSA Security Inc. All rights reserved. 072-001001-2100-001-000 - 2.1