Add a WPACKET test for the new DER capability
[openssl.git] / crypto / bf / bf_enc.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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 /*
11  * BF low level APIs are deprecated for public use, but still ok for internal
12  * use.
13  */
14 #include "internal/deprecated.h"
15
16 #include <openssl/blowfish.h>
17 #include "bf_local.h"
18
19 /*
20  * Blowfish as implemented from 'Blowfish: Springer-Verlag paper' (From
21  * LECTURE NOTES IN COMPUTER SCIENCE 809, FAST SOFTWARE ENCRYPTION, CAMBRIDGE
22  * SECURITY WORKSHOP, CAMBRIDGE, U.K., DECEMBER 9-11, 1993)
23  */
24
25 #if (BF_ROUNDS != 16) && (BF_ROUNDS != 20)
26 # error If you set BF_ROUNDS to some value other than 16 or 20, you will have \
27 to modify the code.
28 #endif
29
30 void BF_encrypt(BF_LONG *data, const BF_KEY *key)
31 {
32     register BF_LONG l, r;
33     register const BF_LONG *p, *s;
34
35     p = key->P;
36     s = &(key->S[0]);
37     l = data[0];
38     r = data[1];
39
40     l ^= p[0];
41     BF_ENC(r, l, s, p[1]);
42     BF_ENC(l, r, s, p[2]);
43     BF_ENC(r, l, s, p[3]);
44     BF_ENC(l, r, s, p[4]);
45     BF_ENC(r, l, s, p[5]);
46     BF_ENC(l, r, s, p[6]);
47     BF_ENC(r, l, s, p[7]);
48     BF_ENC(l, r, s, p[8]);
49     BF_ENC(r, l, s, p[9]);
50     BF_ENC(l, r, s, p[10]);
51     BF_ENC(r, l, s, p[11]);
52     BF_ENC(l, r, s, p[12]);
53     BF_ENC(r, l, s, p[13]);
54     BF_ENC(l, r, s, p[14]);
55     BF_ENC(r, l, s, p[15]);
56     BF_ENC(l, r, s, p[16]);
57 # if BF_ROUNDS == 20
58     BF_ENC(r, l, s, p[17]);
59     BF_ENC(l, r, s, p[18]);
60     BF_ENC(r, l, s, p[19]);
61     BF_ENC(l, r, s, p[20]);
62 # endif
63     r ^= p[BF_ROUNDS + 1];
64
65     data[1] = l & 0xffffffffU;
66     data[0] = r & 0xffffffffU;
67 }
68
69 void BF_decrypt(BF_LONG *data, const BF_KEY *key)
70 {
71     register BF_LONG l, r;
72     register const BF_LONG *p, *s;
73
74     p = key->P;
75     s = &(key->S[0]);
76     l = data[0];
77     r = data[1];
78
79     l ^= p[BF_ROUNDS + 1];
80 #  if BF_ROUNDS == 20
81     BF_ENC(r, l, s, p[20]);
82     BF_ENC(l, r, s, p[19]);
83     BF_ENC(r, l, s, p[18]);
84     BF_ENC(l, r, s, p[17]);
85 #  endif
86     BF_ENC(r, l, s, p[16]);
87     BF_ENC(l, r, s, p[15]);
88     BF_ENC(r, l, s, p[14]);
89     BF_ENC(l, r, s, p[13]);
90     BF_ENC(r, l, s, p[12]);
91     BF_ENC(l, r, s, p[11]);
92     BF_ENC(r, l, s, p[10]);
93     BF_ENC(l, r, s, p[9]);
94     BF_ENC(r, l, s, p[8]);
95     BF_ENC(l, r, s, p[7]);
96     BF_ENC(r, l, s, p[6]);
97     BF_ENC(l, r, s, p[5]);
98     BF_ENC(r, l, s, p[4]);
99     BF_ENC(l, r, s, p[3]);
100     BF_ENC(r, l, s, p[2]);
101     BF_ENC(l, r, s, p[1]);
102     r ^= p[0];
103
104     data[1] = l & 0xffffffffU;
105     data[0] = r & 0xffffffffU;
106 }
107
108 void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
109                     const BF_KEY *schedule, unsigned char *ivec, int encrypt)
110 {
111     register BF_LONG tin0, tin1;
112     register BF_LONG tout0, tout1, xor0, xor1;
113     register long l = length;
114     BF_LONG tin[2];
115
116     if (encrypt) {
117         n2l(ivec, tout0);
118         n2l(ivec, tout1);
119         ivec -= 8;
120         for (l -= 8; l >= 0; l -= 8) {
121             n2l(in, tin0);
122             n2l(in, tin1);
123             tin0 ^= tout0;
124             tin1 ^= tout1;
125             tin[0] = tin0;
126             tin[1] = tin1;
127             BF_encrypt(tin, schedule);
128             tout0 = tin[0];
129             tout1 = tin[1];
130             l2n(tout0, out);
131             l2n(tout1, out);
132         }
133         if (l != -8) {
134             n2ln(in, tin0, tin1, l + 8);
135             tin0 ^= tout0;
136             tin1 ^= tout1;
137             tin[0] = tin0;
138             tin[1] = tin1;
139             BF_encrypt(tin, schedule);
140             tout0 = tin[0];
141             tout1 = tin[1];
142             l2n(tout0, out);
143             l2n(tout1, out);
144         }
145         l2n(tout0, ivec);
146         l2n(tout1, ivec);
147     } else {
148         n2l(ivec, xor0);
149         n2l(ivec, xor1);
150         ivec -= 8;
151         for (l -= 8; l >= 0; l -= 8) {
152             n2l(in, tin0);
153             n2l(in, tin1);
154             tin[0] = tin0;
155             tin[1] = tin1;
156             BF_decrypt(tin, schedule);
157             tout0 = tin[0] ^ xor0;
158             tout1 = tin[1] ^ xor1;
159             l2n(tout0, out);
160             l2n(tout1, out);
161             xor0 = tin0;
162             xor1 = tin1;
163         }
164         if (l != -8) {
165             n2l(in, tin0);
166             n2l(in, tin1);
167             tin[0] = tin0;
168             tin[1] = tin1;
169             BF_decrypt(tin, schedule);
170             tout0 = tin[0] ^ xor0;
171             tout1 = tin[1] ^ xor1;
172             l2nn(tout0, tout1, out, l + 8);
173             xor0 = tin0;
174             xor1 = tin1;
175         }
176         l2n(xor0, ivec);
177         l2n(xor1, ivec);
178     }
179     tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
180     tin[0] = tin[1] = 0;
181 }