reindented code
[gnutls:gnutls.git] / src / ocsptool-common.c
1 /*
2  * Copyright (C) 2012 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuTLS.
5  *
6  * GnuTLS is free software: you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuTLS is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see
18  * <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include <gnutls/gnutls.h>
29 #include <gnutls/ocsp.h>
30 #include <gnutls/x509.h>
31 #include <gnutls/crypto.h>
32
33 /* Gnulib portability files. */
34 #include <read-file.h>
35 #include <socket.h>
36
37 #include <ocsptool-common.h>
38
39 #define MAX_BUF 4*1024
40 #define HEADER_PATTERN "POST / HTTP/1.1\r\n" \
41   "Host: %s\r\n" \
42   "Accept: */*\r\n" \
43   "Content-Type: application/ocsp-request\r\n" \
44   "Content-Length: %u\r\n" \
45   "Connection: close\r\n\r\n"
46 static char buffer[MAX_BUF + 1];
47
48 /* returns the host part of a URL */
49 static const char *host_from_url(const char *url, unsigned int *port)
50 {
51         static char hostname[512];
52         char *p;
53
54         *port = 0;
55
56         if ((p = strstr(url, "http://")) != NULL) {
57                 snprintf(hostname, sizeof(hostname), "%s", p + 7);
58                 p = strchr(hostname, '/');
59                 if (p != NULL)
60                         *p = 0;
61
62                 p = strchr(hostname, ':');
63                 if (p != NULL) {
64                         *p = 0;
65                         *port = atoi(p + 1);
66                 }
67
68                 return hostname;
69         } else {
70                 return url;
71         }
72 }
73
74 void
75 _generate_request(gnutls_x509_crt_t cert, gnutls_x509_crt_t issuer,
76                   gnutls_datum_t * rdata, int nonce)
77 {
78         gnutls_ocsp_req_t req;
79         int ret;
80
81         ret = gnutls_ocsp_req_init(&req);
82         if (ret < 0) {
83                 fprintf(stderr, "ocsp_req_init: %s", gnutls_strerror(ret));
84                 exit(1);
85         }
86
87         ret = gnutls_ocsp_req_add_cert(req, GNUTLS_DIG_SHA1, issuer, cert);
88         if (ret < 0) {
89                 fprintf(stderr, "ocsp_req_add_cert: %s",
90                         gnutls_strerror(ret));
91                 exit(1);
92         }
93
94         if (nonce) {
95                 unsigned char noncebuf[23];
96                 gnutls_datum_t nonce = { noncebuf, sizeof(noncebuf) };
97
98                 ret =
99                     gnutls_rnd(GNUTLS_RND_RANDOM, nonce.data, nonce.size);
100                 if (ret < 0) {
101                         fprintf(stderr, "gnutls_rnd: %s",
102                                 gnutls_strerror(ret));
103                         exit(1);
104                 }
105
106                 ret = gnutls_ocsp_req_set_nonce(req, 0, &nonce);
107                 if (ret < 0) {
108                         fprintf(stderr, "ocsp_req_set_nonce: %s",
109                                 gnutls_strerror(ret));
110                         exit(1);
111                 }
112         }
113
114         ret = gnutls_ocsp_req_export(req, rdata);
115         if (ret != 0) {
116                 fprintf(stderr, "ocsp_req_export: %s",
117                         gnutls_strerror(ret));
118                 exit(1);
119         }
120
121         gnutls_ocsp_req_deinit(req);
122         return;
123 }
124
125 static size_t get_data(void *buffer, size_t size, size_t nmemb,
126                        void *userp)
127 {
128         gnutls_datum_t *ud = userp;
129
130         size *= nmemb;
131
132         ud->data = realloc(ud->data, size + ud->size);
133         if (ud->data == NULL) {
134                 fprintf(stderr, "Not enough memory for the request\n");
135                 exit(1);
136         }
137
138         memcpy(&ud->data[ud->size], buffer, size);
139         ud->size += size;
140
141         return size;
142 }
143
144 /* Returns 0 on ok, and -1 on error */
145 int send_ocsp_request(const char *server,
146                       gnutls_x509_crt_t cert, gnutls_x509_crt_t issuer,
147                       gnutls_datum_t * resp_data, int nonce)
148 {
149         gnutls_datum_t ud;
150         int ret;
151         gnutls_datum_t req;
152         char *url = (void *) server;
153         char headers[1024];
154         char service[16];
155         unsigned char *p;
156         const char *hostname;
157         unsigned int headers_size = 0, port;
158         socket_st hd;
159
160         sockets_init();
161
162         if (url == NULL) {
163                 /* try to read URL from issuer certificate */
164                 gnutls_datum_t data;
165
166                 ret = gnutls_x509_crt_get_authority_info_access(cert, 0,
167                                                                 GNUTLS_IA_OCSP_URI,
168                                                                 &data,
169                                                                 NULL);
170
171                 if (ret < 0)
172                         ret =
173                             gnutls_x509_crt_get_authority_info_access
174                             (issuer, 0, GNUTLS_IA_OCSP_URI, &data, NULL);
175                 if (ret < 0) {
176                         fprintf(stderr,
177                                 "Cannot find URL from issuer: %s\n",
178                                 gnutls_strerror(ret));
179                         return -1;
180                 }
181
182                 url = malloc(data.size + 1);
183                 memcpy(url, data.data, data.size);
184                 url[data.size] = 0;
185
186                 gnutls_free(data.data);
187         }
188
189         hostname = host_from_url(url, &port);
190         if (port != 0)
191                 snprintf(service, sizeof(service), "%u", port);
192         else
193                 strcpy(service, "80");
194
195         fprintf(stderr, "Connecting to OCSP server: %s...\n", hostname);
196
197         memset(&ud, 0, sizeof(ud));
198
199         _generate_request(cert, issuer, &req, nonce);
200
201         snprintf(headers, sizeof(headers), HEADER_PATTERN, hostname,
202                  (unsigned int) req.size);
203         headers_size = strlen(headers);
204
205         socket_open(&hd, hostname, service, 0);
206
207         socket_send(&hd, headers, headers_size);
208         socket_send(&hd, req.data, req.size);
209
210         do {
211                 ret = socket_recv(&hd, buffer, sizeof(buffer));
212                 if (ret > 0)
213                         get_data(buffer, ret, 1, &ud);
214         } while (ret > 0);
215
216         if (ret < 0 || ud.size == 0) {
217                 perror("recv");
218                 return -1;
219         }
220
221         socket_bye(&hd);
222
223         p = memmem(ud.data, ud.size, "\r\n\r\n", 4);
224         if (p == NULL) {
225                 fprintf(stderr, "Cannot interpret HTTP response\n");
226                 return -1;
227         }
228
229         p += 4;
230         resp_data->size = ud.size - (p - ud.data);
231         resp_data->data = malloc(resp_data->size);
232         if (resp_data->data == NULL)
233                 return -1;
234
235         memcpy(resp_data->data, p, resp_data->size);
236
237         free(ud.data);
238
239         return 0;
240 }
241
242 void print_ocsp_verify_res(unsigned int output)
243 {
244         int comma = 0;
245
246         if (output) {
247                 printf("Failure");
248                 comma = 1;
249         } else {
250                 printf("Success");
251                 comma = 1;
252         }
253
254         if (output & GNUTLS_OCSP_VERIFY_SIGNER_NOT_FOUND) {
255                 if (comma)
256                         printf(", ");
257                 printf("Signer cert not found");
258                 comma = 1;
259         }
260
261         if (output & GNUTLS_OCSP_VERIFY_SIGNER_KEYUSAGE_ERROR) {
262                 if (comma)
263                         printf(", ");
264                 printf("Signer cert keyusage error");
265                 comma = 1;
266         }
267
268         if (output & GNUTLS_OCSP_VERIFY_UNTRUSTED_SIGNER) {
269                 if (comma)
270                         printf(", ");
271                 printf("Signer cert is not trusted");
272                 comma = 1;
273         }
274
275         if (output & GNUTLS_OCSP_VERIFY_INSECURE_ALGORITHM) {
276                 if (comma)
277                         printf(", ");
278                 printf("Insecure algorithm");
279                 comma = 1;
280         }
281
282         if (output & GNUTLS_OCSP_VERIFY_SIGNATURE_FAILURE) {
283                 if (comma)
284                         printf(", ");
285                 printf("Signature failure");
286                 comma = 1;
287         }
288
289         if (output & GNUTLS_OCSP_VERIFY_CERT_NOT_ACTIVATED) {
290                 if (comma)
291                         printf(", ");
292                 printf("Signer cert not yet activated");
293                 comma = 1;
294         }
295
296         if (output & GNUTLS_OCSP_VERIFY_CERT_EXPIRED) {
297                 if (comma)
298                         printf(", ");
299                 printf("Signer cert expired");
300                 comma = 1;
301         }
302 }
303
304 /* three days */
305 #define OCSP_VALIDITY_SECS (3*60*60*24)
306
307 /* Returns:
308  *  0: certificate is revoked
309  *  1: certificate is ok
310  *  -1: dunno
311  */
312 int
313 check_ocsp_response(gnutls_x509_crt_t cert,
314                     gnutls_x509_crt_t issuer, gnutls_datum_t * data)
315 {
316         gnutls_ocsp_resp_t resp;
317         int ret;
318         unsigned int status, cert_status;
319         time_t rtime, vtime, ntime, now;
320
321         now = time(0);
322
323         ret = gnutls_ocsp_resp_init(&resp);
324         if (ret < 0) {
325                 fprintf(stderr, "ocsp_resp_init: %s",
326                         gnutls_strerror(ret));
327                 exit(1);
328         }
329
330         ret = gnutls_ocsp_resp_import(resp, data);
331         if (ret < 0) {
332                 fprintf(stderr, "importing response: %s",
333                         gnutls_strerror(ret));
334                 exit(1);
335         }
336
337         ret = gnutls_ocsp_resp_check_crt(resp, 0, cert);
338         if (ret < 0) {
339                 printf
340                     ("*** Got OCSP response on an unrelated certificate (ignoring)\n");
341                 ret = -1;
342                 goto cleanup;
343         }
344
345         ret = gnutls_ocsp_resp_verify_direct(resp, issuer, &status, 0);
346         if (ret < 0) {
347                 fprintf(stderr, "gnutls_ocsp_resp_verify_direct: %s",
348                         gnutls_strerror(ret));
349                 exit(1);
350         }
351
352         if (status != 0) {
353                 printf("*** Verifying OCSP Response: ");
354                 print_ocsp_verify_res(status);
355                 printf(".\n");
356         }
357
358         /* do not print revocation data if response was not verified */
359         if (status != 0) {
360                 ret = -1;
361                 goto cleanup;
362         }
363
364         ret = gnutls_ocsp_resp_get_single(resp, 0, NULL, NULL, NULL, NULL,
365                                           &cert_status, &vtime, &ntime,
366                                           &rtime, NULL);
367         if (ret < 0) {
368                 fprintf(stderr, "reading response: %s",
369                         gnutls_strerror(ret));
370                 exit(1);
371         }
372
373         if (cert_status == GNUTLS_OCSP_CERT_REVOKED) {
374                 printf("*** Certificate was revoked at %s", ctime(&rtime));
375                 ret = 0;
376                 goto cleanup;
377         }
378
379         if (ntime == -1) {
380                 if (now - vtime > OCSP_VALIDITY_SECS) {
381                         printf
382                             ("*** The OCSP response is old (was issued at: %s) ignoring",
383                              ctime(&vtime));
384                         ret = -1;
385                         goto cleanup;
386                 }
387         } else {
388                 /* there is a newer OCSP answer, don't trust this one */
389                 if (ntime < now) {
390                         printf
391                             ("*** The OCSP response was issued at: %s, but there is a newer issue at %s",
392                              ctime(&vtime), ctime(&ntime));
393                         ret = -1;
394                         goto cleanup;
395                 }
396         }
397
398         printf("- OCSP server flags certificate not revoked as of %s",
399                ctime(&vtime));
400         ret = 1;
401       cleanup:
402         gnutls_ocsp_resp_deinit(resp);
403
404         return ret;
405 }