1dd8c2be22c7c7ab0d507e297ceaaeb24e01dcc2
[openssl.git] / demos / state_machine / state_machine.c
1 /* ====================================================================
2  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in
13  *    the documentation and/or other materials provided with the
14  *    distribution.
15  *
16  * 3. All advertising materials mentioning features or use of this
17  *    software must display the following acknowledgment:
18  *    "This product includes software developed by the OpenSSL Project
19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
20  *
21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22  *    endorse or promote products derived from this software without
23  *    prior written permission. For written permission, please contact
24  *    openssl-core@openssl.org.
25  *
26  * 5. Products derived from this software may not be called "OpenSSL"
27  *    nor may "OpenSSL" appear in their names without prior written
28  *    permission of the OpenSSL Project.
29  *
30  * 6. Redistributions of any form whatsoever must retain the following
31  *    acknowledgment:
32  *    "This product includes software developed by the OpenSSL Project
33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
34  *
35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46  * OF THE POSSIBILITY OF SUCH DAMAGE.
47  * ====================================================================
48  *
49  * This product includes cryptographic software written by Eric Young
50  * (eay@cryptsoft.com).  This product includes software written by Tim
51  * Hudson (tjh@cryptsoft.com).
52  *
53  */
54
55 /*
56  * Nuron, a leader in hardware encryption technology, generously
57  * sponsored the development of this demo by Ben Laurie.
58  *
59  * See http://www.nuron.com/.
60  */
61
62 /*
63  * the aim of this demo is to provide a fully working state-machine
64  * style SSL implementation, i.e. one where the main loop acquires
65  * some data, then converts it from or to SSL by feeding it into the
66  * SSL state machine. It then does any I/O required by the state machine
67  * and loops.
68  *
69  * In order to keep things as simple as possible, this implementation
70  * listens on a TCP socket, which it expects to get an SSL connection
71  * on (for example, from s_client) and from then on writes decrypted
72  * data to stdout and encrypts anything arriving on stdin. Verbose
73  * commentary is written to stderr.
74  *
75  * This implementation acts as a server, but it can also be done for a client.  */
76
77 #include <openssl/ssl.h>
78 #include <assert.h>
79 #include <unistd.h>
80 #include <string.h>
81 #include <openssl/err.h>
82 #include <sys/types.h>
83 #include <sys/socket.h>
84 #include <netinet/in.h>
85
86 /*
87  * die_unless is intended to work like assert, except that it happens always,
88  * even if NDEBUG is defined. Use assert as a stopgap.
89  */
90
91 #define die_unless(x)   assert(x)
92
93 typedef struct {
94     SSL_CTX *pCtx;
95     BIO *pbioRead;
96     BIO *pbioWrite;
97     SSL *pSSL;
98 } SSLStateMachine;
99
100 void SSLStateMachine_print_error(SSLStateMachine * pMachine,
101                                  const char *szErr)
102 {
103     unsigned long l;
104
105     fprintf(stderr, "%s\n", szErr);
106     while ((l = ERR_get_error())) {
107         char buf[1024];
108
109         ERR_error_string_n(l, buf, sizeof buf);
110         fprintf(stderr, "Error %lx: %s\n", l, buf);
111     }
112 }
113
114 SSLStateMachine *SSLStateMachine_new(const char *szCertificateFile,
115                                      const char *szKeyFile)
116 {
117     SSLStateMachine *pMachine = malloc(sizeof(*pMachine));
118     int n;
119
120     die_unless(pMachine);
121
122     pMachine->pCtx = SSL_CTX_new(SSLv23_server_method());
123     die_unless(pMachine->pCtx);
124
125     n = SSL_CTX_use_certificate_file(pMachine->pCtx, szCertificateFile,
126                                      SSL_FILETYPE_PEM);
127     die_unless(n > 0);
128
129     n = SSL_CTX_use_PrivateKey_file(pMachine->pCtx, szKeyFile,
130                                     SSL_FILETYPE_PEM);
131     die_unless(n > 0);
132
133     pMachine->pSSL = SSL_new(pMachine->pCtx);
134     die_unless(pMachine->pSSL);
135
136     pMachine->pbioRead = BIO_new(BIO_s_mem());
137
138     pMachine->pbioWrite = BIO_new(BIO_s_mem());
139
140     SSL_set_bio(pMachine->pSSL, pMachine->pbioRead, pMachine->pbioWrite);
141
142     SSL_set_accept_state(pMachine->pSSL);
143
144     return pMachine;
145 }
146
147 void SSLStateMachine_read_inject(SSLStateMachine * pMachine,
148                                  const unsigned char *aucBuf, int nBuf)
149 {
150     int n = BIO_write(pMachine->pbioRead, aucBuf, nBuf);
151     /*
152      * If it turns out this assert fails, then buffer the data here and just
153      * feed it in in churn instead. Seems to me that it should be guaranteed
154      * to succeed, though.
155      */
156     assert(n == nBuf);
157     fprintf(stderr, "%d bytes of encrypted data fed to state machine\n", n);
158 }
159
160 int SSLStateMachine_read_extract(SSLStateMachine * pMachine,
161                                  unsigned char *aucBuf, int nBuf)
162 {
163     int n;
164
165     if (!SSL_is_init_finished(pMachine->pSSL)) {
166         fprintf(stderr, "Doing SSL_accept\n");
167         n = SSL_accept(pMachine->pSSL);
168         if (n == 0)
169             fprintf(stderr, "SSL_accept returned zero\n");
170         if (n < 0) {
171             int err;
172
173             if ((err =
174                  SSL_get_error(pMachine->pSSL, n)) == SSL_ERROR_WANT_READ) {
175                 fprintf(stderr, "SSL_accept wants more data\n");
176                 return 0;
177             }
178
179             SSLStateMachine_print_error(pMachine, "SSL_accept error");
180             exit(7);
181         }
182         return 0;
183     }
184
185     n = SSL_read(pMachine->pSSL, aucBuf, nBuf);
186     if (n < 0) {
187         int err = SSL_get_error(pMachine->pSSL, n);
188
189         if (err == SSL_ERROR_WANT_READ) {
190             fprintf(stderr, "SSL_read wants more data\n");
191             return 0;
192         }
193
194         SSLStateMachine_print_error(pMachine, "SSL_read error");
195         exit(8);
196     }
197
198     fprintf(stderr, "%d bytes of decrypted data read from state machine\n",
199             n);
200     return n;
201 }
202
203 int SSLStateMachine_write_can_extract(SSLStateMachine * pMachine)
204 {
205     int n = BIO_pending(pMachine->pbioWrite);
206     if (n)
207         fprintf(stderr, "There is encrypted data available to write\n");
208     else
209         fprintf(stderr, "There is no encrypted data available to write\n");
210
211     return n;
212 }
213
214 int SSLStateMachine_write_extract(SSLStateMachine * pMachine,
215                                   unsigned char *aucBuf, int nBuf)
216 {
217     int n;
218
219     n = BIO_read(pMachine->pbioWrite, aucBuf, nBuf);
220     fprintf(stderr, "%d bytes of encrypted data read from state machine\n",
221             n);
222     return n;
223 }
224
225 void SSLStateMachine_write_inject(SSLStateMachine * pMachine,
226                                   const unsigned char *aucBuf, int nBuf)
227 {
228     int n = SSL_write(pMachine->pSSL, aucBuf, nBuf);
229     /*
230      * If it turns out this assert fails, then buffer the data here and just
231      * feed it in in churn instead. Seems to me that it should be guaranteed
232      * to succeed, though.
233      */
234     assert(n == nBuf);
235     fprintf(stderr, "%d bytes of unencrypted data fed to state machine\n", n);
236 }
237
238 int OpenSocket(int nPort)
239 {
240     int nSocket;
241     struct sockaddr_in saServer;
242     struct sockaddr_in saClient;
243     int one = 1;
244     int nSize;
245     int nFD;
246     int nLen;
247
248     nSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
249     if (nSocket < 0) {
250         perror("socket");
251         exit(1);
252     }
253
254     if (setsockopt
255         (nSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof one) < 0) {
256         perror("setsockopt");
257         exit(2);
258     }
259
260     memset(&saServer, 0, sizeof(saServer));
261     saServer.sin_family = AF_INET;
262     saServer.sin_port = htons(nPort);
263     nSize = sizeof saServer;
264     if (bind(nSocket, (struct sockaddr *)&saServer, nSize) < 0) {
265         perror("bind");
266         exit(3);
267     }
268
269     if (listen(nSocket, 512) < 0) {
270         perror("listen");
271         exit(4);
272     }
273
274     nLen = sizeof saClient;
275     nFD = accept(nSocket, (struct sockaddr *)&saClient, &nLen);
276     if (nFD < 0) {
277         perror("accept");
278         exit(5);
279     }
280
281     fprintf(stderr, "Incoming accepted on port %d\n", nPort);
282
283     return nFD;
284 }
285
286 int main(int argc, char **argv)
287 {
288     SSLStateMachine *pMachine;
289     int nPort;
290     int nFD;
291     const char *szCertificateFile;
292     const char *szKeyFile;
293     char rbuf[1];
294     int nrbuf = 0;
295
296     if (argc != 4) {
297         fprintf(stderr, "%s <port> <certificate file> <key file>\n", argv[0]);
298         exit(6);
299     }
300
301     nPort = atoi(argv[1]);
302     szCertificateFile = argv[2];
303     szKeyFile = argv[3];
304
305     OpenSSL_add_ssl_algorithms();
306     SSL_load_error_strings();
307
308     nFD = OpenSocket(nPort);
309
310     pMachine = SSLStateMachine_new(szCertificateFile, szKeyFile);
311
312     for (;;) {
313         fd_set rfds, wfds;
314         unsigned char buf[1024];
315         int n;
316
317         FD_ZERO(&rfds);
318         FD_ZERO(&wfds);
319
320         /* Select socket for input */
321         FD_SET(nFD, &rfds);
322
323         /* check whether there's decrypted data */
324         if (!nrbuf)
325             nrbuf = SSLStateMachine_read_extract(pMachine, rbuf, 1);
326
327         /* if there's decrypted data, check whether we can write it */
328         if (nrbuf)
329             FD_SET(1, &wfds);
330
331         /* Select socket for output */
332         if (SSLStateMachine_write_can_extract(pMachine))
333             FD_SET(nFD, &wfds);
334
335         /* Select stdin for input */
336         FD_SET(0, &rfds);
337
338         /* Wait for something to do something */
339         n = select(nFD + 1, &rfds, &wfds, NULL, NULL);
340         assert(n > 0);
341
342         /* Socket is ready for input */
343         if (FD_ISSET(nFD, &rfds)) {
344             n = read(nFD, buf, sizeof buf);
345             if (n == 0) {
346                 fprintf(stderr, "Got EOF on socket\n");
347                 exit(0);
348             }
349             assert(n > 0);
350
351             SSLStateMachine_read_inject(pMachine, buf, n);
352         }
353
354         /* stdout is ready for output (and hence we have some to send it) */
355         if (FD_ISSET(1, &wfds)) {
356             assert(nrbuf == 1);
357             buf[0] = rbuf[0];
358             nrbuf = 0;
359
360             n = SSLStateMachine_read_extract(pMachine, buf + 1,
361                                              sizeof buf - 1);
362             if (n < 0) {
363                 SSLStateMachine_print_error(pMachine, "read extract failed");
364                 break;
365             }
366             assert(n >= 0);
367             ++n;
368             if (n > 0) {        /* FIXME: has to be true now */
369                 int w;
370
371                 w = write(1, buf, n);
372                 /* FIXME: we should push back any unwritten data */
373                 assert(w == n);
374             }
375         }
376
377         /*
378          * Socket is ready for output (and therefore we have output to send)
379          */
380         if (FD_ISSET(nFD, &wfds)) {
381             int w;
382
383             n = SSLStateMachine_write_extract(pMachine, buf, sizeof buf);
384             assert(n > 0);
385
386             w = write(nFD, buf, n);
387             /* FIXME: we should push back any unwritten data */
388             assert(w == n);
389         }
390
391         /* Stdin is ready for input */
392         if (FD_ISSET(0, &rfds)) {
393             n = read(0, buf, sizeof buf);
394             if (n == 0) {
395                 fprintf(stderr, "Got EOF on stdin\n");
396                 exit(0);
397             }
398             assert(n > 0);
399
400             SSLStateMachine_write_inject(pMachine, buf, n);
401         }
402     }
403     /* not reached */
404     return 0;
405 }