Dead code removal; #if 0 from crypto/des
[openssl.git] / crypto / evp / openbsd_hw.c
1 /* Written by Ben Laurie, 2001 */
2 /*
3  * Copyright (c) 2001 The OpenSSL Project.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in
14  *    the documentation and/or other materials provided with the
15  *    distribution.
16  *
17  * 3. All advertising materials mentioning features or use of this
18  *    software must display the following acknowledgment:
19  *    "This product includes software developed by the OpenSSL Project
20  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21  *
22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23  *    endorse or promote products derived from this software without
24  *    prior written permission. For written permission, please contact
25  *    openssl-core@openssl.org.
26  *
27  * 5. Products derived from this software may not be called "OpenSSL"
28  *    nor may "OpenSSL" appear in their names without prior written
29  *    permission of the OpenSSL Project.
30  *
31  * 6. Redistributions of any form whatsoever must retain the following
32  *    acknowledgment:
33  *    "This product includes software developed by the OpenSSL Project
34  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35  *
36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47  * OF THE POSSIBILITY OF SUCH DAMAGE.
48  */
49
50 #include <openssl/evp.h>
51 #include <openssl/objects.h>
52 #include <openssl/rsa.h>
53 #include "evp_locl.h"
54
55 /*
56  * This stuff should now all be supported through
57  * crypto/engine/hw_openbsd_dev_crypto.c unless I botched it up
58  */
59 static void *dummy = &dummy;
60
61 #if 0
62
63 /* check flag after OpenSSL headers to ensure make depend works */
64 # ifdef OPENSSL_OPENBSD_DEV_CRYPTO
65
66 #  include <fcntl.h>
67 #  include <stdio.h>
68 #  include <errno.h>
69 #  include <sys/ioctl.h>
70 #  include <crypto/cryptodev.h>
71 #  include <unistd.h>
72 #  include <assert.h>
73
74 /* longest key supported in hardware */
75 #  define MAX_HW_KEY      24
76 #  define MAX_HW_IV       8
77
78 #  define MD5_DIGEST_LENGTH       16
79 #  define MD5_CBLOCK              64
80
81 static int fd;
82 static int dev_failed;
83
84 typedef struct session_op session_op;
85
86 #  define CDATA(ctx) EVP_C_DATA(session_op,ctx)
87
88 static void err(const char *str)
89 {
90     fprintf(stderr, "%s: errno %d\n", str, errno);
91 }
92
93 static int dev_crypto_init(session_op *ses)
94 {
95     if (dev_failed)
96         return 0;
97     if (!fd) {
98         int cryptodev_fd;
99
100         if ((cryptodev_fd = open("/dev/crypto", O_RDWR, 0)) < 0) {
101             err("/dev/crypto");
102             dev_failed = 1;
103             return 0;
104         }
105         if (ioctl(cryptodev_fd, CRIOGET, &fd) == -1) {
106             err("CRIOGET failed");
107             close(cryptodev_fd);
108             dev_failed = 1;
109             return 0;
110         }
111         close(cryptodev_fd);
112     }
113     assert(ses);
114     memset(ses, '\0', sizeof *ses);
115
116     return 1;
117 }
118
119 static int dev_crypto_cleanup(EVP_CIPHER_CTX *ctx)
120 {
121     if (ioctl(fd, CIOCFSESSION, &CDATA(ctx)->ses) == -1)
122         err("CIOCFSESSION failed");
123
124     OPENSSL_free(CDATA(ctx)->key);
125
126     return 1;
127 }
128
129 static int dev_crypto_init_key(EVP_CIPHER_CTX *ctx, int cipher,
130                                const unsigned char *key, int klen)
131 {
132     if (!dev_crypto_init(CDATA(ctx)))
133         return 0;
134
135     CDATA(ctx)->key = OPENSSL_malloc(MAX_HW_KEY);
136     if (CDATA(ctx)->key == NULL)
137         return 0;
138
139     assert(ctx->cipher->iv_len <= MAX_HW_IV);
140
141     memcpy(CDATA(ctx)->key, key, klen);
142
143     CDATA(ctx)->cipher = cipher;
144     CDATA(ctx)->keylen = klen;
145
146     if (ioctl(fd, CIOCGSESSION, CDATA(ctx)) == -1) {
147         err("CIOCGSESSION failed");
148         return 0;
149     }
150     return 1;
151 }
152
153 static int dev_crypto_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
154                              const unsigned char *in, unsigned int inl)
155 {
156     struct crypt_op cryp;
157     unsigned char lb[MAX_HW_IV];
158
159     if (!inl)
160         return 1;
161
162     assert(CDATA(ctx));
163     assert(!dev_failed);
164
165     memset(&cryp, '\0', sizeof cryp);
166     cryp.ses = CDATA(ctx)->ses;
167     cryp.op = ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
168     cryp.flags = 0;
169     cryp.len = inl;
170     assert((inl & (ctx->cipher->block_size - 1)) == 0);
171     cryp.src = (caddr_t) in;
172     cryp.dst = (caddr_t) out;
173     cryp.mac = 0;
174     if (ctx->cipher->iv_len)
175         cryp.iv = (caddr_t) ctx->iv;
176
177     if (!ctx->encrypt)
178         memcpy(lb, &in[cryp.len - ctx->cipher->iv_len], ctx->cipher->iv_len);
179
180     if (ioctl(fd, CIOCCRYPT, &cryp) == -1) {
181         if (errno == EINVAL) {  /* buffers are misaligned */
182             unsigned int cinl = 0;
183             char *cin = NULL;
184             char *cout = NULL;
185
186             /* NB: this can only make cinl != inl with stream ciphers */
187             cinl = (inl + 3) / 4 * 4;
188
189             if (((unsigned long)in & 3) || cinl != inl) {
190                 cin = OPENSSL_malloc(cinl);
191                 if (cin == NULL)
192                     return 0;
193                 memcpy(cin, in, inl);
194                 cryp.src = cin;
195             }
196
197             if (((unsigned long)out & 3) || cinl != inl) {
198                 cout = OPENSSL_malloc(cinl);
199                 if (cout == NULL) {
200                     if (cin != NULL)
201                         OPENSSL_free(cin);
202                     return 0;
203                 }
204                 cryp.dst = cout;
205             }
206
207             cryp.len = cinl;
208
209             if (ioctl(fd, CIOCCRYPT, &cryp) == -1) {
210                 err("CIOCCRYPT(2) failed");
211                 printf("src=%p dst=%p\n", cryp.src, cryp.dst);
212                 abort();
213                 return 0;
214             }
215
216             if (cout) {
217                 memcpy(out, cout, inl);
218                 OPENSSL_free(cout);
219             }
220             if (cin)
221                 OPENSSL_free(cin);
222         } else {
223             err("CIOCCRYPT failed");
224             abort();
225             return 0;
226         }
227     }
228
229     if (ctx->encrypt)
230         memcpy(ctx->iv, &out[cryp.len - ctx->cipher->iv_len],
231                ctx->cipher->iv_len);
232     else
233         memcpy(ctx->iv, lb, ctx->cipher->iv_len);
234
235     return 1;
236 }
237
238 static int dev_crypto_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
239                                         const unsigned char *key,
240                                         const unsigned char *iv, int enc)
241 {
242     return dev_crypto_init_key(ctx, CRYPTO_3DES_CBC, key, 24);
243 }
244
245 #  define dev_crypto_des_ede3_cbc_cipher dev_crypto_cipher
246
247 BLOCK_CIPHER_def_cbc(dev_crypto_des_ede3, session_op, NID_des_ede3, 8, 24, 8,
248                      0, dev_crypto_des_ede3_init_key,
249                      dev_crypto_cleanup,
250                      EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, NULL)
251
252 static int dev_crypto_rc4_init_key(EVP_CIPHER_CTX *ctx,
253                                    const unsigned char *key,
254                                    const unsigned char *iv, int enc)
255 {
256     return dev_crypto_init_key(ctx, CRYPTO_ARC4, key, 16);
257 }
258
259 static const EVP_CIPHER r4_cipher = {
260     NID_rc4,
261     1, 16, 0,                   /* FIXME: key should be up to 256 bytes */
262     EVP_CIPH_VARIABLE_LENGTH,
263     dev_crypto_rc4_init_key,
264     dev_crypto_cipher,
265     dev_crypto_cleanup,
266     sizeof(session_op),
267     NULL,
268     NULL,
269     NULL
270 };
271
272 const EVP_CIPHER *EVP_dev_crypto_rc4(void)
273 {
274     return &r4_cipher;
275 }
276
277 typedef struct {
278     session_op sess;
279     char *data;
280     int len;
281     unsigned char md[EVP_MAX_MD_SIZE];
282 } MD_DATA;
283
284 static int dev_crypto_init_digest(MD_DATA *md_data, int mac)
285 {
286     if (!dev_crypto_init(&md_data->sess))
287         return 0;
288
289     md_data->len = 0;
290     md_data->data = NULL;
291
292     md_data->sess.mac = mac;
293
294     if (ioctl(fd, CIOCGSESSION, &md_data->sess) == -1) {
295         err("CIOCGSESSION failed");
296         return 0;
297     }
298     return 1;
299 }
300
301 static int dev_crypto_cleanup_digest(MD_DATA *md_data)
302 {
303     if (ioctl(fd, CIOCFSESSION, &md_data->sess.ses) == -1) {
304         err("CIOCFSESSION failed");
305         return 0;
306     }
307
308     return 1;
309 }
310
311 /* FIXME: if device can do chained MACs, then don't accumulate */
312 /* FIXME: move accumulation to the framework */
313 static int dev_crypto_md5_init(EVP_MD_CTX *ctx)
314 {
315     return dev_crypto_init_digest(ctx->md_data, CRYPTO_MD5);
316 }
317
318 static int do_digest(int ses, unsigned char *md, const void *data, int len)
319 {
320     struct crypt_op cryp;
321     static const unsigned char md5zero[16] = {
322         0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
323         0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e
324     };
325
326     /* some cards can't do zero length */
327     if (!len) {
328         memcpy(md, md5zero, 16);
329         return 1;
330     }
331
332     memset(&cryp, '\0', sizeof cryp);
333     cryp.ses = ses;
334     cryp.op = COP_ENCRYPT;      /* required to do the MAC rather than check
335                                  * it */
336     cryp.len = len;
337     cryp.src = (caddr_t) data;
338     cryp.dst = (caddr_t) data;  // FIXME!!!
339     cryp.mac = (caddr_t) md;
340
341     if (ioctl(fd, CIOCCRYPT, &cryp) == -1) {
342         if (errno == EINVAL) {  /* buffer is misaligned */
343             char *dcopy;
344
345             dcopy = OPENSSL_malloc(len);
346             memcpy(dcopy, data, len);
347             cryp.src = dcopy;
348             cryp.dst = cryp.src; // FIXME!!!
349
350             if (ioctl(fd, CIOCCRYPT, &cryp) == -1) {
351                 err("CIOCCRYPT(MAC2) failed");
352                 abort();
353                 return 0;
354             }
355             OPENSSL_free(dcopy);
356         } else {
357             err("CIOCCRYPT(MAC) failed");
358             abort();
359             return 0;
360         }
361     }
362     // printf("done\n");
363
364     return 1;
365 }
366
367 static int dev_crypto_md5_update(EVP_MD_CTX *ctx, const void *data,
368                                  unsigned long len)
369 {
370     MD_DATA *md_data = ctx->md_data;
371     char *tmp_md_data;
372
373     if (ctx->flags & EVP_MD_CTX_FLAG_ONESHOT)
374         return do_digest(md_data->sess.ses, md_data->md, data, len);
375
376     tmp_md_data = OPENSSL_realloc(md_data->data, md_data->len + len);
377     if (tmp_md_data == NULL)
378         return 0;
379     md_data->data = tmp_md_data;
380     memcpy(md_data->data + md_data->len, data, len);
381     md_data->len += len;
382
383     return 1;
384 }
385
386 static int dev_crypto_md5_final(EVP_MD_CTX *ctx, unsigned char *md)
387 {
388     int ret;
389     MD_DATA *md_data = ctx->md_data;
390
391     if (ctx->flags & EVP_MD_CTX_FLAG_ONESHOT) {
392         memcpy(md, md_data->md, MD5_DIGEST_LENGTH);
393         ret = 1;
394     } else {
395         ret = do_digest(md_data->sess.ses, md, md_data->data, md_data->len);
396         OPENSSL_free(md_data->data);
397         md_data->data = NULL;
398         md_data->len = 0;
399     }
400
401     return ret;
402 }
403
404 static int dev_crypto_md5_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
405 {
406     const MD_DATA *from_md = from->md_data;
407     MD_DATA *to_md = to->md_data;
408
409     // How do we copy sessions?
410     assert(from->digest->flags & EVP_MD_FLAG_ONESHOT);
411
412     to_md->data = OPENSSL_malloc(from_md->len);
413     if (to_md->data == NULL)
414         return 0;
415     memcpy(to_md->data, from_md->data, from_md->len);
416
417     return 1;
418 }
419
420 static int dev_crypto_md5_cleanup(EVP_MD_CTX *ctx)
421 {
422     return dev_crypto_cleanup_digest(ctx->md_data);
423 }
424
425 static const EVP_MD md5_md = {
426     NID_md5,
427     NID_md5WithRSAEncryption,
428     MD5_DIGEST_LENGTH,
429     EVP_MD_FLAG_ONESHOT,        // XXX: set according to device info...
430     dev_crypto_md5_init,
431     dev_crypto_md5_update,
432     dev_crypto_md5_final,
433     dev_crypto_md5_copy,
434     dev_crypto_md5_cleanup,
435     EVP_PKEY_RSA_method,
436     MD5_CBLOCK,
437     sizeof(MD_DATA),
438 };
439
440 const EVP_MD *EVP_dev_crypto_md5(void)
441 {
442     return &md5_md;
443 }
444
445 # endif
446 #endif