Add EVP test program.
[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 #ifdef OPENSSL_OPENBSD_DEV_CRYPTO
51
52 #include <fcntl.h>
53 #include <stdio.h>
54 #include <errno.h>
55 #include <sys/ioctl.h>
56 #include <crypto/cryptodev.h>
57 #include <unistd.h>
58 #include <openssl/evp.h>
59 #include <openssl/objects.h>
60 #include "evp_locl.h"
61 #include <assert.h>
62
63 /* longest key supported in hardware */
64 #define MAX_HW_KEY      24
65
66 static int fd;
67 static int dev_failed;
68
69 typedef struct session_op session_op;
70
71 #define data(ctx) EVP_C_DATA(session_op,ctx)
72
73 static void err(const char *str)
74     {
75     fprintf(stderr,"%s: errno %d\n",str,errno);
76     }
77
78 static int dev_crypto_init(EVP_CIPHER_CTX *ctx)
79     {
80     if(dev_failed)
81         return 0;
82     if(!fd)
83         {
84         int cryptodev_fd;
85
86         if ((cryptodev_fd=open("/dev/crypto",O_RDWR,0)) < 0)
87             {
88             err("/dev/crypto");
89             dev_failed=1;
90             return 0;
91             }
92         if (ioctl(cryptodev_fd,CRIOGET,&fd) == -1)
93             {
94             err("CRIOGET failed");
95             close(cryptodev_fd);
96             dev_failed=1;
97             return 0;
98             }
99         close(cryptodev_fd);
100         }
101     assert(data(ctx));
102     memset(data(ctx),'\0',sizeof *data(ctx));
103     data(ctx)->key=OPENSSL_malloc(MAX_HW_KEY);
104
105     return 1;
106     }
107
108 static int dev_crypto_cleanup(EVP_CIPHER_CTX *ctx)
109     {
110     if(ioctl(fd,CIOCFSESSION,&data(ctx)->ses) == -1)
111         err("CIOCFSESSION failed");
112
113     OPENSSL_free(data(ctx)->key);
114
115     return 1;
116     }
117
118 /* FIXME: there should be some non-fatal way to report we fell back to s/w? */
119 static int dev_crypto_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
120                                         const unsigned char *key,
121                                         const unsigned char *iv, int enc)
122     {
123     if(!dev_crypto_init(ctx))
124         {
125         /* fall back to using software... */
126         ctx->cipher=EVP_des_ede3_cbc();
127         return ctx->cipher->init(ctx,key,iv,enc);
128         }
129     memcpy(data(ctx)->key,key,24);
130     
131     data(ctx)->cipher=CRYPTO_3DES_CBC;
132     data(ctx)->mac=0;
133     data(ctx)->keylen=24;
134
135     if (ioctl(fd,CIOCGSESSION,data(ctx)) == -1)
136         {
137         err("CIOCGSESSION failed");
138         /* fall back to using software... */
139         dev_crypto_cleanup(ctx);
140         ctx->cipher=EVP_des_ede3_cbc();
141         return ctx->cipher->init(ctx,key,iv,enc);
142         }
143     return 1;
144     }
145
146 static int dev_crypto_des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, 
147                                           unsigned char *out,
148                                           const unsigned char *in,
149                                           unsigned int inl)
150     {
151     struct crypt_op cryp;
152     unsigned char lb[8];
153
154     assert(data(ctx));
155     assert(!dev_failed);
156
157     memset(&cryp,'\0',sizeof cryp);
158     cryp.ses=data(ctx)->ses;
159     cryp.op=ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
160     cryp.flags=0;
161 #if 0
162     cryp.len=((inl+7)/8)*8;
163 #endif
164     cryp.len=inl;
165     assert((inl&7) == 0);
166     cryp.src=(caddr_t)in;
167     cryp.dst=(caddr_t)out;
168     cryp.mac=0;
169     cryp.iv=(caddr_t)ctx->iv;
170
171     if(!ctx->encrypt)
172         memcpy(lb,&in[cryp.len-8],8);
173
174     if (ioctl(fd, CIOCCRYPT, &cryp) == -1)
175         {
176         err("CIOCCRYPT failed");
177         abort();
178         return 0;
179         }
180
181     if(ctx->encrypt)
182         memcpy(ctx->iv,&out[cryp.len-8],8);
183     else
184         memcpy(ctx->iv,lb,8);
185
186     return 1;
187     }
188
189 BLOCK_CIPHER_def_cbc(dev_crypto_des_ede3, session_op, NID_des_ede3, 8, 24, 8,
190                      0, dev_crypto_des_ede3_init_key,
191                      dev_crypto_cleanup, 
192                      EVP_CIPHER_set_asn1_iv,
193                      EVP_CIPHER_get_asn1_iv,
194                      NULL)
195 #else
196 static void *dummy=&dummy;
197 #endif