-static void ssl3_generate_key_block(s,km,num)
-SSL *s;
-unsigned char *km;
-int num;
- {
- MD5_CTX m5;
- SHA_CTX s1;
- unsigned char buf[8],smd[SHA_DIGEST_LENGTH];
- unsigned char c='A';
- int i,j,k;
-
- k=0;
- for (i=0; i<num; i+=MD5_DIGEST_LENGTH)
- {
- k++;
- for (j=0; j<k; j++)
- buf[j]=c;
- c++;
- SHA1_Init( &s1);
- SHA1_Update(&s1,buf,k);
- SHA1_Update(&s1,s->session->master_key,
- s->session->master_key_length);
- SHA1_Update(&s1,s->s3->server_random,SSL3_RANDOM_SIZE);
- SHA1_Update(&s1,s->s3->client_random,SSL3_RANDOM_SIZE);
- SHA1_Final( smd,&s1);
-
- MD5_Init( &m5);
- MD5_Update(&m5,s->session->master_key,
- s->session->master_key_length);
- MD5_Update(&m5,smd,SHA_DIGEST_LENGTH);
- if ((i+MD5_DIGEST_LENGTH) > num)
- {
- MD5_Final(smd,&m5);
- memcpy(km,smd,(num-i));
- }
- else
- MD5_Final(km,&m5);
-
- km+=MD5_DIGEST_LENGTH;
- }
- memset(smd,0,SHA_DIGEST_LENGTH);
- }
-
-int ssl3_change_cipher_state(s,which)
-SSL *s;
-int which;
- {
- unsigned char *p,*key_block,*mac_secret;
- unsigned char exp_key[EVP_MAX_KEY_LENGTH];
- unsigned char exp_iv[EVP_MAX_KEY_LENGTH];
- unsigned char *ms,*key,*iv,*er1,*er2;
- EVP_CIPHER_CTX *dd;
- EVP_CIPHER *c;
- COMP_METHOD *comp;
- EVP_MD *m;
- MD5_CTX md;
- int exp,n,i,j,k;
-
- exp=(s->s3->tmp.new_cipher->algorithms & SSL_EXPORT)?1:0;
- c=s->s3->tmp.new_sym_enc;
- m=s->s3->tmp.new_hash;
- comp=s->s3->tmp.new_compression;
- key_block=s->s3->tmp.key_block;
-
- if (which & SSL3_CC_READ)
- {
- if ((s->enc_read_ctx == NULL) &&
- ((s->enc_read_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
- goto err;
- dd= s->enc_read_ctx;
- s->read_hash=m;
- /* COMPRESS */
- if (s->expand != NULL)
- {
- COMP_CTX_free(s->expand);
- s->expand=NULL;
- }
- if (comp != NULL)
- {
- s->expand=COMP_CTX_new(comp);
- if (s->expand == NULL)
- {
- SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
- goto err2;
- }
- s->s3->rrec.comp=(unsigned char *)
- Malloc(SSL3_RT_MAX_PLAIN_LENGTH);
- if (s->s3->rrec.comp == NULL)
- goto err;
- }
- memset(&(s->s3->read_sequence[0]),0,8);
- mac_secret= &(s->s3->read_mac_secret[0]);
- }
- else
- {
- if ((s->enc_write_ctx == NULL) &&
- ((s->enc_write_ctx=(EVP_CIPHER_CTX *)
- Malloc(sizeof(EVP_CIPHER_CTX))) == NULL))
- goto err;
- dd= s->enc_write_ctx;
- s->write_hash=m;
- /* COMPRESS */
- if (s->compress != NULL)
- {
- COMP_CTX_free(s->compress);
- s->compress=NULL;
- }
- if (comp != NULL)
- {
- s->compress=COMP_CTX_new(comp);
- if (s->compress == NULL)
- {
- SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
- goto err2;
- }
- }
- memset(&(s->s3->write_sequence[0]),0,8);
- mac_secret= &(s->s3->write_mac_secret[0]);
- }
-
- EVP_CIPHER_CTX_init(dd);
-
- p=s->s3->tmp.key_block;
- i=EVP_MD_size(m);
- /* Should be j=exp?min(5,EVP_CIPHER_key_length(c)):EVP_CIPHER_key_length(c); ?? - Ben 30/12/98 */
- j=(exp)?5:EVP_CIPHER_key_length(c);
- k=EVP_CIPHER_iv_length(c);
- if ( (which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||
- (which == SSL3_CHANGE_CIPHER_SERVER_READ))
- {
- ms= &(p[ 0]); n=i+i;
- key= &(p[ n]); n+=j+j;
- iv= &(p[ n]); n+=k+k;
- er1= &(s->s3->client_random[0]);
- er2= &(s->s3->server_random[0]);
- }
- else
- {
- n=i;
- ms= &(p[ n]); n+=i+j;
- key= &(p[ n]); n+=j+k;
- iv= &(p[ n]); n+=k;
- er1= &(s->s3->server_random[0]);
- er2= &(s->s3->client_random[0]);
- }
-
- if (n > s->s3->tmp.key_block_length)
- {
- SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_INTERNAL_ERROR);
- goto err2;
- }
-
- memcpy(mac_secret,ms,i);
- if (exp)
- {
- /* In here I set both the read and write key/iv to the
- * same value since only the correct one will be used :-).
- */
- MD5_Init(&md);
- MD5_Update(&md,key,j);
- MD5_Update(&md,er1,SSL3_RANDOM_SIZE);
- MD5_Update(&md,er2,SSL3_RANDOM_SIZE);
- MD5_Final(&(exp_key[0]),&md);
- key= &(exp_key[0]);
-
- if (k > 0)
- {
- MD5_Init(&md);
- MD5_Update(&md,er1,SSL3_RANDOM_SIZE);
- MD5_Update(&md,er2,SSL3_RANDOM_SIZE);
- MD5_Final(&(exp_iv[0]),&md);
- iv= &(exp_iv[0]);
- }
- }
-
- s->session->key_arg_length=0;
-
- EVP_CipherInit(dd,c,key,iv,(which & SSL3_CC_WRITE));
-
- memset(&(exp_key[0]),0,sizeof(exp_key));
- memset(&(exp_iv[0]),0,sizeof(exp_iv));
- return(1);
-err:
- SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_MALLOC_FAILURE);
-err2:
- return(0);
- }
-
-int ssl3_setup_key_block(s)
-SSL *s;
- {
- unsigned char *p;
- EVP_CIPHER *c;
- EVP_MD *hash;
- int num,exp;
-
- if (s->s3->tmp.key_block_length != 0)
- return(1);
-
- if (!ssl_cipher_get_evp(s->session->cipher,&c,&hash))
- {
- SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);
- return(0);
- }
-
- s->s3->tmp.new_sym_enc=c;
- s->s3->tmp.new_hash=hash;
-#ifdef ZLIB
- s->s3->tmp.new_compression=COMP_zlib();
+ num = EVP_MD_size(hash);
+ if (num < 0)
+ return 0;
+
+ num = EVP_CIPHER_key_length(c) + num + EVP_CIPHER_iv_length(c);
+ num *= 2;
+
+ ssl3_cleanup_key_block(s);
+
+ if ((p = OPENSSL_malloc(num)) == NULL)
+ goto err;
+
+ s->s3->tmp.key_block_length = num;
+ s->s3->tmp.key_block = p;
+
+ ret = ssl3_generate_key_block(s, p, num);
+
+ if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)) {
+ /*
+ * enable vulnerability countermeasure for CBC ciphers with known-IV
+ * problem (http://www.openssl.org/~bodo/tls-cbc.txt)
+ */
+ s->s3->need_empty_fragments = 1;
+
+ if (s->session->cipher != NULL) {
+ if (s->session->cipher->algorithm_enc == SSL_eNULL)
+ s->s3->need_empty_fragments = 0;
+
+#ifndef OPENSSL_NO_RC4
+ if (s->session->cipher->algorithm_enc == SSL_RC4)
+ s->s3->need_empty_fragments = 0;
+#endif
+ }
+ }
+
+ return ret;
+
+ err:
+ SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK, ERR_R_MALLOC_FAILURE);
+ return (0);
+}
+
+void ssl3_cleanup_key_block(SSL *s)
+{
+ if (s->s3->tmp.key_block != NULL) {
+ OPENSSL_cleanse(s->s3->tmp.key_block, s->s3->tmp.key_block_length);
+ OPENSSL_free(s->s3->tmp.key_block);
+ s->s3->tmp.key_block = NULL;
+ }
+ s->s3->tmp.key_block_length = 0;
+}
+
+/*-
+ * ssl3_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
+ *
+ * Returns:
+ * 0: (in non-constant time) if the record is publically invalid (i.e. too
+ * short etc).
+ * 1: if the record's padding is valid / the encryption was successful.
+ * -1: if the record's padding is invalid or, if sending, an internal error
+ * occurred.
+ */
+int ssl3_enc(SSL *s, int send)
+{
+ SSL3_RECORD *rec;
+ EVP_CIPHER_CTX *ds;
+ unsigned long l;
+ int bs, i, mac_size = 0;
+ const EVP_CIPHER *enc;
+
+ if (send) {
+ ds = s->enc_write_ctx;
+ rec = &(s->s3->wrec);
+ if (s->enc_write_ctx == NULL)
+ enc = NULL;
+ else
+ enc = EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
+ } else {
+ ds = s->enc_read_ctx;
+ rec = &(s->s3->rrec);
+ if (s->enc_read_ctx == NULL)
+ enc = NULL;
+ else
+ enc = EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
+ }
+
+ if ((s->session == NULL) || (ds == NULL) || (enc == NULL)) {
+ memmove(rec->data, rec->input, rec->length);
+ rec->input = rec->data;
+ } else {
+ l = rec->length;
+ bs = EVP_CIPHER_block_size(ds->cipher);
+
+ /* COMPRESS */
+
+ if ((bs != 1) && send) {
+ i = bs - ((int)l % bs);
+
+ /* we need to add 'i-1' padding bytes */
+ l += i;
+ /*
+ * the last of these zero bytes will be overwritten with the
+ * padding length.
+ */
+ memset(&rec->input[rec->length], 0, i);
+ rec->length += i;
+ rec->input[l - 1] = (i - 1);
+ }
+
+ if (!send) {
+ if (l == 0 || l % bs != 0)
+ return 0;
+ /* otherwise, rec->length >= bs */
+ }
+
+ if (EVP_Cipher(ds, rec->data, rec->input, l) < 1)
+ return -1;
+
+ if (EVP_MD_CTX_md(s->read_hash) != NULL)
+ mac_size = EVP_MD_CTX_size(s->read_hash);
+ if ((bs != 1) && !send)
+ return ssl3_cbc_remove_padding(s, rec, bs, mac_size);
+ }
+ return (1);
+}
+
+void ssl3_init_finished_mac(SSL *s)
+{
+ if (s->s3->handshake_buffer)
+ BIO_free(s->s3->handshake_buffer);
+ if (s->s3->handshake_dgst)
+ ssl3_free_digest_list(s);
+ s->s3->handshake_buffer = BIO_new(BIO_s_mem());
+ (void)BIO_set_close(s->s3->handshake_buffer, BIO_CLOSE);
+}
+
+void ssl3_free_digest_list(SSL *s)
+{
+ int i;
+ if (!s->s3->handshake_dgst)
+ return;
+ for (i = 0; i < SSL_MAX_DIGEST; i++) {
+ if (s->s3->handshake_dgst[i])
+ EVP_MD_CTX_destroy(s->s3->handshake_dgst[i]);
+ }
+ OPENSSL_free(s->s3->handshake_dgst);
+ s->s3->handshake_dgst = NULL;
+}
+
+void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len)
+{
+ if (s->s3->handshake_buffer
+ && !(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE)) {
+ BIO_write(s->s3->handshake_buffer, (void *)buf, len);
+ } else {
+ int i;
+ for (i = 0; i < SSL_MAX_DIGEST; i++) {
+ if (s->s3->handshake_dgst[i] != NULL)
+ EVP_DigestUpdate(s->s3->handshake_dgst[i], buf, len);
+ }
+ }
+}
+
+int ssl3_digest_cached_records(SSL *s)
+{
+ int i;
+ long mask;
+ const EVP_MD *md;
+ long hdatalen;
+ void *hdata;
+
+ /* Allocate handshake_dgst array */
+ ssl3_free_digest_list(s);
+ s->s3->handshake_dgst =
+ OPENSSL_malloc(SSL_MAX_DIGEST * sizeof(EVP_MD_CTX *));
+ if (s->s3->handshake_dgst == NULL) {
+ SSLerr(SSL_F_SSL3_DIGEST_CACHED_RECORDS, ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+ memset(s->s3->handshake_dgst, 0, SSL_MAX_DIGEST * sizeof(EVP_MD_CTX *));
+ hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
+ if (hdatalen <= 0) {
+ SSLerr(SSL_F_SSL3_DIGEST_CACHED_RECORDS, SSL_R_BAD_HANDSHAKE_LENGTH);
+ return 0;
+ }
+
+ /* Loop through bitso of algorithm2 field and create MD_CTX-es */
+ for (i = 0; ssl_get_handshake_digest(i, &mask, &md); i++) {
+ if ((mask & ssl_get_algorithm2(s)) && md) {
+ s->s3->handshake_dgst[i] = EVP_MD_CTX_create();
+ if (EVP_MD_nid(md) == NID_md5) {
+ EVP_MD_CTX_set_flags(s->s3->handshake_dgst[i],
+ EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
+ }
+ EVP_DigestInit_ex(s->s3->handshake_dgst[i], md, NULL);
+ EVP_DigestUpdate(s->s3->handshake_dgst[i], hdata, hdatalen);
+ } else {
+ s->s3->handshake_dgst[i] = NULL;
+ }
+ }
+ if (!(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE)) {
+ /* Free handshake_buffer BIO */
+ BIO_free(s->s3->handshake_buffer);
+ s->s3->handshake_buffer = NULL;
+ }
+
+ return 1;
+}
+
+int ssl3_cert_verify_mac(SSL *s, int md_nid, unsigned char *p)
+{
+ return (ssl3_handshake_mac(s, md_nid, NULL, 0, p));
+}
+
+int ssl3_final_finish_mac(SSL *s,
+ const char *sender, int len, unsigned char *p)
+{
+ int ret, sha1len;
+ ret = ssl3_handshake_mac(s, NID_md5, sender, len, p);
+ if (ret == 0)
+ return 0;
+
+ p += ret;
+
+ sha1len = ssl3_handshake_mac(s, NID_sha1, sender, len, p);
+ if (sha1len == 0)
+ return 0;
+
+ ret += sha1len;
+ return (ret);
+}
+
+static int ssl3_handshake_mac(SSL *s, int md_nid,
+ const char *sender, int len, unsigned char *p)
+{
+ unsigned int ret;
+ int npad, n;
+ unsigned int i;
+ unsigned char md_buf[EVP_MAX_MD_SIZE];
+ EVP_MD_CTX ctx, *d = NULL;
+
+ if (s->s3->handshake_buffer)
+ if (!ssl3_digest_cached_records(s))
+ return 0;
+
+ /*
+ * Search for digest of specified type in the handshake_dgst array
+ */
+ for (i = 0; i < SSL_MAX_DIGEST; i++) {
+ if (s->s3->handshake_dgst[i]
+ && EVP_MD_CTX_type(s->s3->handshake_dgst[i]) == md_nid) {
+ d = s->s3->handshake_dgst[i];
+ break;
+ }
+ }
+ if (!d) {
+ SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, SSL_R_NO_REQUIRED_DIGEST);
+ return 0;
+ }
+ EVP_MD_CTX_init(&ctx);
+ EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
+ EVP_MD_CTX_copy_ex(&ctx, d);
+ n = EVP_MD_CTX_size(&ctx);
+ if (n < 0)
+ return 0;
+
+ npad = (48 / n) * n;
+ if (sender != NULL)
+ EVP_DigestUpdate(&ctx, sender, len);
+ EVP_DigestUpdate(&ctx, s->session->master_key,
+ s->session->master_key_length);
+ EVP_DigestUpdate(&ctx, ssl3_pad_1, npad);
+ EVP_DigestFinal_ex(&ctx, md_buf, &i);
+
+ EVP_DigestInit_ex(&ctx, EVP_MD_CTX_md(&ctx), NULL);
+ EVP_DigestUpdate(&ctx, s->session->master_key,
+ s->session->master_key_length);
+ EVP_DigestUpdate(&ctx, ssl3_pad_2, npad);
+ EVP_DigestUpdate(&ctx, md_buf, i);
+ EVP_DigestFinal_ex(&ctx, p, &ret);
+
+ EVP_MD_CTX_cleanup(&ctx);
+
+ return ((int)ret);
+}
+
+int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
+{
+ SSL3_RECORD *rec;
+ unsigned char *mac_sec, *seq;
+ EVP_MD_CTX md_ctx;
+ const EVP_MD_CTX *hash;
+ unsigned char *p, rec_char;
+ size_t md_size;
+ int npad;
+ int t;
+
+ if (send) {
+ rec = &(ssl->s3->wrec);
+ mac_sec = &(ssl->s3->write_mac_secret[0]);
+ seq = &(ssl->s3->write_sequence[0]);
+ hash = ssl->write_hash;
+ } else {
+ rec = &(ssl->s3->rrec);
+ mac_sec = &(ssl->s3->read_mac_secret[0]);
+ seq = &(ssl->s3->read_sequence[0]);
+ hash = ssl->read_hash;
+ }
+
+ t = EVP_MD_CTX_size(hash);
+ if (t < 0)
+ return -1;
+ md_size = t;
+ npad = (48 / md_size) * md_size;
+
+ if (!send &&
+ EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
+ ssl3_cbc_record_digest_supported(hash)) {
+ /*
+ * This is a CBC-encrypted record. We must avoid leaking any
+ * timing-side channel information about how many blocks of data we
+ * are hashing because that gives an attacker a timing-oracle.
+ */
+
+ /*-
+ * npad is, at most, 48 bytes and that's with MD5:
+ * 16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
+ *
+ * With SHA-1 (the largest hash speced for SSLv3) the hash size
+ * goes up 4, but npad goes down by 8, resulting in a smaller
+ * total size. */
+ unsigned char header[75];
+ unsigned j = 0;
+ memcpy(header + j, mac_sec, md_size);
+ j += md_size;
+ memcpy(header + j, ssl3_pad_1, npad);
+ j += npad;
+ memcpy(header + j, seq, 8);
+ j += 8;
+ header[j++] = rec->type;
+ header[j++] = rec->length >> 8;
+ header[j++] = rec->length & 0xff;
+
+ /* Final param == is SSLv3 */
+ ssl3_cbc_digest_record(hash,
+ md, &md_size,
+ header, rec->input,
+ rec->length + md_size, rec->orig_len,
+ mac_sec, md_size, 1);
+ } else {
+ unsigned int md_size_u;
+ /* Chop the digest off the end :-) */
+ EVP_MD_CTX_init(&md_ctx);
+
+ EVP_MD_CTX_copy_ex(&md_ctx, hash);
+ EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
+ EVP_DigestUpdate(&md_ctx, ssl3_pad_1, npad);
+ EVP_DigestUpdate(&md_ctx, seq, 8);
+ rec_char = rec->type;
+ EVP_DigestUpdate(&md_ctx, &rec_char, 1);
+ p = md;
+ s2n(rec->length, p);
+ EVP_DigestUpdate(&md_ctx, md, 2);
+ EVP_DigestUpdate(&md_ctx, rec->input, rec->length);
+ EVP_DigestFinal_ex(&md_ctx, md, NULL);
+
+ EVP_MD_CTX_copy_ex(&md_ctx, hash);
+ EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
+ EVP_DigestUpdate(&md_ctx, ssl3_pad_2, npad);
+ EVP_DigestUpdate(&md_ctx, md, md_size);
+ EVP_DigestFinal_ex(&md_ctx, md, &md_size_u);
+ md_size = md_size_u;
+
+ EVP_MD_CTX_cleanup(&md_ctx);
+ }
+
+ ssl3_record_sequence_update(seq);
+ return (md_size);
+}
+
+void ssl3_record_sequence_update(unsigned char *seq)
+{
+ int i;
+
+ for (i = 7; i >= 0; i--) {
+ ++seq[i];
+ if (seq[i] != 0)
+ break;
+ }
+}
+
+int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
+ int len)
+{
+ static const unsigned char *salt[3] = {
+#ifndef CHARSET_EBCDIC
+ (const unsigned char *)"A",
+ (const unsigned char *)"BB",
+ (const unsigned char *)"CCC",
+#else
+ (const unsigned char *)"\x41",
+ (const unsigned char *)"\x42\x42",
+ (const unsigned char *)"\x43\x43\x43",
+#endif
+ };
+ unsigned char buf[EVP_MAX_MD_SIZE];
+ EVP_MD_CTX ctx;
+ int i, ret = 0;
+ unsigned int n;
+#ifdef OPENSSL_SSL_TRACE_CRYPTO
+ unsigned char *tmpout = out;