summaryrefslogtreecommitdiff
path: root/src/lib/libssl/s3_pkt.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libssl/s3_pkt.c')
-rw-r--r--src/lib/libssl/s3_pkt.c1223
1 files changed, 562 insertions, 661 deletions
diff --git a/src/lib/libssl/s3_pkt.c b/src/lib/libssl/s3_pkt.c
index 6b55d21a3e..6c677d9f6b 100644
--- a/src/lib/libssl/s3_pkt.c
+++ b/src/lib/libssl/s3_pkt.c
@@ -118,11 +118,12 @@
118#include <openssl/rand.h> 118#include <openssl/rand.h>
119 119
120static int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 120static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
121 unsigned int len, int create_empty_fragment); 121 unsigned int len, int create_empty_fragment);
122static int ssl3_get_record(SSL *s); 122static int ssl3_get_record(SSL *s);
123 123
124int ssl3_read_n(SSL *s, int n, int max, int extend) 124int
125 { 125ssl3_read_n(SSL *s, int n, int max, int extend)
126{
126 /* If extend == 0, obtain new n-byte packet; if extend == 1, increase 127 /* If extend == 0, obtain new n-byte packet; if extend == 1, increase
127 * packet by another n bytes. 128 * packet by another n bytes.
128 * The packet will be in the sub-array of s->s3->rbuf.buf specified 129 * The packet will be in the sub-array of s->s3->rbuf.buf specified
@@ -130,37 +131,35 @@ int ssl3_read_n(SSL *s, int n, int max, int extend)
130 * (If s->read_ahead is set, 'max' bytes may be stored in rbuf 131 * (If s->read_ahead is set, 'max' bytes may be stored in rbuf
131 * [plus s->packet_length bytes if extend == 1].) 132 * [plus s->packet_length bytes if extend == 1].)
132 */ 133 */
133 int i,len,left; 134 int i, len, left;
134 long align=0; 135 long align = 0;
135 unsigned char *pkt; 136 unsigned char *pkt;
136 SSL3_BUFFER *rb; 137 SSL3_BUFFER *rb;
137 138
138 if (n <= 0) return n; 139 if (n <= 0)
140 return n;
139 141
140 rb = &(s->s3->rbuf); 142 rb = &(s->s3->rbuf);
141 if (rb->buf == NULL) 143 if (rb->buf == NULL)
142 if (!ssl3_setup_read_buffer(s)) 144 if (!ssl3_setup_read_buffer(s))
143 return -1; 145 return -1;
144 146
145 left = rb->left; 147 left = rb->left;
146#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 148#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
147 align = (long)rb->buf + SSL3_RT_HEADER_LENGTH; 149 align = (long)rb->buf + SSL3_RT_HEADER_LENGTH;
148 align = (-align)&(SSL3_ALIGN_PAYLOAD-1); 150 align = (-align)&(SSL3_ALIGN_PAYLOAD - 1);
149#endif 151#endif
150 152
151 if (!extend) 153 if (!extend) {
152 {
153 /* start with empty packet ... */ 154 /* start with empty packet ... */
154 if (left == 0) 155 if (left == 0)
155 rb->offset = align; 156 rb->offset = align;
156 else if (align != 0 && left >= SSL3_RT_HEADER_LENGTH) 157 else if (align != 0 && left >= SSL3_RT_HEADER_LENGTH) {
157 {
158 /* check if next packet length is large 158 /* check if next packet length is large
159 * enough to justify payload alignment... */ 159 * enough to justify payload alignment... */
160 pkt = rb->buf + rb->offset; 160 pkt = rb->buf + rb->offset;
161 if (pkt[0] == SSL3_RT_APPLICATION_DATA 161 if (pkt[0] == SSL3_RT_APPLICATION_DATA
162 && (pkt[3]<<8|pkt[4]) >= 128) 162 && (pkt[3]<<8|pkt[4]) >= 128) {
163 {
164 /* Note that even if packet is corrupted 163 /* Note that even if packet is corrupted
165 * and its length field is insane, we can 164 * and its length field is insane, we can
166 * only be led to wrong decision about 165 * only be led to wrong decision about
@@ -168,109 +167,100 @@ int ssl3_read_n(SSL *s, int n, int max, int extend)
168 * Header values has no effect on memmove 167 * Header values has no effect on memmove
169 * arguments and therefore no buffer 168 * arguments and therefore no buffer
170 * overrun can be triggered. */ 169 * overrun can be triggered. */
171 memmove (rb->buf+align,pkt,left); 170 memmove (rb->buf + align, pkt, left);
172 rb->offset = align; 171 rb->offset = align;
173 }
174 } 172 }
173 }
175 s->packet = rb->buf + rb->offset; 174 s->packet = rb->buf + rb->offset;
176 s->packet_length = 0; 175 s->packet_length = 0;
177 /* ... now we can act as if 'extend' was set */ 176 /* ... now we can act as if 'extend' was set */
178 } 177 }
179 178
180 /* For DTLS/UDP reads should not span multiple packets 179 /* For DTLS/UDP reads should not span multiple packets
181 * because the read operation returns the whole packet 180 * because the read operation returns the whole packet
182 * at once (as long as it fits into the buffer). */ 181 * at once (as long as it fits into the buffer). */
183 if (SSL_version(s) == DTLS1_VERSION || SSL_version(s) == DTLS1_BAD_VER) 182 if (SSL_version(s) == DTLS1_VERSION || SSL_version(s) == DTLS1_BAD_VER) {
184 {
185 if (left > 0 && n > left) 183 if (left > 0 && n > left)
186 n = left; 184 n = left;
187 } 185 }
188 186
189 /* if there is enough in the buffer from a previous read, take some */ 187 /* if there is enough in the buffer from a previous read, take some */
190 if (left >= n) 188 if (left >= n) {
191 { 189 s->packet_length += n;
192 s->packet_length+=n; 190 rb->left = left - n;
193 rb->left=left-n; 191 rb->offset += n;
194 rb->offset+=n; 192 return (n);
195 return(n); 193 }
196 }
197 194
198 /* else we need to read more data */ 195 /* else we need to read more data */
199 196
200 len = s->packet_length; 197 len = s->packet_length;
201 pkt = rb->buf+align; 198 pkt = rb->buf + align;
202 /* Move any available bytes to front of buffer: 199 /* Move any available bytes to front of buffer:
203 * 'len' bytes already pointed to by 'packet', 200 * 'len' bytes already pointed to by 'packet',
204 * 'left' extra ones at the end */ 201 * 'left' extra ones at the end */
205 if (s->packet != pkt) /* len > 0 */ 202 if (s->packet != pkt) /* len > 0 */
206 { 203 {
207 memmove(pkt, s->packet, len+left); 204 memmove(pkt, s->packet, len + left);
208 s->packet = pkt; 205 s->packet = pkt;
209 rb->offset = len + align; 206 rb->offset = len + align;
210 } 207 }
211 208
212 if (n > (int)(rb->len - rb->offset)) /* does not happen */ 209 if (n > (int)(rb->len - rb->offset)) /* does not happen */
213 { 210 {
214 SSLerr(SSL_F_SSL3_READ_N,ERR_R_INTERNAL_ERROR); 211 SSLerr(SSL_F_SSL3_READ_N, ERR_R_INTERNAL_ERROR);
215 return -1; 212 return -1;
216 } 213 }
217 214
218 if (!s->read_ahead) 215 if (!s->read_ahead)
219 /* ignore max parameter */ 216 /* ignore max parameter */
220 max = n; 217 max = n;
221 else 218 else {
222 {
223 if (max < n) 219 if (max < n)
224 max = n; 220 max = n;
225 if (max > (int)(rb->len - rb->offset)) 221 if (max > (int)(rb->len - rb->offset))
226 max = rb->len - rb->offset; 222 max = rb->len - rb->offset;
227 } 223 }
228 224
229 while (left < n) 225 while (left < n) {
230 {
231 /* Now we have len+left bytes at the front of s->s3->rbuf.buf 226 /* Now we have len+left bytes at the front of s->s3->rbuf.buf
232 * and need to read in more until we have len+n (up to 227 * and need to read in more until we have len+n (up to
233 * len+max if possible) */ 228 * len+max if possible) */
234 229
235 errno = 0; 230 errno = 0;
236 if (s->rbio != NULL) 231 if (s->rbio != NULL) {
237 { 232 s->rwstate = SSL_READING;
238 s->rwstate=SSL_READING; 233 i = BIO_read(s->rbio, pkt + len + left, max - left);
239 i=BIO_read(s->rbio,pkt+len+left, max-left); 234 } else {
240 } 235 SSLerr(SSL_F_SSL3_READ_N, SSL_R_READ_BIO_NOT_SET);
241 else
242 {
243 SSLerr(SSL_F_SSL3_READ_N,SSL_R_READ_BIO_NOT_SET);
244 i = -1; 236 i = -1;
245 } 237 }
246 238
247 if (i <= 0) 239 if (i <= 0) {
248 {
249 rb->left = left; 240 rb->left = left;
250 if (s->mode & SSL_MODE_RELEASE_BUFFERS && 241 if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
251 SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER) 242 SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER)
252 if (len+left == 0) 243 if (len + left == 0)
253 ssl3_release_read_buffer(s); 244 ssl3_release_read_buffer(s);
254 return(i); 245 return (i);
255 } 246 }
256 left+=i; 247 left += i;
257 /* reads should *never* span multiple packets for DTLS because 248 /* reads should *never* span multiple packets for DTLS because
258 * the underlying transport protocol is message oriented as opposed 249 * the underlying transport protocol is message oriented as opposed
259 * to byte oriented as in the TLS case. */ 250 * to byte oriented as in the TLS case. */
260 if (SSL_version(s) == DTLS1_VERSION || SSL_version(s) == DTLS1_BAD_VER) 251 if (SSL_version(s) == DTLS1_VERSION || SSL_version(s) == DTLS1_BAD_VER) {
261 {
262 if (n > left) 252 if (n > left)
263 n = left; /* makes the while condition false */ 253 n = left; /* makes the while condition false */
264 }
265 } 254 }
255 }
266 256
267 /* done reading, now the book-keeping */ 257 /* done reading, now the book-keeping */
268 rb->offset += n; 258 rb->offset += n;
269 rb->left = left - n; 259 rb->left = left - n;
270 s->packet_length += n; 260 s->packet_length += n;
271 s->rwstate=SSL_NOTHING; 261 s->rwstate = SSL_NOTHING;
272 return(n); 262 return (n);
273 } 263}
274 264
275/* Call this to get a new input record. 265/* Call this to get a new input record.
276 * It will return <= 0 if more data is needed, normally due to an error 266 * It will return <= 0 if more data is needed, normally due to an error
@@ -281,10 +271,11 @@ int ssl3_read_n(SSL *s, int n, int max, int extend)
281 * ssl->s3->rrec.length, - number of bytes 271 * ssl->s3->rrec.length, - number of bytes
282 */ 272 */
283/* used only by ssl3_read_bytes */ 273/* used only by ssl3_read_bytes */
284static int ssl3_get_record(SSL *s) 274static int
285 { 275ssl3_get_record(SSL *s)
286 int ssl_major,ssl_minor,al; 276{
287 int enc_err,n,i,ret= -1; 277 int ssl_major, ssl_minor, al;
278 int enc_err, n, i, ret = -1;
288 SSL3_RECORD *rr; 279 SSL3_RECORD *rr;
289 SSL_SESSION *sess; 280 SSL_SESSION *sess;
290 unsigned char *p; 281 unsigned char *p;
@@ -293,90 +284,83 @@ static int ssl3_get_record(SSL *s)
293 unsigned mac_size, orig_len; 284 unsigned mac_size, orig_len;
294 size_t extra; 285 size_t extra;
295 286
296 rr= &(s->s3->rrec); 287 rr = &(s->s3->rrec);
297 sess=s->session; 288 sess = s->session;
298 289
299 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER) 290 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
300 extra=SSL3_RT_MAX_EXTRA; 291 extra = SSL3_RT_MAX_EXTRA;
301 else 292 else
302 extra=0; 293 extra = 0;
303 if (extra && !s->s3->init_extra) 294 if (extra && !s->s3->init_extra) {
304 {
305 /* An application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER 295 /* An application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER
306 * set after ssl3_setup_buffers() was done */ 296 * set after ssl3_setup_buffers() was done */
307 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR); 297 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
308 return -1; 298 return -1;
309 } 299 }
310 300
311again: 301again:
312 /* check if we have the header */ 302 /* check if we have the header */
313 if ( (s->rstate != SSL_ST_READ_BODY) || 303 if ((s->rstate != SSL_ST_READ_BODY) ||
314 (s->packet_length < SSL3_RT_HEADER_LENGTH)) 304 (s->packet_length < SSL3_RT_HEADER_LENGTH)) {
315 { 305 n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
316 n=ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
317 if (n <= 0) return(n); /* error or non-blocking */ 306 if (n <= 0) return(n); /* error or non-blocking */
318 s->rstate=SSL_ST_READ_BODY; 307 s->rstate = SSL_ST_READ_BODY;
319 308
320 p=s->packet; 309 p = s->packet;
321 310
322 /* Pull apart the header into the SSL3_RECORD */ 311 /* Pull apart the header into the SSL3_RECORD */
323 rr->type= *(p++); 312 rr->type= *(p++);
324 ssl_major= *(p++); 313 ssl_major= *(p++);
325 ssl_minor= *(p++); 314 ssl_minor= *(p++);
326 version=(ssl_major<<8)|ssl_minor; 315 version = (ssl_major << 8)|ssl_minor;
327 n2s(p,rr->length); 316 n2s(p, rr->length);
328#if 0 317#if 0
329fprintf(stderr, "Record type=%d, Length=%d\n", rr->type, rr->length); 318 fprintf(stderr, "Record type=%d, Length=%d\n", rr->type, rr->length);
330#endif 319#endif
331 320
332 /* Lets check version */ 321 /* Lets check version */
333 if (!s->first_packet) 322 if (!s->first_packet) {
334 { 323 if (version != s->version) {
335 if (version != s->version) 324 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
336 { 325 if ((s->version & 0xFF00) == (version & 0xFF00) && !s->enc_write_ctx && !s->write_hash)
337 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER); 326 /* Send back error using their minor version number :-) */
338 if ((s->version & 0xFF00) == (version & 0xFF00) && !s->enc_write_ctx && !s->write_hash) 327 s->version = (unsigned short)version;
339 /* Send back error using their minor version number :-) */ 328 al = SSL_AD_PROTOCOL_VERSION;
340 s->version = (unsigned short)version;
341 al=SSL_AD_PROTOCOL_VERSION;
342 goto f_err; 329 goto f_err;
343 }
344 } 330 }
331 }
345 332
346 if ((version>>8) != SSL3_VERSION_MAJOR) 333 if ((version >> 8) != SSL3_VERSION_MAJOR) {
347 { 334 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
348 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER);
349 goto err; 335 goto err;
350 } 336 }
351 337
352 if (rr->length > s->s3->rbuf.len - SSL3_RT_HEADER_LENGTH) 338 if (rr->length > s->s3->rbuf.len - SSL3_RT_HEADER_LENGTH) {
353 { 339 al = SSL_AD_RECORD_OVERFLOW;
354 al=SSL_AD_RECORD_OVERFLOW; 340 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
355 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
356 goto f_err; 341 goto f_err;
357 } 342 }
358 343
359 /* now s->rstate == SSL_ST_READ_BODY */ 344 /* now s->rstate == SSL_ST_READ_BODY */
360 } 345 }
361 346
362 /* s->rstate == SSL_ST_READ_BODY, get and decode the data */ 347 /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
363 348
364 if (rr->length > s->packet_length-SSL3_RT_HEADER_LENGTH) 349 if (rr->length > s->packet_length - SSL3_RT_HEADER_LENGTH) {
365 {
366 /* now s->packet_length == SSL3_RT_HEADER_LENGTH */ 350 /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
367 i=rr->length; 351 i = rr->length;
368 n=ssl3_read_n(s,i,i,1); 352 n = ssl3_read_n(s, i, i, 1);
369 if (n <= 0) return(n); /* error or non-blocking io */ 353 if (n <= 0) return(n); /* error or non-blocking io */
370 /* now n == rr->length, 354 /* now n == rr->length,
371 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */ 355 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */
372 } 356 }
373 357
374 s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */ 358 s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */
375 359
376 /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length, 360 /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
377 * and we have that many bytes in s->packet 361 * and we have that many bytes in s->packet
378 */ 362 */
379 rr->input= &(s->packet[SSL3_RT_HEADER_LENGTH]); 363 rr->input = &(s->packet[SSL3_RT_HEADER_LENGTH]);
380 364
381 /* ok, we can now read from 's->packet' data into 'rr' 365 /* ok, we can now read from 's->packet' data into 'rr'
382 * rr->input points at rr->length bytes, which 366 * rr->input points at rr->length bytes, which
@@ -389,47 +373,43 @@ fprintf(stderr, "Record type=%d, Length=%d\n", rr->type, rr->length);
389 * rr->length bytes of encrypted compressed stuff. */ 373 * rr->length bytes of encrypted compressed stuff. */
390 374
391 /* check is not needed I believe */ 375 /* check is not needed I believe */
392 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra) 376 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH + extra) {
393 { 377 al = SSL_AD_RECORD_OVERFLOW;
394 al=SSL_AD_RECORD_OVERFLOW; 378 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
395 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
396 goto f_err; 379 goto f_err;
397 } 380 }
398 381
399 /* decrypt in place in 'rr->input' */ 382 /* decrypt in place in 'rr->input' */
400 rr->data=rr->input; 383 rr->data = rr->input;
401 384
402 enc_err = s->method->ssl3_enc->enc(s,0); 385 enc_err = s->method->ssl3_enc->enc(s, 0);
403 /* enc_err is: 386 /* enc_err is:
404 * 0: (in non-constant time) if the record is publically invalid. 387 * 0: (in non-constant time) if the record is publically invalid.
405 * 1: if the padding is valid 388 * 1: if the padding is valid
406 * -1: if the padding is invalid */ 389 * -1: if the padding is invalid */
407 if (enc_err == 0) 390 if (enc_err == 0) {
408 { 391 al = SSL_AD_DECRYPTION_FAILED;
409 al=SSL_AD_DECRYPTION_FAILED; 392 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
410 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
411 goto f_err; 393 goto f_err;
412 } 394 }
413 395
414#ifdef TLS_DEBUG 396#ifdef TLS_DEBUG
415printf("dec %d\n",rr->length); 397 printf("dec %d\n", rr->length);
416{ unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); } 398 { unsigned int z; for (z = 0; z<rr->length; z++) printf("%02X%c", rr->data[z],((z+1)%16)?' ':'\n'); }
417printf("\n"); 399 printf("\n");
418#endif 400#endif
419 401
420 /* r->length is now the compressed data plus mac */ 402 /* r->length is now the compressed data plus mac */
421 if ((sess != NULL) && 403 if ((sess != NULL) && (s->enc_read_ctx != NULL) &&
422 (s->enc_read_ctx != NULL) && 404 (EVP_MD_CTX_md(s->read_hash) != NULL)) {
423 (EVP_MD_CTX_md(s->read_hash) != NULL))
424 {
425 /* s->read_hash != NULL => mac_size != -1 */ 405 /* s->read_hash != NULL => mac_size != -1 */
426 unsigned char *mac = NULL; 406 unsigned char *mac = NULL;
427 unsigned char mac_tmp[EVP_MAX_MD_SIZE]; 407 unsigned char mac_tmp[EVP_MAX_MD_SIZE];
428 mac_size=EVP_MD_CTX_size(s->read_hash); 408 mac_size = EVP_MD_CTX_size(s->read_hash);
429 OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE); 409 OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
430 410
431 /* kludge: *_cbc_remove_padding passes padding length in rr->type */ 411 /* kludge: *_cbc_remove_padding passes padding length in rr->type */
432 orig_len = rr->length+((unsigned int)rr->type>>8); 412 orig_len = rr->length + ((unsigned int)rr->type >> 8);
433 413
434 /* orig_len is the length of the record before any padding was 414 /* orig_len is the length of the record before any padding was
435 * removed. This is public information, as is the MAC in use, 415 * removed. This is public information, as is the MAC in use,
@@ -437,17 +417,15 @@ printf("\n");
437 * amount of time if it's too short to possibly contain a MAC. 417 * amount of time if it's too short to possibly contain a MAC.
438 */ 418 */
439 if (orig_len < mac_size || 419 if (orig_len < mac_size ||
440 /* CBC records must have a padding length byte too. */ 420 /* CBC records must have a padding length byte too. */
441 (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE && 421 (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
442 orig_len < mac_size+1)) 422 orig_len < mac_size + 1)) {
443 { 423 al = SSL_AD_DECODE_ERROR;
444 al=SSL_AD_DECODE_ERROR; 424 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
445 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
446 goto f_err; 425 goto f_err;
447 } 426 }
448 427
449 if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) 428 if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
450 {
451 /* We update the length so that the TLS header bytes 429 /* We update the length so that the TLS header bytes
452 * can be constructed correctly but we need to extract 430 * can be constructed correctly but we need to extract
453 * the MAC in constant time from within the record, 431 * the MAC in constant time from within the record,
@@ -456,60 +434,53 @@ printf("\n");
456 mac = mac_tmp; 434 mac = mac_tmp;
457 ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len); 435 ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
458 rr->length -= mac_size; 436 rr->length -= mac_size;
459 } 437 } else {
460 else
461 {
462 /* In this case there's no padding, so |orig_len| 438 /* In this case there's no padding, so |orig_len|
463 * equals |rec->length| and we checked that there's 439 * equals |rec->length| and we checked that there's
464 * enough bytes for |mac_size| above. */ 440 * enough bytes for |mac_size| above. */
465 rr->length -= mac_size; 441 rr->length -= mac_size;
466 mac = &rr->data[rr->length]; 442 mac = &rr->data[rr->length];
467 } 443 }
468 444
469 i=s->method->ssl3_enc->mac(s,md,0 /* not send */); 445 i=s->method->ssl3_enc->mac(s,md,0 /* not send */);
470 if (i < 0 || mac == NULL || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) 446 if (i < 0 || mac == NULL || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
471 enc_err = -1; 447 enc_err = -1;
472 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size) 448 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra + mac_size)
473 enc_err = -1; 449 enc_err = -1;
474 } 450 }
475 451
476 if (enc_err < 0) 452 if (enc_err < 0) {
477 {
478 /* A separate 'decryption_failed' alert was introduced with TLS 1.0, 453 /* A separate 'decryption_failed' alert was introduced with TLS 1.0,
479 * SSL 3.0 only has 'bad_record_mac'. But unless a decryption 454 * SSL 3.0 only has 'bad_record_mac'. But unless a decryption
480 * failure is directly visible from the ciphertext anyway, 455 * failure is directly visible from the ciphertext anyway,
481 * we should not reveal which kind of error occured -- this 456 * we should not reveal which kind of error occured -- this
482 * might become visible to an attacker (e.g. via a logfile) */ 457 * might become visible to an attacker (e.g. via a logfile) */
483 al=SSL_AD_BAD_RECORD_MAC; 458 al = SSL_AD_BAD_RECORD_MAC;
484 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); 459 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
485 goto f_err; 460 goto f_err;
486 } 461 }
487 462
488 /* r->length is now just compressed */ 463 /* r->length is now just compressed */
489 if (s->expand != NULL) 464 if (s->expand != NULL) {
490 { 465 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra) {
491 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra) 466 al = SSL_AD_RECORD_OVERFLOW;
492 { 467 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);
493 al=SSL_AD_RECORD_OVERFLOW;
494 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
495 goto f_err; 468 goto f_err;
496 } 469 }
497 if (!ssl3_do_uncompress(s)) 470 if (!ssl3_do_uncompress(s)) {
498 { 471 al = SSL_AD_DECOMPRESSION_FAILURE;
499 al=SSL_AD_DECOMPRESSION_FAILURE; 472 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);
500 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_DECOMPRESSION);
501 goto f_err; 473 goto f_err;
502 }
503 } 474 }
475 }
504 476
505 if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH+extra) 477 if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH + extra) {
506 { 478 al = SSL_AD_RECORD_OVERFLOW;
507 al=SSL_AD_RECORD_OVERFLOW; 479 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
508 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
509 goto f_err; 480 goto f_err;
510 } 481 }
511 482
512 rr->off=0; 483 rr->off = 0;
513 /* So at this point the following is true 484 /* So at this point the following is true
514 * ssl->s3->rrec.type is the type of record 485 * ssl->s3->rrec.type is the type of record
515 * ssl->s3->rrec.length == number of bytes in record 486 * ssl->s3->rrec.length == number of bytes in record
@@ -519,178 +490,171 @@ printf("\n");
519 */ 490 */
520 491
521 /* we have pulled in a full packet so zero things */ 492 /* we have pulled in a full packet so zero things */
522 s->packet_length=0; 493 s->packet_length = 0;
523 494
524 /* just read a 0 length packet */ 495 /* just read a 0 length packet */
525 if (rr->length == 0) goto again; 496 if (rr->length == 0)
497 goto again;
526 498
527#if 0 499#if 0
528fprintf(stderr, "Ultimate Record type=%d, Length=%d\n", rr->type, rr->length); 500 fprintf(stderr, "Ultimate Record type=%d, Length=%d\n", rr->type, rr->length);
529#endif 501#endif
530 502
531 return(1); 503 return (1);
532 504
533f_err: 505f_err:
534 ssl3_send_alert(s,SSL3_AL_FATAL,al); 506 ssl3_send_alert(s, SSL3_AL_FATAL, al);
535err: 507err:
536 return(ret); 508 return (ret);
537 } 509}
538 510
539int ssl3_do_uncompress(SSL *ssl) 511int
540 { 512ssl3_do_uncompress(SSL *ssl)
513{
541#ifndef OPENSSL_NO_COMP 514#ifndef OPENSSL_NO_COMP
542 int i; 515 int i;
543 SSL3_RECORD *rr; 516 SSL3_RECORD *rr;
544 517
545 rr= &(ssl->s3->rrec); 518 rr = &(ssl->s3->rrec);
546 i=COMP_expand_block(ssl->expand,rr->comp, 519 i = COMP_expand_block(ssl->expand, rr->comp,
547 SSL3_RT_MAX_PLAIN_LENGTH,rr->data,(int)rr->length); 520 SSL3_RT_MAX_PLAIN_LENGTH, rr->data,(int)rr->length);
548 if (i < 0) 521 if (i < 0)
549 return(0); 522 return (0);
550 else 523 else
551 rr->length=i; 524 rr->length = i;
552 rr->data=rr->comp; 525 rr->data = rr->comp;
553#endif 526#endif
554 return(1); 527 return (1);
555 } 528}
556 529
557int ssl3_do_compress(SSL *ssl) 530int
558 { 531ssl3_do_compress(SSL *ssl)
532{
559#ifndef OPENSSL_NO_COMP 533#ifndef OPENSSL_NO_COMP
560 int i; 534 int i;
561 SSL3_RECORD *wr; 535 SSL3_RECORD *wr;
562 536
563 wr= &(ssl->s3->wrec); 537 wr = &(ssl->s3->wrec);
564 i=COMP_compress_block(ssl->compress,wr->data, 538 i = COMP_compress_block(ssl->compress, wr->data,
565 SSL3_RT_MAX_COMPRESSED_LENGTH, 539 SSL3_RT_MAX_COMPRESSED_LENGTH,
566 wr->input,(int)wr->length); 540 wr->input,(int)wr->length);
567 if (i < 0) 541 if (i < 0)
568 return(0); 542 return (0);
569 else 543 else
570 wr->length=i; 544 wr->length = i;
571 545
572 wr->input=wr->data; 546 wr->input = wr->data;
573#endif 547#endif
574 return(1); 548 return (1);
575 } 549}
576 550
577/* Call this to write data in records of type 'type' 551/* Call this to write data in records of type 'type'
578 * It will return <= 0 if not all data has been sent or non-blocking IO. 552 * It will return <= 0 if not all data has been sent or non-blocking IO.
579 */ 553 */
580int ssl3_write_bytes(SSL *s, int type, const void *buf_, int len) 554int
581 { 555ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
582 const unsigned char *buf=buf_; 556{
583 unsigned int tot,n,nw; 557 const unsigned char *buf = buf_;
558 unsigned int tot, n, nw;
584 int i; 559 int i;
585 560
586 s->rwstate=SSL_NOTHING; 561 s->rwstate = SSL_NOTHING;
587 tot=s->s3->wnum; 562 tot = s->s3->wnum;
588 s->s3->wnum=0; 563 s->s3->wnum = 0;
589 564
590 if (SSL_in_init(s) && !s->in_handshake) 565 if (SSL_in_init(s) && !s->in_handshake) {
591 { 566 i = s->handshake_func(s);
592 i=s->handshake_func(s); 567 if (i < 0)
593 if (i < 0) return(i); 568 return (i);
594 if (i == 0) 569 if (i == 0) {
595 { 570 SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
596 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
597 return -1; 571 return -1;
598 }
599 } 572 }
573 }
600 574
601 n=(len-tot); 575 n = (len - tot);
602 for (;;) 576 for (;;) {
603 {
604 if (n > s->max_send_fragment) 577 if (n > s->max_send_fragment)
605 nw=s->max_send_fragment; 578 nw = s->max_send_fragment;
606 else 579 else
607 nw=n; 580 nw = n;
608 581
609 i=do_ssl3_write(s, type, &(buf[tot]), nw, 0); 582 i = do_ssl3_write(s, type, &(buf[tot]), nw, 0);
610 if (i <= 0) 583 if (i <= 0) {
611 { 584 s->s3->wnum = tot;
612 s->s3->wnum=tot;
613 return i; 585 return i;
614 } 586 }
615 587
616 if ((i == (int)n) || 588 if ((i == (int)n) || (type == SSL3_RT_APPLICATION_DATA &&
617 (type == SSL3_RT_APPLICATION_DATA && 589 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
618 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
619 {
620 /* next chunk of data should get another prepended empty fragment 590 /* next chunk of data should get another prepended empty fragment
621 * in ciphersuites with known-IV weakness: */ 591 * in ciphersuites with known-IV weakness: */
622 s->s3->empty_fragment_done = 0; 592 s->s3->empty_fragment_done = 0;
623
624 return tot+i;
625 }
626 593
627 n-=i; 594 return tot + i;
628 tot+=i;
629 } 595 }
630 }
631 596
632static int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 597 n -= i;
633 unsigned int len, int create_empty_fragment) 598 tot += i;
634 { 599 }
635 unsigned char *p,*plen; 600}
636 int i,mac_size,clear=0; 601
637 int prefix_len=0; 602static int
603do_ssl3_write(SSL *s, int type, const unsigned char *buf,
604 unsigned int len, int create_empty_fragment)
605{
606 unsigned char *p, *plen;
607 int i, mac_size, clear = 0;
608 int prefix_len = 0;
638 int eivlen; 609 int eivlen;
639 long align=0; 610 long align = 0;
640 SSL3_RECORD *wr; 611 SSL3_RECORD *wr;
641 SSL3_BUFFER *wb=&(s->s3->wbuf); 612 SSL3_BUFFER *wb = &(s->s3->wbuf);
642 SSL_SESSION *sess; 613 SSL_SESSION *sess;
643 614
644 if (wb->buf == NULL) 615 if (wb->buf == NULL)
645 if (!ssl3_setup_write_buffer(s)) 616 if (!ssl3_setup_write_buffer(s))
646 return -1; 617 return -1;
647 618
648 /* first check if there is a SSL3_BUFFER still being written 619 /* first check if there is a SSL3_BUFFER still being written
649 * out. This will happen with non blocking IO */ 620 * out. This will happen with non blocking IO */
650 if (wb->left != 0) 621 if (wb->left != 0)
651 return(ssl3_write_pending(s,type,buf,len)); 622 return (ssl3_write_pending(s, type, buf, len));
652 623
653 /* If we have an alert to send, lets send it */ 624 /* If we have an alert to send, lets send it */
654 if (s->s3->alert_dispatch) 625 if (s->s3->alert_dispatch) {
655 { 626 i = s->method->ssl_dispatch_alert(s);
656 i=s->method->ssl_dispatch_alert(s);
657 if (i <= 0) 627 if (i <= 0)
658 return(i); 628 return (i);
659 /* if it went, fall through and send more stuff */ 629 /* if it went, fall through and send more stuff */
660 } 630 }
661 631
662 if (len == 0 && !create_empty_fragment) 632 if (len == 0 && !create_empty_fragment)
663 return 0; 633 return 0;
664 634
665 wr= &(s->s3->wrec); 635 wr = &(s->s3->wrec);
666 sess=s->session; 636 sess = s->session;
667 637
668 if ( (sess == NULL) || 638 if ((sess == NULL) || (s->enc_write_ctx == NULL) ||
669 (s->enc_write_ctx == NULL) || 639 (EVP_MD_CTX_md(s->write_hash) == NULL)) {
670 (EVP_MD_CTX_md(s->write_hash) == NULL))
671 {
672#if 1 640#if 1
673 clear=s->enc_write_ctx?0:1; /* must be AEAD cipher */ 641 clear = s->enc_write_ctx ? 0 : 1; /* must be AEAD cipher */
674#else 642#else
675 clear=1; 643 clear = 1;
676#endif 644#endif
677 mac_size=0; 645 mac_size = 0;
678 } 646 } else {
679 else 647 mac_size = EVP_MD_CTX_size(s->write_hash);
680 {
681 mac_size=EVP_MD_CTX_size(s->write_hash);
682 if (mac_size < 0) 648 if (mac_size < 0)
683 goto err; 649 goto err;
684 } 650 }
685 651
686 /* 'create_empty_fragment' is true only when this function calls itself */ 652 /* 'create_empty_fragment' is true only when this function calls itself */
687 if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done) 653 if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done) {
688 {
689 /* countermeasure against known-IV weakness in CBC ciphersuites 654 /* countermeasure against known-IV weakness in CBC ciphersuites
690 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */ 655 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
691 656
692 if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) 657 if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) {
693 {
694 /* recursive function call with 'create_empty_fragment' set; 658 /* recursive function call with 'create_empty_fragment' set;
695 * this prepares and buffers the data for an empty fragment 659 * this prepares and buffers the data for an empty fragment
696 * (these 'prefix_len' bytes are sent out later 660 * (these 'prefix_len' bytes are sent out later
@@ -700,216 +664,195 @@ static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
700 goto err; 664 goto err;
701 665
702 if (prefix_len > 666 if (prefix_len >
703 (SSL3_RT_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD)) 667 (SSL3_RT_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD)) {
704 {
705 /* insufficient space */ 668 /* insufficient space */
706 SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); 669 SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
707 goto err; 670 goto err;
708 }
709 } 671 }
710
711 s->s3->empty_fragment_done = 1;
712 } 672 }
713 673
714 if (create_empty_fragment) 674 s->s3->empty_fragment_done = 1;
715 { 675 }
676
677 if (create_empty_fragment) {
716#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 678#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
717 /* extra fragment would be couple of cipher blocks, 679 /* extra fragment would be couple of cipher blocks,
718 * which would be multiple of SSL3_ALIGN_PAYLOAD, so 680 * which would be multiple of SSL3_ALIGN_PAYLOAD, so
719 * if we want to align the real payload, then we can 681 * if we want to align the real payload, then we can
720 * just pretent we simply have two headers. */ 682 * just pretent we simply have two headers. */
721 align = (long)wb->buf + 2*SSL3_RT_HEADER_LENGTH; 683 align = (long)wb->buf + 2*SSL3_RT_HEADER_LENGTH;
722 align = (-align)&(SSL3_ALIGN_PAYLOAD-1); 684 align = (-align)&(SSL3_ALIGN_PAYLOAD - 1);
723#endif 685#endif
724 p = wb->buf + align; 686 p = wb->buf + align;
725 wb->offset = align; 687 wb->offset = align;
726 } 688 } else if (prefix_len) {
727 else if (prefix_len)
728 {
729 p = wb->buf + wb->offset + prefix_len; 689 p = wb->buf + wb->offset + prefix_len;
730 } 690 } else {
731 else
732 {
733#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 691#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
734 align = (long)wb->buf + SSL3_RT_HEADER_LENGTH; 692 align = (long)wb->buf + SSL3_RT_HEADER_LENGTH;
735 align = (-align)&(SSL3_ALIGN_PAYLOAD-1); 693 align = (-align)&(SSL3_ALIGN_PAYLOAD - 1);
736#endif 694#endif
737 p = wb->buf + align; 695 p = wb->buf + align;
738 wb->offset = align; 696 wb->offset = align;
739 } 697 }
740 698
741 /* write the header */ 699 /* write the header */
742 700
743 *(p++)=type&0xff; 701 *(p++) = type&0xff;
744 wr->type=type; 702 wr->type = type;
745 703
746 *(p++)=(s->version>>8); 704 *(p++) = (s->version >> 8);
747 /* Some servers hang if iniatial client hello is larger than 256 705 /* Some servers hang if iniatial client hello is larger than 256
748 * bytes and record version number > TLS 1.0 706 * bytes and record version number > TLS 1.0
749 */ 707 */
750 if (s->state == SSL3_ST_CW_CLNT_HELLO_B 708 if (s->state == SSL3_ST_CW_CLNT_HELLO_B && !s->renegotiate &&
751 && !s->renegotiate 709 TLS1_get_version(s) > TLS1_VERSION)
752 && TLS1_get_version(s) > TLS1_VERSION)
753 *(p++) = 0x1; 710 *(p++) = 0x1;
754 else 711 else
755 *(p++)=s->version&0xff; 712 *(p++) = s->version&0xff;
756 713
757 /* field where we are to write out packet length */ 714 /* field where we are to write out packet length */
758 plen=p; 715 plen = p;
759 p+=2; 716
717 p += 2;
760 /* Explicit IV length, block ciphers and TLS version 1.1 or later */ 718 /* Explicit IV length, block ciphers and TLS version 1.1 or later */
761 if (s->enc_write_ctx && s->version >= TLS1_1_VERSION) 719 if (s->enc_write_ctx && s->version >= TLS1_1_VERSION) {
762 {
763 int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx); 720 int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx);
764 if (mode == EVP_CIPH_CBC_MODE) 721 if (mode == EVP_CIPH_CBC_MODE) {
765 {
766 eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx); 722 eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx);
767 if (eivlen <= 1) 723 if (eivlen <= 1)
768 eivlen = 0; 724 eivlen = 0;
769 } 725 }
770 /* Need explicit part of IV for GCM mode */ 726 /* Need explicit part of IV for GCM mode */
771 else if (mode == EVP_CIPH_GCM_MODE) 727 else if (mode == EVP_CIPH_GCM_MODE)
772 eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN; 728 eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
773 else 729 else
774 eivlen = 0; 730 eivlen = 0;
775 } 731 } else
776 else
777 eivlen = 0; 732 eivlen = 0;
778 733
779 /* lets setup the record stuff. */ 734 /* lets setup the record stuff. */
780 wr->data=p + eivlen; 735 wr->data = p + eivlen;
781 wr->length=(int)len; 736 wr->length = (int)len;
782 wr->input=(unsigned char *)buf; 737 wr->input = (unsigned char *)buf;
783 738
784 /* we now 'read' from wr->input, wr->length bytes into 739 /* we now 'read' from wr->input, wr->length bytes into
785 * wr->data */ 740 * wr->data */
786 741
787 /* first we compress */ 742 /* first we compress */
788 if (s->compress != NULL) 743 if (s->compress != NULL) {
789 { 744 if (!ssl3_do_compress(s)) {
790 if (!ssl3_do_compress(s)) 745 SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_COMPRESSION_FAILURE);
791 {
792 SSLerr(SSL_F_DO_SSL3_WRITE,SSL_R_COMPRESSION_FAILURE);
793 goto err; 746 goto err;
794 }
795 }
796 else
797 {
798 memcpy(wr->data,wr->input,wr->length);
799 wr->input=wr->data;
800 } 747 }
748 } else {
749 memcpy(wr->data, wr->input, wr->length);
750 wr->input = wr->data;
751 }
801 752
802 /* we should still have the output to wr->data and the input 753 /* we should still have the output to wr->data and the input
803 * from wr->input. Length should be wr->length. 754 * from wr->input. Length should be wr->length.
804 * wr->data still points in the wb->buf */ 755 * wr->data still points in the wb->buf */
805 756
806 if (mac_size != 0) 757 if (mac_size != 0) {
807 { 758 if (s->method->ssl3_enc->mac(s, &(p[wr->length + eivlen]), 1) < 0)
808 if (s->method->ssl3_enc->mac(s,&(p[wr->length + eivlen]),1) < 0)
809 goto err; 759 goto err;
810 wr->length+=mac_size; 760 wr->length += mac_size;
811 } 761 }
812 762
813 wr->input=p; 763 wr->input = p;
814 wr->data=p; 764 wr->data = p;
815 765
816 if (eivlen) 766 if (eivlen) {
817 {
818 /* if (RAND_pseudo_bytes(p, eivlen) <= 0) 767 /* if (RAND_pseudo_bytes(p, eivlen) <= 0)
819 goto err; */ 768 goto err;
769*/
820 wr->length += eivlen; 770 wr->length += eivlen;
821 } 771 }
822 772
823 /* ssl3_enc can only have an error on read */ 773 /* ssl3_enc can only have an error on read */
824 s->method->ssl3_enc->enc(s,1); 774 s->method->ssl3_enc->enc(s, 1);
825 775
826 /* record length after mac and block padding */ 776 /* record length after mac and block padding */
827 s2n(wr->length,plen); 777 s2n(wr->length, plen);
828 778
829 /* we should now have 779 /* we should now have
830 * wr->data pointing to the encrypted data, which is 780 * wr->data pointing to the encrypted data, which is
831 * wr->length long */ 781 * wr->length long */
832 wr->type=type; /* not needed but helps for debugging */ 782 wr->type=type; /* not needed but helps for debugging */
833 wr->length+=SSL3_RT_HEADER_LENGTH; 783 wr->length += SSL3_RT_HEADER_LENGTH;
834 784
835 if (create_empty_fragment) 785 if (create_empty_fragment) {
836 {
837 /* we are in a recursive call; 786 /* we are in a recursive call;
838 * just return the length, don't write out anything here 787 * just return the length, don't write out anything here
839 */ 788 */
840 return wr->length; 789 return wr->length;
841 } 790 }
842 791
843 /* now let's set up wb */ 792 /* now let's set up wb */
844 wb->left = prefix_len + wr->length; 793 wb->left = prefix_len + wr->length;
845 794
846 /* memorize arguments so that ssl3_write_pending can detect bad write retries later */ 795 /* memorize arguments so that ssl3_write_pending can detect bad write retries later */
847 s->s3->wpend_tot=len; 796 s->s3->wpend_tot = len;
848 s->s3->wpend_buf=buf; 797 s->s3->wpend_buf = buf;
849 s->s3->wpend_type=type; 798 s->s3->wpend_type = type;
850 s->s3->wpend_ret=len; 799 s->s3->wpend_ret = len;
851 800
852 /* we now just need to write the buffer */ 801 /* we now just need to write the buffer */
853 return ssl3_write_pending(s,type,buf,len); 802 return ssl3_write_pending(s, type, buf, len);
854err: 803err:
855 return -1; 804 return -1;
856 } 805}
857 806
858/* if s->s3->wbuf.left != 0, we need to call this */ 807/* if s->s3->wbuf.left != 0, we need to call this */
859int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, 808int
860 unsigned int len) 809ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
861 { 810 unsigned int len)
811{
862 int i; 812 int i;
863 SSL3_BUFFER *wb=&(s->s3->wbuf); 813 SSL3_BUFFER *wb = &(s->s3->wbuf);
864 814
865/* XXXX */ 815/* XXXX */
866 if ((s->s3->wpend_tot > (int)len) 816 if ((s->s3->wpend_tot > (int)len) || ((s->s3->wpend_buf != buf) &&
867 || ((s->s3->wpend_buf != buf) && 817 !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
868 !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) 818 (s->s3->wpend_type != type)) {
869 || (s->s3->wpend_type != type)) 819 SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BAD_WRITE_RETRY);
870 { 820 return (-1);
871 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BAD_WRITE_RETRY); 821 }
872 return(-1);
873 }
874 822
875 for (;;) 823 for (;;) {
876 {
877 errno = 0; 824 errno = 0;
878 if (s->wbio != NULL) 825 if (s->wbio != NULL) {
879 { 826 s->rwstate = SSL_WRITING;
880 s->rwstate=SSL_WRITING; 827 i = BIO_write(s->wbio,
881 i=BIO_write(s->wbio, 828 (char *)&(wb->buf[wb->offset]),
882 (char *)&(wb->buf[wb->offset]), 829 (unsigned int)wb->left);
883 (unsigned int)wb->left); 830 } else {
884 } 831 SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BIO_NOT_SET);
885 else 832 i = -1;
886 { 833 }
887 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BIO_NOT_SET); 834 if (i == wb->left) {
888 i= -1; 835 wb->left = 0;
889 } 836 wb->offset += i;
890 if (i == wb->left)
891 {
892 wb->left=0;
893 wb->offset+=i;
894 if (s->mode & SSL_MODE_RELEASE_BUFFERS && 837 if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
895 SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER) 838 SSL_version(s) != DTLS1_VERSION &&
839 SSL_version(s) != DTLS1_BAD_VER)
896 ssl3_release_write_buffer(s); 840 ssl3_release_write_buffer(s);
897 s->rwstate=SSL_NOTHING; 841 s->rwstate = SSL_NOTHING;
898 return(s->s3->wpend_ret); 842 return (s->s3->wpend_ret);
899 } 843 } else if (i <= 0) {
900 else if (i <= 0) {
901 if (s->version == DTLS1_VERSION || 844 if (s->version == DTLS1_VERSION ||
902 s->version == DTLS1_BAD_VER) { 845 s->version == DTLS1_BAD_VER) {
903 /* For DTLS, just drop it. That's kind of the whole 846 /* For DTLS, just drop it. That's kind of the whole
904 point in using a datagram service */ 847 point in using a datagram service */
905 wb->left = 0; 848 wb->left = 0;
906 } 849 }
907 return(i); 850 return (i);
908 }
909 wb->offset+=i;
910 wb->left-=i;
911 } 851 }
852 wb->offset += i;
853 wb->left -= i;
912 } 854 }
855}
913 856
914/* Return up to 'len' payload bytes received in 'type' records. 857/* Return up to 'len' payload bytes received in 'type' records.
915 * 'type' is one of the following: 858 * 'type' is one of the following:
@@ -938,39 +881,40 @@ int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
938 * Application data protocol 881 * Application data protocol
939 * none of our business 882 * none of our business
940 */ 883 */
941int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek) 884int
942 { 885ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
943 int al,i,j,ret; 886{
887 int al, i, j, ret;
944 unsigned int n; 888 unsigned int n;
945 SSL3_RECORD *rr; 889 SSL3_RECORD *rr;
946 void (*cb)(const SSL *ssl,int type2,int val)=NULL; 890 void (*cb)(const SSL *ssl, int type2, int val) = NULL;
947 891
948 if (s->s3->rbuf.buf == NULL) /* Not initialized yet */ 892 if (s->s3->rbuf.buf == NULL) /* Not initialized yet */
949 if (!ssl3_setup_read_buffer(s)) 893 if (!ssl3_setup_read_buffer(s))
950 return(-1); 894 return (-1);
951 895
952 if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE) && type) || 896 if ((type && (type != SSL3_RT_APPLICATION_DATA) &&
953 (peek && (type != SSL3_RT_APPLICATION_DATA))) 897 (type != SSL3_RT_HANDSHAKE) && type) ||
954 { 898 (peek && (type != SSL3_RT_APPLICATION_DATA))) {
955 SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR); 899 SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
956 return -1; 900 return -1;
957 } 901 }
958 902
959 if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0)) 903 if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0))
960 /* (partially) satisfy request from storage */ 904 /* (partially) satisfy request from storage */
961 { 905 {
962 unsigned char *src = s->s3->handshake_fragment; 906 unsigned char *src = s->s3->handshake_fragment;
963 unsigned char *dst = buf; 907 unsigned char *dst = buf;
964 unsigned int k; 908 unsigned int k;
965 909
966 /* peek == 0 */ 910 /* peek == 0 */
967 n = 0; 911 n = 0;
968 while ((len > 0) && (s->s3->handshake_fragment_len > 0)) 912 while ((len > 0) && (s->s3->handshake_fragment_len > 0)) {
969 {
970 *dst++ = *src++; 913 *dst++ = *src++;
971 len--; s->s3->handshake_fragment_len--; 914 len--;
915 s->s3->handshake_fragment_len--;
972 n++; 916 n++;
973 } 917 }
974 /* move any remaining fragment bytes: */ 918 /* move any remaining fragment bytes: */
975 for (k = 0; k < s->s3->handshake_fragment_len; k++) 919 for (k = 0; k < s->s3->handshake_fragment_len; k++)
976 s->s3->handshake_fragment[k] = *src++; 920 s->s3->handshake_fragment[k] = *src++;
@@ -979,19 +923,18 @@ int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
979 923
980 /* Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */ 924 /* Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */
981 925
982 if (!s->in_handshake && SSL_in_init(s)) 926 if (!s->in_handshake && SSL_in_init(s)) {
983 {
984 /* type == SSL3_RT_APPLICATION_DATA */ 927 /* type == SSL3_RT_APPLICATION_DATA */
985 i=s->handshake_func(s); 928 i = s->handshake_func(s);
986 if (i < 0) return(i); 929 if (i < 0)
987 if (i == 0) 930 return (i);
988 { 931 if (i == 0) {
989 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); 932 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
990 return(-1); 933 return (-1);
991 }
992 } 934 }
935 }
993start: 936start:
994 s->rwstate=SSL_NOTHING; 937 s->rwstate = SSL_NOTHING;
995 938
996 /* s->s3->rrec.type - is the type of record 939 /* s->s3->rrec.type - is the type of record
997 * s->s3->rrec.data, - data 940 * s->s3->rrec.data, - data
@@ -1000,67 +943,63 @@ start:
1000 rr = &(s->s3->rrec); 943 rr = &(s->s3->rrec);
1001 944
1002 /* get new packet if necessary */ 945 /* get new packet if necessary */
1003 if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) 946 if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) {
1004 { 947 ret = ssl3_get_record(s);
1005 ret=ssl3_get_record(s); 948 if (ret <= 0)
1006 if (ret <= 0) return(ret); 949 return (ret);
1007 } 950 }
1008 951
1009 /* we now have a packet which can be read and processed */ 952 /* we now have a packet which can be read and processed */
1010 953
1011 if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec, 954 if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
1012 * reset by ssl3_get_finished */ 955 * reset by ssl3_get_finished */
1013 && (rr->type != SSL3_RT_HANDSHAKE)) 956 && (rr->type != SSL3_RT_HANDSHAKE)) {
1014 { 957 al = SSL_AD_UNEXPECTED_MESSAGE;
1015 al=SSL_AD_UNEXPECTED_MESSAGE; 958 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
1016 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
1017 goto f_err; 959 goto f_err;
1018 } 960 }
1019 961
1020 /* If the other end has shut down, throw anything we read away 962 /* If the other end has shut down, throw anything we read away
1021 * (even in 'peek' mode) */ 963 * (even in 'peek' mode) */
1022 if (s->shutdown & SSL_RECEIVED_SHUTDOWN) 964 if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1023 { 965 rr->length = 0;
1024 rr->length=0; 966 s->rwstate = SSL_NOTHING;
1025 s->rwstate=SSL_NOTHING; 967 return (0);
1026 return(0); 968 }
1027 }
1028 969
1029 970
1030 if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */ 971 if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */
1031 { 972 {
1032 /* make sure that we are not getting application data when we 973 /* make sure that we are not getting application data when we
1033 * are doing a handshake for the first time */ 974 * are doing a handshake for the first time */
1034 if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && 975 if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
1035 (s->enc_read_ctx == NULL)) 976 (s->enc_read_ctx == NULL)) {
1036 { 977 al = SSL_AD_UNEXPECTED_MESSAGE;
1037 al=SSL_AD_UNEXPECTED_MESSAGE; 978 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE);
1038 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE);
1039 goto f_err; 979 goto f_err;
1040 } 980 }
1041 981
1042 if (len <= 0) return(len); 982 if (len <= 0)
983 return (len);
1043 984
1044 if ((unsigned int)len > rr->length) 985 if ((unsigned int)len > rr->length)
1045 n = rr->length; 986 n = rr->length;
1046 else 987 else
1047 n = (unsigned int)len; 988 n = (unsigned int)len;
1048 989
1049 memcpy(buf,&(rr->data[rr->off]),n); 990 memcpy(buf, &(rr->data[rr->off]), n);
1050 if (!peek) 991 if (!peek) {
1051 { 992 rr->length -= n;
1052 rr->length-=n; 993 rr->off += n;
1053 rr->off+=n; 994 if (rr->length == 0) {
1054 if (rr->length == 0) 995 s->rstate = SSL_ST_READ_HEADER;
1055 { 996 rr->off = 0;
1056 s->rstate=SSL_ST_READ_HEADER;
1057 rr->off=0;
1058 if (s->mode & SSL_MODE_RELEASE_BUFFERS) 997 if (s->mode & SSL_MODE_RELEASE_BUFFERS)
1059 ssl3_release_read_buffer(s); 998 ssl3_release_read_buffer(s);
1060 }
1061 } 999 }
1062 return(n);
1063 } 1000 }
1001 return (n);
1002 }
1064 1003
1065 1004
1066 /* If we get here, then type != rr->type; if we have a handshake 1005 /* If we get here, then type != rr->type; if we have a handshake
@@ -1069,137 +1008,122 @@ start:
1069 /* In case of record types for which we have 'fragment' storage, 1008 /* In case of record types for which we have 'fragment' storage,
1070 * fill that so that we can process the data at a fixed place. 1009 * fill that so that we can process the data at a fixed place.
1071 */ 1010 */
1072 { 1011 {
1073 unsigned int dest_maxlen = 0; 1012 unsigned int dest_maxlen = 0;
1074 unsigned char *dest = NULL; 1013 unsigned char *dest = NULL;
1075 unsigned int *dest_len = NULL; 1014 unsigned int *dest_len = NULL;
1076 1015
1077 if (rr->type == SSL3_RT_HANDSHAKE) 1016 if (rr->type == SSL3_RT_HANDSHAKE) {
1078 {
1079 dest_maxlen = sizeof s->s3->handshake_fragment; 1017 dest_maxlen = sizeof s->s3->handshake_fragment;
1080 dest = s->s3->handshake_fragment; 1018 dest = s->s3->handshake_fragment;
1081 dest_len = &s->s3->handshake_fragment_len; 1019 dest_len = &s->s3->handshake_fragment_len;
1082 } 1020 } else if (rr->type == SSL3_RT_ALERT) {
1083 else if (rr->type == SSL3_RT_ALERT)
1084 {
1085 dest_maxlen = sizeof s->s3->alert_fragment; 1021 dest_maxlen = sizeof s->s3->alert_fragment;
1086 dest = s->s3->alert_fragment; 1022 dest = s->s3->alert_fragment;
1087 dest_len = &s->s3->alert_fragment_len; 1023 dest_len = &s->s3->alert_fragment_len;
1088 } 1024 }
1089#ifndef OPENSSL_NO_HEARTBEATS 1025#ifndef OPENSSL_NO_HEARTBEATS
1090 else if (rr->type == TLS1_RT_HEARTBEAT) 1026 else if (rr->type == TLS1_RT_HEARTBEAT) {
1091 {
1092 tls1_process_heartbeat(s); 1027 tls1_process_heartbeat(s);
1093 1028
1094 /* Exit and notify application to read again */ 1029 /* Exit and notify application to read again */
1095 rr->length = 0; 1030 rr->length = 0;
1096 s->rwstate=SSL_READING; 1031 s->rwstate = SSL_READING;
1097 BIO_clear_retry_flags(SSL_get_rbio(s)); 1032 BIO_clear_retry_flags(SSL_get_rbio(s));
1098 BIO_set_retry_read(SSL_get_rbio(s)); 1033 BIO_set_retry_read(SSL_get_rbio(s));
1099 return(-1); 1034 return (-1);
1100 } 1035 }
1101#endif 1036#endif
1102 1037
1103 if (dest_maxlen > 0) 1038 if (dest_maxlen > 0) {
1104 {
1105 n = dest_maxlen - *dest_len; /* available space in 'dest' */ 1039 n = dest_maxlen - *dest_len; /* available space in 'dest' */
1106 if (rr->length < n) 1040 if (rr->length < n)
1107 n = rr->length; /* available bytes */ 1041 n = rr->length; /* available bytes */
1108 1042
1109 /* now move 'n' bytes: */ 1043 /* now move 'n' bytes: */
1110 while (n-- > 0) 1044 while (n-- > 0) {
1111 {
1112 dest[(*dest_len)++] = rr->data[rr->off++]; 1045 dest[(*dest_len)++] = rr->data[rr->off++];
1113 rr->length--; 1046 rr->length--;
1114 } 1047 }
1115 1048
1116 if (*dest_len < dest_maxlen) 1049 if (*dest_len < dest_maxlen)
1117 goto start; /* fragment was too small */ 1050 goto start; /* fragment was too small */
1118 }
1119 } 1051 }
1052 }
1120 1053
1121 /* s->s3->handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE; 1054 /* s->s3->handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE;
1122 * s->s3->alert_fragment_len == 2 iff rr->type == SSL3_RT_ALERT. 1055 * s->s3->alert_fragment_len == 2 iff rr->type == SSL3_RT_ALERT.
1123 * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */ 1056 * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */
1124 1057
1125 /* If we are a client, check for an incoming 'Hello Request': */ 1058 /* If we are a client, check for an incoming 'Hello Request': */
1126 if ((!s->server) && 1059 if ((!s->server) && (s->s3->handshake_fragment_len >= 4) &&
1127 (s->s3->handshake_fragment_len >= 4) && 1060 (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
1128 (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) && 1061 (s->session != NULL) && (s->session->cipher != NULL)) {
1129 (s->session != NULL) && (s->session->cipher != NULL))
1130 {
1131 s->s3->handshake_fragment_len = 0; 1062 s->s3->handshake_fragment_len = 0;
1132 1063
1133 if ((s->s3->handshake_fragment[1] != 0) || 1064 if ((s->s3->handshake_fragment[1] != 0) ||
1134 (s->s3->handshake_fragment[2] != 0) || 1065 (s->s3->handshake_fragment[2] != 0) ||
1135 (s->s3->handshake_fragment[3] != 0)) 1066 (s->s3->handshake_fragment[3] != 0)) {
1136 { 1067 al = SSL_AD_DECODE_ERROR;
1137 al=SSL_AD_DECODE_ERROR; 1068 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_HELLO_REQUEST);
1138 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_HELLO_REQUEST);
1139 goto f_err; 1069 goto f_err;
1140 } 1070 }
1141 1071
1142 if (s->msg_callback) 1072 if (s->msg_callback)
1143 s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->s3->handshake_fragment, 4, s, s->msg_callback_arg); 1073 s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->s3->handshake_fragment, 4, s, s->msg_callback_arg);
1144 1074
1145 if (SSL_is_init_finished(s) && 1075 if (SSL_is_init_finished(s) &&
1146 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && 1076 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
1147 !s->s3->renegotiate) 1077 !s->s3->renegotiate) {
1148 {
1149 ssl3_renegotiate(s); 1078 ssl3_renegotiate(s);
1150 if (ssl3_renegotiate_check(s)) 1079 if (ssl3_renegotiate_check(s)) {
1151 { 1080 i = s->handshake_func(s);
1152 i=s->handshake_func(s); 1081 if (i < 0)
1153 if (i < 0) return(i); 1082 return (i);
1154 if (i == 0) 1083 if (i == 0) {
1155 { 1084 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
1156 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); 1085 return (-1);
1157 return(-1); 1086 }
1158 }
1159 1087
1160 if (!(s->mode & SSL_MODE_AUTO_RETRY)) 1088 if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1161 {
1162 if (s->s3->rbuf.left == 0) /* no read-ahead left? */ 1089 if (s->s3->rbuf.left == 0) /* no read-ahead left? */
1163 { 1090 {
1164 BIO *bio; 1091 BIO *bio;
1165 /* In the case where we try to read application data, 1092 /* In the case where we try to read application data,
1166 * but we trigger an SSL handshake, we return -1 with 1093 * but we trigger an SSL handshake, we return -1 with
1167 * the retry option set. Otherwise renegotiation may 1094 * the retry option set. Otherwise renegotiation may
1168 * cause nasty problems in the blocking world */ 1095 * cause nasty problems in the blocking world */
1169 s->rwstate=SSL_READING; 1096 s->rwstate = SSL_READING;
1170 bio=SSL_get_rbio(s); 1097 bio = SSL_get_rbio(s);
1171 BIO_clear_retry_flags(bio); 1098 BIO_clear_retry_flags(bio);
1172 BIO_set_retry_read(bio); 1099 BIO_set_retry_read(bio);
1173 return(-1); 1100 return (-1);
1174 }
1175 } 1101 }
1176 } 1102 }
1177 } 1103 }
1104 }
1178 /* we either finished a handshake or ignored the request, 1105 /* we either finished a handshake or ignored the request,
1179 * now try again to obtain the (application) data we were asked for */ 1106 * now try again to obtain the (application) data we were asked for */
1180 goto start; 1107 goto start;
1181 } 1108 }
1182 /* If we are a server and get a client hello when renegotiation isn't 1109 /* If we are a server and get a client hello when renegotiation isn't
1183 * allowed send back a no renegotiation alert and carry on. 1110 * allowed send back a no renegotiation alert and carry on.
1184 * WARNING: experimental code, needs reviewing (steve) 1111 * WARNING: experimental code, needs reviewing (steve)
1185 */ 1112 */
1186 if (s->server && 1113 if (s->server &&
1187 SSL_is_init_finished(s) && 1114 SSL_is_init_finished(s) &&
1188 !s->s3->send_connection_binding && 1115 !s->s3->send_connection_binding &&
1189 (s->version > SSL3_VERSION) && 1116 (s->version > SSL3_VERSION) &&
1190 (s->s3->handshake_fragment_len >= 4) && 1117 (s->s3->handshake_fragment_len >= 4) &&
1191 (s->s3->handshake_fragment[0] == SSL3_MT_CLIENT_HELLO) && 1118 (s->s3->handshake_fragment[0] == SSL3_MT_CLIENT_HELLO) &&
1192 (s->session != NULL) && (s->session->cipher != NULL) && 1119 (s->session != NULL) && (s->session->cipher != NULL) &&
1193 !(s->ctx->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) 1120 !(s->ctx->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
1194
1195 {
1196 /*s->s3->handshake_fragment_len = 0;*/ 1121 /*s->s3->handshake_fragment_len = 0;*/
1197 rr->length = 0; 1122 rr->length = 0;
1198 ssl3_send_alert(s,SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); 1123 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
1199 goto start; 1124 goto start;
1200 } 1125 }
1201 if (s->s3->alert_fragment_len >= 2) 1126 if (s->s3->alert_fragment_len >= 2) {
1202 {
1203 int alert_level = s->s3->alert_fragment[0]; 1127 int alert_level = s->s3->alert_fragment[0];
1204 int alert_descr = s->s3->alert_fragment[1]; 1128 int alert_descr = s->s3->alert_fragment[1];
1205 1129
@@ -1209,24 +1133,22 @@ start:
1209 s->msg_callback(0, s->version, SSL3_RT_ALERT, s->s3->alert_fragment, 2, s, s->msg_callback_arg); 1133 s->msg_callback(0, s->version, SSL3_RT_ALERT, s->s3->alert_fragment, 2, s, s->msg_callback_arg);
1210 1134
1211 if (s->info_callback != NULL) 1135 if (s->info_callback != NULL)
1212 cb=s->info_callback; 1136 cb = s->info_callback;
1213 else if (s->ctx->info_callback != NULL) 1137 else if (s->ctx->info_callback != NULL)
1214 cb=s->ctx->info_callback; 1138 cb = s->ctx->info_callback;
1215 1139
1216 if (cb != NULL) 1140 if (cb != NULL) {
1217 {
1218 j = (alert_level << 8) | alert_descr; 1141 j = (alert_level << 8) | alert_descr;
1219 cb(s, SSL_CB_READ_ALERT, j); 1142 cb(s, SSL_CB_READ_ALERT, j);
1220 } 1143 }
1221 1144
1222 if (alert_level == 1) /* warning */ 1145 if (alert_level == 1) /* warning */
1223 { 1146 {
1224 s->s3->warn_alert = alert_descr; 1147 s->s3->warn_alert = alert_descr;
1225 if (alert_descr == SSL_AD_CLOSE_NOTIFY) 1148 if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
1226 {
1227 s->shutdown |= SSL_RECEIVED_SHUTDOWN; 1149 s->shutdown |= SSL_RECEIVED_SHUTDOWN;
1228 return(0); 1150 return (0);
1229 } 1151 }
1230 /* This is a warning but we receive it if we requested 1152 /* This is a warning but we receive it if we requested
1231 * renegotiation and the peer denied it. Terminate with 1153 * renegotiation and the peer denied it. Terminate with
1232 * a fatal alert because if application tried to 1154 * a fatal alert because if application tried to
@@ -1236,139 +1158,126 @@ start:
1236 * In future we might have a renegotiation where we 1158 * In future we might have a renegotiation where we
1237 * don't care if the peer refused it where we carry on. 1159 * don't care if the peer refused it where we carry on.
1238 */ 1160 */
1239 else if (alert_descr == SSL_AD_NO_RENEGOTIATION) 1161 else if (alert_descr == SSL_AD_NO_RENEGOTIATION) {
1240 {
1241 al = SSL_AD_HANDSHAKE_FAILURE; 1162 al = SSL_AD_HANDSHAKE_FAILURE;
1242 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_NO_RENEGOTIATION); 1163 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_NO_RENEGOTIATION);
1243 goto f_err; 1164 goto f_err;
1244 } 1165 }
1245#ifdef SSL_AD_MISSING_SRP_USERNAME 1166#ifdef SSL_AD_MISSING_SRP_USERNAME
1246 else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME) 1167 else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME)
1247 return(0); 1168 return (0);
1248#endif 1169#endif
1249 } 1170 } else if (alert_level == 2) /* fatal */
1250 else if (alert_level == 2) /* fatal */ 1171 {
1251 {
1252 char tmp[16]; 1172 char tmp[16];
1253 1173
1254 s->rwstate=SSL_NOTHING; 1174 s->rwstate = SSL_NOTHING;
1255 s->s3->fatal_alert = alert_descr; 1175 s->s3->fatal_alert = alert_descr;
1256 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr); 1176 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
1257 BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr); 1177 BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);
1258 ERR_add_error_data(2,"SSL alert number ",tmp); 1178 ERR_add_error_data(2, "SSL alert number ", tmp);
1259 s->shutdown|=SSL_RECEIVED_SHUTDOWN; 1179 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
1260 SSL_CTX_remove_session(s->ctx,s->session); 1180 SSL_CTX_remove_session(s->ctx, s->session);
1261 return(0); 1181 return (0);
1262 } 1182 } else {
1263 else 1183 al = SSL_AD_ILLEGAL_PARAMETER;
1264 { 1184 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);
1265 al=SSL_AD_ILLEGAL_PARAMETER;
1266 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
1267 goto f_err; 1185 goto f_err;
1268 } 1186 }
1269 1187
1270 goto start; 1188 goto start;
1271 } 1189 }
1272 1190
1273 if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */ 1191 if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */
1274 { 1192 {
1275 s->rwstate=SSL_NOTHING; 1193 s->rwstate = SSL_NOTHING;
1276 rr->length=0; 1194 rr->length = 0;
1277 return(0); 1195 return (0);
1278 } 1196 }
1279 1197
1280 if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) 1198 if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
1281 {
1282 /* 'Change Cipher Spec' is just a single byte, so we know 1199 /* 'Change Cipher Spec' is just a single byte, so we know
1283 * exactly what the record payload has to look like */ 1200 * exactly what the record payload has to look like */
1284 if ( (rr->length != 1) || (rr->off != 0) || 1201 if ((rr->length != 1) || (rr->off != 0) ||
1285 (rr->data[0] != SSL3_MT_CCS)) 1202 (rr->data[0] != SSL3_MT_CCS)) {
1286 { 1203 al = SSL_AD_ILLEGAL_PARAMETER;
1287 al=SSL_AD_ILLEGAL_PARAMETER; 1204 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_CHANGE_CIPHER_SPEC);
1288 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
1289 goto f_err; 1205 goto f_err;
1290 } 1206 }
1291 1207
1292 /* Check we have a cipher to change to */ 1208 /* Check we have a cipher to change to */
1293 if (s->s3->tmp.new_cipher == NULL) 1209 if (s->s3->tmp.new_cipher == NULL) {
1294 { 1210 al = SSL_AD_UNEXPECTED_MESSAGE;
1295 al=SSL_AD_UNEXPECTED_MESSAGE; 1211 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_CCS_RECEIVED_EARLY);
1296 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_CCS_RECEIVED_EARLY);
1297 goto f_err; 1212 goto f_err;
1298 } 1213 }
1299 1214
1300 rr->length=0; 1215 rr->length = 0;
1301 1216
1302 if (s->msg_callback) 1217 if (s->msg_callback)
1303 s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, rr->data, 1, s, s->msg_callback_arg); 1218 s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, rr->data, 1, s, s->msg_callback_arg);
1304 1219
1305 s->s3->change_cipher_spec=1; 1220 s->s3->change_cipher_spec = 1;
1306 if (!ssl3_do_change_cipher_spec(s)) 1221 if (!ssl3_do_change_cipher_spec(s))
1307 goto err; 1222 goto err;
1308 else 1223 else
1309 goto start; 1224 goto start;
1310 } 1225 }
1311 1226
1312 /* Unexpected handshake message (Client Hello, or protocol violation) */ 1227 /* Unexpected handshake message (Client Hello, or protocol violation) */
1313 if ((s->s3->handshake_fragment_len >= 4) && !s->in_handshake) 1228 if ((s->s3->handshake_fragment_len >= 4) && !s->in_handshake) {
1314 {
1315 if (((s->state&SSL_ST_MASK) == SSL_ST_OK) && 1229 if (((s->state&SSL_ST_MASK) == SSL_ST_OK) &&
1316 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) 1230 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) {
1317 {
1318#if 0 /* worked only because C operator preferences are not as expected (and 1231#if 0 /* worked only because C operator preferences are not as expected (and
1319 * because this is not really needed for clients except for detecting 1232 * because this is not really needed for clients except for detecting
1320 * protocol violations): */ 1233 * protocol violations): */
1321 s->state=SSL_ST_BEFORE|(s->server) 1234 s->state = SSL_ST_BEFORE |
1322 ?SSL_ST_ACCEPT 1235 (s->server) ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1323 :SSL_ST_CONNECT;
1324#else 1236#else
1325 s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT; 1237 s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1326#endif 1238#endif
1327 s->renegotiate=1; 1239 s->renegotiate = 1;
1328 s->new_session=1; 1240 s->new_session = 1;
1329 } 1241 }
1330 i=s->handshake_func(s); 1242 i = s->handshake_func(s);
1331 if (i < 0) return(i); 1243 if (i < 0)
1332 if (i == 0) 1244 return (i);
1333 { 1245 if (i == 0) {
1334 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); 1246 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
1335 return(-1); 1247 return (-1);
1336 } 1248 }
1337 1249
1338 if (!(s->mode & SSL_MODE_AUTO_RETRY)) 1250 if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1339 {
1340 if (s->s3->rbuf.left == 0) /* no read-ahead left? */ 1251 if (s->s3->rbuf.left == 0) /* no read-ahead left? */
1341 { 1252 {
1342 BIO *bio; 1253 BIO *bio;
1343 /* In the case where we try to read application data, 1254 /* In the case where we try to read application data,
1344 * but we trigger an SSL handshake, we return -1 with 1255 * but we trigger an SSL handshake, we return -1 with
1345 * the retry option set. Otherwise renegotiation may 1256 * the retry option set. Otherwise renegotiation may
1346 * cause nasty problems in the blocking world */ 1257 * cause nasty problems in the blocking world */
1347 s->rwstate=SSL_READING; 1258 s->rwstate = SSL_READING;
1348 bio=SSL_get_rbio(s); 1259 bio = SSL_get_rbio(s);
1349 BIO_clear_retry_flags(bio); 1260 BIO_clear_retry_flags(bio);
1350 BIO_set_retry_read(bio); 1261 BIO_set_retry_read(bio);
1351 return(-1); 1262 return (-1);
1352 }
1353 } 1263 }
1354 goto start;
1355 } 1264 }
1265 goto start;
1266 }
1356 1267
1357 switch (rr->type) 1268 switch (rr->type) {
1358 {
1359 default: 1269 default:
1360#ifndef OPENSSL_NO_TLS 1270#ifndef OPENSSL_NO_TLS
1361 /* TLS up to v1.1 just ignores unknown message types: 1271 /* TLS up to v1.1 just ignores unknown message types:
1362 * TLS v1.2 give an unexpected message alert. 1272 * TLS v1.2 give an unexpected message alert.
1363 */ 1273 */
1364 if (s->version >= TLS1_VERSION && s->version <= TLS1_1_VERSION) 1274 if (s->version >= TLS1_VERSION && s->version <= TLS1_1_VERSION) {
1365 {
1366 rr->length = 0; 1275 rr->length = 0;
1367 goto start; 1276 goto start;
1368 } 1277 }
1369#endif 1278#endif
1370 al=SSL_AD_UNEXPECTED_MESSAGE; 1279 al = SSL_AD_UNEXPECTED_MESSAGE;
1371 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD); 1280 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1372 goto f_err; 1281 goto f_err;
1373 case SSL3_RT_CHANGE_CIPHER_SPEC: 1282 case SSL3_RT_CHANGE_CIPHER_SPEC:
1374 case SSL3_RT_ALERT: 1283 case SSL3_RT_ALERT:
@@ -1376,8 +1285,8 @@ start:
1376 /* we already handled all of these, with the possible exception 1285 /* we already handled all of these, with the possible exception
1377 * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that 1286 * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that
1378 * should not happen when type != rr->type */ 1287 * should not happen when type != rr->type */
1379 al=SSL_AD_UNEXPECTED_MESSAGE; 1288 al = SSL_AD_UNEXPECTED_MESSAGE;
1380 SSLerr(SSL_F_SSL3_READ_BYTES,ERR_R_INTERNAL_ERROR); 1289 SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
1381 goto f_err; 1290 goto f_err;
1382 case SSL3_RT_APPLICATION_DATA: 1291 case SSL3_RT_APPLICATION_DATA:
1383 /* At this point, we were expecting handshake data, 1292 /* At this point, we were expecting handshake data,
@@ -1388,123 +1297,116 @@ start:
1388 * we will indulge it. 1297 * we will indulge it.
1389 */ 1298 */
1390 if (s->s3->in_read_app_data && 1299 if (s->s3->in_read_app_data &&
1391 (s->s3->total_renegotiations != 0) && 1300 (s->s3->total_renegotiations != 0) &&
1392 (( 1301 ((
1393 (s->state & SSL_ST_CONNECT) && 1302 (s->state & SSL_ST_CONNECT) &&
1394 (s->state >= SSL3_ST_CW_CLNT_HELLO_A) && 1303 (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
1395 (s->state <= SSL3_ST_CR_SRVR_HELLO_A) 1304 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1396 ) || ( 1305 ) || (
1397 (s->state & SSL_ST_ACCEPT) && 1306 (s->state & SSL_ST_ACCEPT) &&
1398 (s->state <= SSL3_ST_SW_HELLO_REQ_A) && 1307 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1399 (s->state >= SSL3_ST_SR_CLNT_HELLO_A) 1308 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1400 ) 1309 )
1401 )) 1310 )) {
1402 { 1311 s->s3->in_read_app_data = 2;
1403 s->s3->in_read_app_data=2; 1312 return (-1);
1404 return(-1); 1313 } else {
1405 } 1314 al = SSL_AD_UNEXPECTED_MESSAGE;
1406 else 1315 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1407 {
1408 al=SSL_AD_UNEXPECTED_MESSAGE;
1409 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1410 goto f_err; 1316 goto f_err;
1411 }
1412 } 1317 }
1318 }
1413 /* not reached */ 1319 /* not reached */
1414 1320
1415f_err: 1321f_err:
1416 ssl3_send_alert(s,SSL3_AL_FATAL,al); 1322 ssl3_send_alert(s, SSL3_AL_FATAL, al);
1417err: 1323err:
1418 return(-1); 1324 return (-1);
1419 } 1325}
1420 1326
1421int ssl3_do_change_cipher_spec(SSL *s) 1327int
1422 { 1328ssl3_do_change_cipher_spec(SSL *s)
1329{
1423 int i; 1330 int i;
1424 const char *sender; 1331 const char *sender;
1425 int slen; 1332 int slen;
1426 1333
1427 if (s->state & SSL_ST_ACCEPT) 1334 if (s->state & SSL_ST_ACCEPT)
1428 i=SSL3_CHANGE_CIPHER_SERVER_READ; 1335 i = SSL3_CHANGE_CIPHER_SERVER_READ;
1429 else 1336 else
1430 i=SSL3_CHANGE_CIPHER_CLIENT_READ; 1337 i = SSL3_CHANGE_CIPHER_CLIENT_READ;
1431 1338
1432 if (s->s3->tmp.key_block == NULL) 1339 if (s->s3->tmp.key_block == NULL) {
1433 { 1340 if (s->session == NULL) {
1434 if (s->session == NULL)
1435 {
1436 /* might happen if dtls1_read_bytes() calls this */ 1341 /* might happen if dtls1_read_bytes() calls this */
1437 SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC,SSL_R_CCS_RECEIVED_EARLY); 1342 SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC, SSL_R_CCS_RECEIVED_EARLY);
1438 return (0); 1343 return (0);
1439 }
1440
1441 s->session->cipher=s->s3->tmp.new_cipher;
1442 if (!s->method->ssl3_enc->setup_key_block(s)) return(0);
1443 } 1344 }
1444 1345
1445 if (!s->method->ssl3_enc->change_cipher_state(s,i)) 1346 s->session->cipher = s->s3->tmp.new_cipher;
1446 return(0); 1347 if (!s->method->ssl3_enc->setup_key_block(s))
1348 return (0);
1349 }
1350
1351 if (!s->method->ssl3_enc->change_cipher_state(s, i))
1352 return (0);
1447 1353
1448 /* we have to record the message digest at 1354 /* we have to record the message digest at
1449 * this point so we can get it before we read 1355 * this point so we can get it before we read
1450 * the finished message */ 1356 * the finished message */
1451 if (s->state & SSL_ST_CONNECT) 1357 if (s->state & SSL_ST_CONNECT) {
1452 { 1358 sender = s->method->ssl3_enc->server_finished_label;
1453 sender=s->method->ssl3_enc->server_finished_label; 1359 slen = s->method->ssl3_enc->server_finished_label_len;
1454 slen=s->method->ssl3_enc->server_finished_label_len; 1360 } else {
1455 } 1361 sender = s->method->ssl3_enc->client_finished_label;
1456 else 1362 slen = s->method->ssl3_enc->client_finished_label_len;
1457 { 1363 }
1458 sender=s->method->ssl3_enc->client_finished_label;
1459 slen=s->method->ssl3_enc->client_finished_label_len;
1460 }
1461 1364
1462 i = s->method->ssl3_enc->final_finish_mac(s, 1365 i = s->method->ssl3_enc->final_finish_mac(s,
1463 sender,slen,s->s3->tmp.peer_finish_md); 1366 sender, slen, s->s3->tmp.peer_finish_md);
1464 if (i == 0) 1367 if (i == 0) {
1465 {
1466 SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR); 1368 SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
1467 return 0; 1369 return 0;
1468 } 1370 }
1469 s->s3->tmp.peer_finish_md_len = i; 1371 s->s3->tmp.peer_finish_md_len = i;
1470 1372
1471 return(1); 1373 return (1);
1472 } 1374}
1473 1375
1474int ssl3_send_alert(SSL *s, int level, int desc) 1376int
1475 { 1377ssl3_send_alert(SSL *s, int level, int desc)
1378{
1476 /* Map tls/ssl alert value to correct one */ 1379 /* Map tls/ssl alert value to correct one */
1477 desc=s->method->ssl3_enc->alert_value(desc); 1380 desc = s->method->ssl3_enc->alert_value(desc);
1478 if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION) 1381 if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION)
1479 desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have protocol_version alerts */ 1382 desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have protocol_version alerts */
1480 if (desc < 0) return -1; 1383 if (desc < 0)
1384 return -1;
1481 /* If a fatal one, remove from cache */ 1385 /* If a fatal one, remove from cache */
1482 if ((level == 2) && (s->session != NULL)) 1386 if ((level == 2) && (s->session != NULL))
1483 SSL_CTX_remove_session(s->ctx,s->session); 1387 SSL_CTX_remove_session(s->ctx, s->session);
1484 1388
1485 s->s3->alert_dispatch=1; 1389 s->s3->alert_dispatch = 1;
1486 s->s3->send_alert[0]=level; 1390 s->s3->send_alert[0] = level;
1487 s->s3->send_alert[1]=desc; 1391 s->s3->send_alert[1] = desc;
1488 if (s->s3->wbuf.left == 0) /* data still being written out? */ 1392 if (s->s3->wbuf.left == 0) /* data still being written out? */
1489 return s->method->ssl_dispatch_alert(s); 1393 return s->method->ssl_dispatch_alert(s);
1490 /* else data is still being written out, we will get written 1394 /* else data is still being written out, we will get written
1491 * some time in the future */ 1395 * some time in the future */
1492 return -1; 1396 return -1;
1493 } 1397}
1494 1398
1495int ssl3_dispatch_alert(SSL *s) 1399int
1496 { 1400ssl3_dispatch_alert(SSL *s)
1497 int i,j; 1401{
1498 void (*cb)(const SSL *ssl,int type,int val)=NULL; 1402 int i, j;
1403 void (*cb)(const SSL *ssl, int type, int val) = NULL;
1499 1404
1500 s->s3->alert_dispatch=0; 1405 s->s3->alert_dispatch = 0;
1501 i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0); 1406 i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0);
1502 if (i <= 0) 1407 if (i <= 0) {
1503 { 1408 s->s3->alert_dispatch = 1;
1504 s->s3->alert_dispatch=1; 1409 } else {
1505 }
1506 else
1507 {
1508 /* Alert sent to BIO. If it is important, flush it now. 1410 /* Alert sent to BIO. If it is important, flush it now.
1509 * If the message does not get sent due to non-blocking IO, 1411 * If the message does not get sent due to non-blocking IO,
1510 * we will not worry too much. */ 1412 * we will not worry too much. */
@@ -1515,15 +1417,14 @@ int ssl3_dispatch_alert(SSL *s)
1515 s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, 2, s, s->msg_callback_arg); 1417 s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, 2, s, s->msg_callback_arg);
1516 1418
1517 if (s->info_callback != NULL) 1419 if (s->info_callback != NULL)
1518 cb=s->info_callback; 1420 cb = s->info_callback;
1519 else if (s->ctx->info_callback != NULL) 1421 else if (s->ctx->info_callback != NULL)
1520 cb=s->ctx->info_callback; 1422 cb = s->ctx->info_callback;
1521 1423
1522 if (cb != NULL) 1424 if (cb != NULL) {
1523 { 1425 j = (s->s3->send_alert[0]<<8)|s->s3->send_alert[1];
1524 j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1]; 1426 cb(s, SSL_CB_WRITE_ALERT, j);
1525 cb(s,SSL_CB_WRITE_ALERT,j);
1526 }
1527 } 1427 }
1528 return(i);
1529 } 1428 }
1429 return (i);
1430}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-10-05 04:46:13 +0000