bac35f8de156eea5a2e24fc2edf082c9b36c9cee
[openssl.git] / crypto / ocsp / ocsp_ht.c
1 /* ocsp_ht.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project 2006.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <ctype.h>
62 #include <string.h>
63 #include "e_os.h"
64 #include <openssl/asn1.h>
65 #include <openssl/ocsp.h>
66 #include <openssl/err.h>
67 #include <openssl/buffer.h>
68 #ifdef OPENSSL_SYS_SUNOS
69 #define strtoul (unsigned long)strtol
70 #endif /* OPENSSL_SYS_SUNOS */
71
72 /* Stateful OCSP request code, supporting non-blocking I/O */
73
74 /* Opaque OCSP request status structure */
75
76 struct ocsp_req_ctx_st {
77         int state;              /* Current I/O state */
78         unsigned char *iobuf;   /* Line buffer */
79         int iobuflen;           /* Line buffer length */
80         BIO *io;                /* BIO to perform I/O with */
81         BIO *mem;               /* Memory BIO response is built into */
82         unsigned long asn1_len; /* ASN1 length of response */
83         unsigned long max_resp_len; /* Maximum length of response */
84         };
85
86 #define OCSP_MAX_RESP_LENGTH    (100 * 1024)
87 #define OCSP_MAX_LINE_LEN       4096;
88
89 /* OCSP states */
90
91 /* If set no reading should be performed */
92 #define OHS_NOREAD              0x1000
93 /* Error condition */
94 #define OHS_ERROR               (0 | OHS_NOREAD)
95 /* First line being read */
96 #define OHS_FIRSTLINE           1
97 /* MIME headers being read */
98 #define OHS_HEADERS             2
99 /* OCSP initial header (tag + length) being read */
100 #define OHS_ASN1_HEADER         3
101 /* OCSP content octets being read */
102 #define OHS_ASN1_CONTENT        4
103 /* First call: ready to start I/O */
104 #define OHS_ASN1_WRITE_INIT     (5 | OHS_NOREAD)
105 /* Request being sent */
106 #define OHS_ASN1_WRITE          (6 | OHS_NOREAD)
107 /* Request being flushed */
108 #define OHS_ASN1_FLUSH          (7 | OHS_NOREAD)
109 /* Completed */
110 #define OHS_DONE                (8 | OHS_NOREAD)
111 /* Headers set, no final \r\n included */
112 #define OHS_HTTP_HEADER         (9 | OHS_NOREAD)
113
114
115 static int parse_http_line1(char *line);
116
117 OCSP_REQ_CTX *OCSP_REQ_CTX_new(BIO *io, int maxline)
118         {
119         OCSP_REQ_CTX *rctx;
120         rctx = OPENSSL_malloc(sizeof(OCSP_REQ_CTX));
121         if (!rctx)
122                 return NULL;
123         rctx->state = OHS_ERROR;
124         rctx->max_resp_len = OCSP_MAX_RESP_LENGTH;
125         rctx->mem = BIO_new(BIO_s_mem());
126         rctx->io = io;
127         rctx->asn1_len = 0;
128         if (maxline > 0)
129                 rctx->iobuflen = maxline;
130         else
131                 rctx->iobuflen = OCSP_MAX_LINE_LEN;
132         rctx->iobuf = OPENSSL_malloc(rctx->iobuflen);
133         if (!rctx->iobuf || !rctx->mem)
134                 {
135                 OCSP_REQ_CTX_free(rctx);
136                 return NULL;
137                 }
138         return rctx;
139         }
140
141 void OCSP_REQ_CTX_free(OCSP_REQ_CTX *rctx)
142         {
143         if (rctx->mem)
144                 BIO_free(rctx->mem);
145         if (rctx->iobuf)
146                 OPENSSL_free(rctx->iobuf);
147         OPENSSL_free(rctx);
148         }
149
150 BIO *OCSP_REQ_CTX_get0_mem_bio(OCSP_REQ_CTX *rctx)
151         {
152         return rctx->mem;
153         }
154
155 void OCSP_set_max_response_length(OCSP_REQ_CTX *rctx, unsigned long len)
156         {
157         if (len == 0)
158                 rctx->max_resp_len = OCSP_MAX_RESP_LENGTH;
159         else
160                 rctx->max_resp_len = len;
161         }
162
163 int OCSP_REQ_CTX_i2d(OCSP_REQ_CTX *rctx, const ASN1_ITEM *it, ASN1_VALUE *val)
164         {
165         static const char req_hdr[] =
166                         "Content-Type: application/ocsp-request\r\n"
167                         "Content-Length: %d\r\n\r\n";
168         int reqlen = ASN1_item_i2d(val, NULL, it);
169         if (BIO_printf(rctx->mem, req_hdr, reqlen) <= 0)
170                 return 0;
171         if (ASN1_item_i2d_bio(it, rctx->mem, val) <= 0)
172                 return 0;
173         rctx->state = OHS_ASN1_WRITE_INIT;
174         return 1;
175         }
176
177 int OCSP_REQ_CTX_nbio_d2i(OCSP_REQ_CTX *rctx,
178                                         ASN1_VALUE **pval, const ASN1_ITEM *it)
179         {
180         int rv, len;
181         const unsigned char *p;
182
183         rv = OCSP_REQ_CTX_nbio(rctx);
184         if (rv != 1)
185                 return rv;
186
187         len = BIO_get_mem_data(rctx->mem, &p);
188         *pval = ASN1_item_d2i(NULL, &p, len, it);
189         if (*pval == NULL)
190                 {
191                 rctx->state = OHS_ERROR;
192                 return 0;
193                 }
194         return 1;
195         }
196
197 int OCSP_REQ_CTX_http(OCSP_REQ_CTX *rctx, const char *op, const char *path)
198         {
199         static const char http_hdr[] = "%s %s HTTP/1.0\r\n";
200
201         if (!path)
202                 path = "/";
203
204         if (BIO_printf(rctx->mem, http_hdr, op, path) <= 0)
205                 return 0;
206         rctx->state = OHS_HTTP_HEADER;
207         return 1;
208         }
209
210 int OCSP_REQ_CTX_set1_req(OCSP_REQ_CTX *rctx, OCSP_REQUEST *req)
211         {
212         return OCSP_REQ_CTX_i2d(rctx, ASN1_ITEM_rptr(OCSP_REQUEST),
213                                                         (ASN1_VALUE *)req);
214         }
215
216 int OCSP_REQ_CTX_add1_header(OCSP_REQ_CTX *rctx,
217                 const char *name, const char *value)
218         {
219         if (!name)
220                 return 0;
221         if (BIO_puts(rctx->mem, name) <= 0)
222                 return 0;
223         if (value)
224                 {
225                 if (BIO_write(rctx->mem, ": ", 2) != 2)
226                         return 0;
227                 if (BIO_puts(rctx->mem, value) <= 0)
228                         return 0;
229                 }
230         if (BIO_write(rctx->mem, "\r\n", 2) != 2)
231                 return 0;
232         rctx->state = OHS_HTTP_HEADER;
233         return 1;
234         }
235
236 OCSP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path, OCSP_REQUEST *req,
237                                int maxline)
238         {
239
240         OCSP_REQ_CTX *rctx = NULL;
241         rctx = OCSP_REQ_CTX_new(io, maxline);
242         if (!rctx)
243                 return NULL;
244
245         if (!OCSP_REQ_CTX_http(rctx, "POST", path))
246                 goto err;
247
248         if (req && !OCSP_REQ_CTX_set1_req(rctx, req))
249                 goto err;
250
251         return rctx;
252         
253         err:
254         OCSP_REQ_CTX_free(rctx);
255         return NULL;
256         }
257
258 /* Parse the HTTP response. This will look like this:
259  * "HTTP/1.0 200 OK". We need to obtain the numeric code and
260  * (optional) informational message.
261  */
262
263 static int parse_http_line1(char *line)
264         {
265         int retcode;
266         char *p, *q, *r;
267         /* Skip to first white space (passed protocol info) */
268
269         for(p = line; *p && !isspace((unsigned char)*p); p++)
270                 continue;
271         if(!*p)
272                 {
273                 OCSPerr(OCSP_F_PARSE_HTTP_LINE1,
274                                         OCSP_R_SERVER_RESPONSE_PARSE_ERROR);
275                 return 0;
276                 }
277
278         /* Skip past white space to start of response code */
279         while(*p && isspace((unsigned char)*p))
280                 p++;
281
282         if(!*p)
283                 {
284                 OCSPerr(OCSP_F_PARSE_HTTP_LINE1,
285                                         OCSP_R_SERVER_RESPONSE_PARSE_ERROR);
286                 return 0;
287                 }
288
289         /* Find end of response code: first whitespace after start of code */
290         for(q = p; *q && !isspace((unsigned char)*q); q++)
291                 continue;
292
293         if(!*q)
294                 {
295                 OCSPerr(OCSP_F_PARSE_HTTP_LINE1,
296                                         OCSP_R_SERVER_RESPONSE_PARSE_ERROR);
297                 return 0;
298                 }
299
300         /* Set end of response code and start of message */ 
301         *q++ = 0;
302
303         /* Attempt to parse numeric code */
304         retcode = strtoul(p, &r, 10);
305
306         if(*r)
307                 return 0;
308
309         /* Skip over any leading white space in message */
310         while(*q && isspace((unsigned char)*q))
311                 q++;
312
313         if(*q)
314                 {
315                 /* Finally zap any trailing white space in message (include
316                  * CRLF) */
317
318                 /* We know q has a non white space character so this is OK */
319                 for(r = q + strlen(q) - 1; isspace((unsigned char)*r); r--)
320                         *r = 0;
321                 }
322         if(retcode != 200)
323                 {
324                 OCSPerr(OCSP_F_PARSE_HTTP_LINE1, OCSP_R_SERVER_RESPONSE_ERROR);
325                 if(!*q)
326                         ERR_add_error_data(2, "Code=", p);
327                 else
328                         ERR_add_error_data(4, "Code=", p, ",Reason=", q);
329                 return 0;
330                 }
331
332
333         return 1;
334
335         }
336
337 int OCSP_REQ_CTX_nbio(OCSP_REQ_CTX *rctx)
338         {
339         int i, n;
340         const unsigned char *p;
341         next_io:
342         if (!(rctx->state & OHS_NOREAD))
343                 {
344                 n = BIO_read(rctx->io, rctx->iobuf, rctx->iobuflen);
345
346                 if (n <= 0)
347                         {
348                         if (BIO_should_retry(rctx->io))
349                                 return -1;
350                         return 0;
351                         }
352
353                 /* Write data to memory BIO */
354
355                 if (BIO_write(rctx->mem, rctx->iobuf, n) != n)
356                         return 0;
357                 }
358
359         switch(rctx->state)
360                 {
361                 case OHS_HTTP_HEADER:
362                 /* Last operation was adding headers: need a final \r\n */
363                 if (BIO_write(rctx->mem, "\r\n", 2) != 2)
364                         {
365                         rctx->state = OHS_ERROR;
366                         return 0;
367                         }
368                 rctx->state = OHS_ASN1_WRITE_INIT;
369
370                 case OHS_ASN1_WRITE_INIT:
371                 rctx->asn1_len = BIO_get_mem_data(rctx->mem, NULL);
372                 rctx->state = OHS_ASN1_WRITE;
373
374                 case OHS_ASN1_WRITE:
375                 n = BIO_get_mem_data(rctx->mem, &p);
376
377                 i = BIO_write(rctx->io,
378                         p + (n - rctx->asn1_len), rctx->asn1_len);
379
380                 if (i <= 0)
381                         {
382                         if (BIO_should_retry(rctx->io))
383                                 return -1;
384                         rctx->state = OHS_ERROR;
385                         return 0;
386                         }
387
388                 rctx->asn1_len -= i;
389
390                 if (rctx->asn1_len > 0)
391                         goto next_io;
392
393                 rctx->state = OHS_ASN1_FLUSH;
394
395                 (void)BIO_reset(rctx->mem);
396
397                 case OHS_ASN1_FLUSH:
398
399                 i = BIO_flush(rctx->io);
400
401                 if (i > 0)
402                         {
403                         rctx->state = OHS_FIRSTLINE;
404                         goto next_io;
405                         }
406
407                 if (BIO_should_retry(rctx->io))
408                         return -1;
409
410                 rctx->state = OHS_ERROR;
411                 return 0;
412
413                 case OHS_ERROR:
414                 return 0;
415
416                 case OHS_FIRSTLINE:
417                 case OHS_HEADERS:
418
419                 /* Attempt to read a line in */
420
421                 next_line:
422                 /* Due to &%^*$" memory BIO behaviour with BIO_gets we
423                  * have to check there's a complete line in there before
424                  * calling BIO_gets or we'll just get a partial read.
425                  */
426                 n = BIO_get_mem_data(rctx->mem, &p);
427                 if ((n <= 0) || !memchr(p, '\n', n))
428                         {
429                         if (n >= rctx->iobuflen)
430                                 {
431                                 rctx->state = OHS_ERROR;
432                                 return 0;
433                                 }
434                         goto next_io;
435                         }
436                 n = BIO_gets(rctx->mem, (char *)rctx->iobuf, rctx->iobuflen);
437
438                 if (n <= 0)
439                         {
440                         if (BIO_should_retry(rctx->mem))
441                                 goto next_io;
442                         rctx->state = OHS_ERROR;
443                         return 0;
444                         }
445
446                 /* Don't allow excessive lines */
447                 if (n == rctx->iobuflen)
448                         {
449                         rctx->state = OHS_ERROR;
450                         return 0;
451                         }
452
453                 /* First line */
454                 if (rctx->state == OHS_FIRSTLINE)
455                         {
456                         if (parse_http_line1((char *)rctx->iobuf))
457                                 {
458                                 rctx->state = OHS_HEADERS;
459                                 goto next_line;
460                                 }
461                         else
462                                 {
463                                 rctx->state = OHS_ERROR;
464                                 return 0;
465                                 }
466                         }
467                 else
468                         {
469                         /* Look for blank line: end of headers */
470                         for (p = rctx->iobuf; *p; p++)
471                                 {
472                                 if ((*p != '\r') && (*p != '\n'))
473                                         break;
474                                 }
475                         if (*p)
476                                 goto next_line;
477
478                         rctx->state = OHS_ASN1_HEADER;
479
480                         }
481  
482                 /* Fall thru */
483
484
485                 case OHS_ASN1_HEADER:
486                 /* Now reading ASN1 header: can read at least 2 bytes which
487                  * is enough for ASN1 SEQUENCE header and either length field
488                  * or at least the length of the length field.
489                  */
490                 n = BIO_get_mem_data(rctx->mem, &p);
491                 if (n < 2)
492                         goto next_io;
493
494                 /* Check it is an ASN1 SEQUENCE */
495                 if (*p++ != (V_ASN1_SEQUENCE|V_ASN1_CONSTRUCTED))
496                         {
497                         rctx->state = OHS_ERROR;
498                         return 0;
499                         }
500
501                 /* Check out length field */
502                 if (*p & 0x80)
503                         {
504                         /* If MSB set on initial length octet we can now
505                          * always read 6 octets: make sure we have them.
506                          */
507                         if (n < 6)
508                                 goto next_io;
509                         n = *p & 0x7F;
510                         /* Not NDEF or excessive length */
511                         if (!n || (n > 4))
512                                 {
513                                 rctx->state = OHS_ERROR;
514                                 return 0;
515                                 }
516                         p++;
517                         rctx->asn1_len = 0;
518                         for (i = 0; i < n; i++)
519                                 {
520                                 rctx->asn1_len <<= 8;
521                                 rctx->asn1_len |= *p++;
522                                 }
523
524                         if (rctx->asn1_len > rctx->max_resp_len)
525                                 {
526                                 rctx->state = OHS_ERROR;
527                                 return 0;
528                                 }
529
530                         rctx->asn1_len += n + 2;
531                         }
532                 else
533                         rctx->asn1_len = *p + 2;
534
535                 rctx->state = OHS_ASN1_CONTENT;
536
537                 /* Fall thru */
538                 
539                 case OHS_ASN1_CONTENT:
540                 n = BIO_get_mem_data(rctx->mem, NULL);
541                 if (n < (int)rctx->asn1_len)
542                         goto next_io;
543
544                 rctx->state = OHS_DONE;
545                 return 1;
546
547                 break;
548
549                 case OHS_DONE:
550                 return 1;
551
552                 }
553
554         return 0;
555
556         }
557
558 int OCSP_sendreq_nbio(OCSP_RESPONSE **presp, OCSP_REQ_CTX *rctx)
559         {
560         return OCSP_REQ_CTX_nbio_d2i(rctx,
561                         (ASN1_VALUE **)presp, ASN1_ITEM_rptr(OCSP_RESPONSE));
562         }
563
564 /* Blocking OCSP request handler: now a special case of non-blocking I/O */
565
566 OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req)
567         {
568         OCSP_RESPONSE *resp = NULL;
569         OCSP_REQ_CTX *ctx;
570         int rv;
571
572         ctx = OCSP_sendreq_new(b, path, req, -1);
573
574         if (!ctx)
575                 return NULL;
576
577         do
578                 {
579                 rv = OCSP_sendreq_nbio(&resp, ctx);
580                 } while ((rv == -1) && BIO_should_retry(b));
581
582         OCSP_REQ_CTX_free(ctx);
583
584         if (rv)
585                 return resp;
586
587         return NULL;
588         }