Don't use a ssl specific DRBG anymore
[openssl.git] / crypto / evp / e_des.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #ifndef OPENSSL_NO_DES
13 # include <openssl/evp.h>
14 # include <openssl/objects.h>
15 # include "internal/evp_int.h"
16 # include <openssl/des.h>
17 # include <openssl/rand.h>
18
19 typedef struct {
20     union {
21         double align;
22         DES_key_schedule ks;
23     } ks;
24     union {
25         void (*cbc) (const void *, void *, size_t,
26                      const DES_key_schedule *, unsigned char *);
27     } stream;
28 } EVP_DES_KEY;
29
30 # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
31 /* ----------^^^ this is not a typo, just a way to detect that
32  * assembler support was in general requested... */
33 #  include "sparc_arch.h"
34
35 extern unsigned int OPENSSL_sparcv9cap_P[];
36
37 #  define SPARC_DES_CAPABLE       (OPENSSL_sparcv9cap_P[1] & CFR_DES)
38
39 void des_t4_key_expand(const void *key, DES_key_schedule *ks);
40 void des_t4_cbc_encrypt(const void *inp, void *out, size_t len,
41                         const DES_key_schedule *ks, unsigned char iv[8]);
42 void des_t4_cbc_decrypt(const void *inp, void *out, size_t len,
43                         const DES_key_schedule *ks, unsigned char iv[8]);
44 # endif
45
46 static int des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
47                         const unsigned char *iv, int enc);
48 static int des_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr);
49
50 /*
51  * Because of various casts and different names can't use
52  * IMPLEMENT_BLOCK_CIPHER
53  */
54
55 static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
56                           const unsigned char *in, size_t inl)
57 {
58     BLOCK_CIPHER_ecb_loop()
59         DES_ecb_encrypt((DES_cblock *)(in + i), (DES_cblock *)(out + i),
60                         EVP_CIPHER_CTX_get_cipher_data(ctx),
61                         EVP_CIPHER_CTX_encrypting(ctx));
62     return 1;
63 }
64
65 static int des_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
66                           const unsigned char *in, size_t inl)
67 {
68     while (inl >= EVP_MAXCHUNK) {
69         int num = EVP_CIPHER_CTX_num(ctx);
70         DES_ofb64_encrypt(in, out, (long)EVP_MAXCHUNK,
71                           EVP_CIPHER_CTX_get_cipher_data(ctx),
72                           (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), &num);
73         EVP_CIPHER_CTX_set_num(ctx, num);
74         inl -= EVP_MAXCHUNK;
75         in += EVP_MAXCHUNK;
76         out += EVP_MAXCHUNK;
77     }
78     if (inl) {
79         int num = EVP_CIPHER_CTX_num(ctx);
80         DES_ofb64_encrypt(in, out, (long)inl,
81                           EVP_CIPHER_CTX_get_cipher_data(ctx),
82                           (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), &num);
83         EVP_CIPHER_CTX_set_num(ctx, num);
84     }
85     return 1;
86 }
87
88 static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
89                           const unsigned char *in, size_t inl)
90 {
91     EVP_DES_KEY *dat = (EVP_DES_KEY *) EVP_CIPHER_CTX_get_cipher_data(ctx);
92
93     if (dat->stream.cbc != NULL) {
94         (*dat->stream.cbc) (in, out, inl, &dat->ks.ks,
95                             EVP_CIPHER_CTX_iv_noconst(ctx));
96         return 1;
97     }
98     while (inl >= EVP_MAXCHUNK) {
99         DES_ncbc_encrypt(in, out, (long)EVP_MAXCHUNK,
100                          EVP_CIPHER_CTX_get_cipher_data(ctx),
101                          (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
102                          EVP_CIPHER_CTX_encrypting(ctx));
103         inl -= EVP_MAXCHUNK;
104         in += EVP_MAXCHUNK;
105         out += EVP_MAXCHUNK;
106     }
107     if (inl)
108         DES_ncbc_encrypt(in, out, (long)inl,
109                          EVP_CIPHER_CTX_get_cipher_data(ctx),
110                          (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
111                          EVP_CIPHER_CTX_encrypting(ctx));
112     return 1;
113 }
114
115 static int des_cfb64_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
116                             const unsigned char *in, size_t inl)
117 {
118     while (inl >= EVP_MAXCHUNK) {
119         int num = EVP_CIPHER_CTX_num(ctx);
120         DES_cfb64_encrypt(in, out, (long)EVP_MAXCHUNK,
121                           EVP_CIPHER_CTX_get_cipher_data(ctx),
122                           (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), &num,
123                           EVP_CIPHER_CTX_encrypting(ctx));
124         EVP_CIPHER_CTX_set_num(ctx, num);
125         inl -= EVP_MAXCHUNK;
126         in += EVP_MAXCHUNK;
127         out += EVP_MAXCHUNK;
128     }
129     if (inl) {
130         int num = EVP_CIPHER_CTX_num(ctx);
131         DES_cfb64_encrypt(in, out, (long)inl,
132                           EVP_CIPHER_CTX_get_cipher_data(ctx),
133                           (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx), &num,
134                           EVP_CIPHER_CTX_encrypting(ctx));
135         EVP_CIPHER_CTX_set_num(ctx, num);
136     }
137     return 1;
138 }
139
140 /*
141  * Although we have a CFB-r implementation for DES, it doesn't pack the right
142  * way, so wrap it here
143  */
144 static int des_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
145                            const unsigned char *in, size_t inl)
146 {
147     size_t n, chunk = EVP_MAXCHUNK / 8;
148     unsigned char c[1], d[1];
149
150     if (inl < chunk)
151         chunk = inl;
152
153     while (inl && inl >= chunk) {
154         for (n = 0; n < chunk * 8; ++n) {
155             c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0;
156             DES_cfb_encrypt(c, d, 1, 1, EVP_CIPHER_CTX_get_cipher_data(ctx),
157                             (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
158                             EVP_CIPHER_CTX_encrypting(ctx));
159             out[n / 8] =
160                 (out[n / 8] & ~(0x80 >> (unsigned int)(n % 8))) |
161                 ((d[0] & 0x80) >> (unsigned int)(n % 8));
162         }
163         inl -= chunk;
164         in += chunk;
165         out += chunk;
166         if (inl < chunk)
167             chunk = inl;
168     }
169
170     return 1;
171 }
172
173 static int des_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
174                            const unsigned char *in, size_t inl)
175 {
176     while (inl >= EVP_MAXCHUNK) {
177         DES_cfb_encrypt(in, out, 8, (long)EVP_MAXCHUNK,
178                         EVP_CIPHER_CTX_get_cipher_data(ctx),
179                         (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
180                         EVP_CIPHER_CTX_encrypting(ctx));
181         inl -= EVP_MAXCHUNK;
182         in += EVP_MAXCHUNK;
183         out += EVP_MAXCHUNK;
184     }
185     if (inl)
186         DES_cfb_encrypt(in, out, 8, (long)inl,
187                         EVP_CIPHER_CTX_get_cipher_data(ctx),
188                         (DES_cblock *)EVP_CIPHER_CTX_iv_noconst(ctx),
189                         EVP_CIPHER_CTX_encrypting(ctx));
190     return 1;
191 }
192
193 BLOCK_CIPHER_defs(des, EVP_DES_KEY, NID_des, 8, 8, 8, 64,
194                   EVP_CIPH_RAND_KEY, des_init_key, NULL,
195                   EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, des_ctrl)
196
197     BLOCK_CIPHER_def_cfb(des, EVP_DES_KEY, NID_des, 8, 8, 1,
198                      EVP_CIPH_RAND_KEY, des_init_key, NULL,
199                      EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, des_ctrl)
200
201     BLOCK_CIPHER_def_cfb(des, EVP_DES_KEY, NID_des, 8, 8, 8,
202                      EVP_CIPH_RAND_KEY, des_init_key, NULL,
203                      EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, des_ctrl)
204
205 static int des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
206                         const unsigned char *iv, int enc)
207 {
208     DES_cblock *deskey = (DES_cblock *)key;
209     EVP_DES_KEY *dat = (EVP_DES_KEY *) EVP_CIPHER_CTX_get_cipher_data(ctx);
210
211     dat->stream.cbc = NULL;
212 # if defined(SPARC_DES_CAPABLE)
213     if (SPARC_DES_CAPABLE) {
214         int mode = EVP_CIPHER_CTX_mode(ctx);
215
216         if (mode == EVP_CIPH_CBC_MODE) {
217             des_t4_key_expand(key, &dat->ks.ks);
218             dat->stream.cbc = enc ? des_t4_cbc_encrypt : des_t4_cbc_decrypt;
219             return 1;
220         }
221     }
222 # endif
223     DES_set_key_unchecked(deskey, EVP_CIPHER_CTX_get_cipher_data(ctx));
224     return 1;
225 }
226
227 static int des_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
228 {
229
230     switch (type) {
231     case EVP_CTRL_RAND_KEY:
232         if (RAND_bytes(ptr, 8) <= 0)
233             return 0;
234         DES_set_odd_parity((DES_cblock *)ptr);
235         return 1;
236
237     default:
238         return -1;
239     }
240 }
241
242 #endif