Configure: handle undefined shared_target.
[openssl.git] / crypto / rc2 / rc2_cbc.c
1 /*
2  * Copyright 1995-2020 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  * RC2 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/rc2.h>
17 #include "rc2_local.h"
18
19 void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
20                      RC2_KEY *ks, unsigned char *iv, int encrypt)
21 {
22     register unsigned long tin0, tin1;
23     register unsigned long tout0, tout1, xor0, xor1;
24     register long l = length;
25     unsigned long tin[2];
26
27     if (encrypt) {
28         c2l(iv, tout0);
29         c2l(iv, tout1);
30         iv -= 8;
31         for (l -= 8; l >= 0; l -= 8) {
32             c2l(in, tin0);
33             c2l(in, tin1);
34             tin0 ^= tout0;
35             tin1 ^= tout1;
36             tin[0] = tin0;
37             tin[1] = tin1;
38             RC2_encrypt(tin, ks);
39             tout0 = tin[0];
40             l2c(tout0, out);
41             tout1 = tin[1];
42             l2c(tout1, out);
43         }
44         if (l != -8) {
45             c2ln(in, tin0, tin1, l + 8);
46             tin0 ^= tout0;
47             tin1 ^= tout1;
48             tin[0] = tin0;
49             tin[1] = tin1;
50             RC2_encrypt(tin, ks);
51             tout0 = tin[0];
52             l2c(tout0, out);
53             tout1 = tin[1];
54             l2c(tout1, out);
55         }
56         l2c(tout0, iv);
57         l2c(tout1, iv);
58     } else {
59         c2l(iv, xor0);
60         c2l(iv, xor1);
61         iv -= 8;
62         for (l -= 8; l >= 0; l -= 8) {
63             c2l(in, tin0);
64             tin[0] = tin0;
65             c2l(in, tin1);
66             tin[1] = tin1;
67             RC2_decrypt(tin, ks);
68             tout0 = tin[0] ^ xor0;
69             tout1 = tin[1] ^ xor1;
70             l2c(tout0, out);
71             l2c(tout1, out);
72             xor0 = tin0;
73             xor1 = tin1;
74         }
75         if (l != -8) {
76             c2l(in, tin0);
77             tin[0] = tin0;
78             c2l(in, tin1);
79             tin[1] = tin1;
80             RC2_decrypt(tin, ks);
81             tout0 = tin[0] ^ xor0;
82             tout1 = tin[1] ^ xor1;
83             l2cn(tout0, tout1, out, l + 8);
84             xor0 = tin0;
85             xor1 = tin1;
86         }
87         l2c(xor0, iv);
88         l2c(xor1, iv);
89     }
90     tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
91     tin[0] = tin[1] = 0;
92 }
93
94 void RC2_encrypt(unsigned long *d, RC2_KEY *key)
95 {
96     int i, n;
97     register RC2_INT *p0, *p1;
98     register RC2_INT x0, x1, x2, x3, t;
99     unsigned long l;
100
101     l = d[0];
102     x0 = (RC2_INT) l & 0xffff;
103     x1 = (RC2_INT) (l >> 16L);
104     l = d[1];
105     x2 = (RC2_INT) l & 0xffff;
106     x3 = (RC2_INT) (l >> 16L);
107
108     n = 3;
109     i = 5;
110
111     p0 = p1 = &(key->data[0]);
112     for (;;) {
113         t = (x0 + (x1 & ~x3) + (x2 & x3) + *(p0++)) & 0xffff;
114         x0 = (t << 1) | (t >> 15);
115         t = (x1 + (x2 & ~x0) + (x3 & x0) + *(p0++)) & 0xffff;
116         x1 = (t << 2) | (t >> 14);
117         t = (x2 + (x3 & ~x1) + (x0 & x1) + *(p0++)) & 0xffff;
118         x2 = (t << 3) | (t >> 13);
119         t = (x3 + (x0 & ~x2) + (x1 & x2) + *(p0++)) & 0xffff;
120         x3 = (t << 5) | (t >> 11);
121
122         if (--i == 0) {
123             if (--n == 0)
124                 break;
125             i = (n == 2) ? 6 : 5;
126
127             x0 += p1[x3 & 0x3f];
128             x1 += p1[x0 & 0x3f];
129             x2 += p1[x1 & 0x3f];
130             x3 += p1[x2 & 0x3f];
131         }
132     }
133
134     d[0] =
135         (unsigned long)(x0 & 0xffff) | ((unsigned long)(x1 & 0xffff) << 16L);
136     d[1] =
137         (unsigned long)(x2 & 0xffff) | ((unsigned long)(x3 & 0xffff) << 16L);
138 }
139
140 void RC2_decrypt(unsigned long *d, RC2_KEY *key)
141 {
142     int i, n;
143     register RC2_INT *p0, *p1;
144     register RC2_INT x0, x1, x2, x3, t;
145     unsigned long l;
146
147     l = d[0];
148     x0 = (RC2_INT) l & 0xffff;
149     x1 = (RC2_INT) (l >> 16L);
150     l = d[1];
151     x2 = (RC2_INT) l & 0xffff;
152     x3 = (RC2_INT) (l >> 16L);
153
154     n = 3;
155     i = 5;
156
157     p0 = &(key->data[63]);
158     p1 = &(key->data[0]);
159     for (;;) {
160         t = ((x3 << 11) | (x3 >> 5)) & 0xffff;
161         x3 = (t - (x0 & ~x2) - (x1 & x2) - *(p0--)) & 0xffff;
162         t = ((x2 << 13) | (x2 >> 3)) & 0xffff;
163         x2 = (t - (x3 & ~x1) - (x0 & x1) - *(p0--)) & 0xffff;
164         t = ((x1 << 14) | (x1 >> 2)) & 0xffff;
165         x1 = (t - (x2 & ~x0) - (x3 & x0) - *(p0--)) & 0xffff;
166         t = ((x0 << 15) | (x0 >> 1)) & 0xffff;
167         x0 = (t - (x1 & ~x3) - (x2 & x3) - *(p0--)) & 0xffff;
168
169         if (--i == 0) {
170             if (--n == 0)
171                 break;
172             i = (n == 2) ? 6 : 5;
173
174             x3 = (x3 - p1[x2 & 0x3f]) & 0xffff;
175             x2 = (x2 - p1[x1 & 0x3f]) & 0xffff;
176             x1 = (x1 - p1[x0 & 0x3f]) & 0xffff;
177             x0 = (x0 - p1[x3 & 0x3f]) & 0xffff;
178         }
179     }
180
181     d[0] =
182         (unsigned long)(x0 & 0xffff) | ((unsigned long)(x1 & 0xffff) << 16L);
183     d[1] =
184         (unsigned long)(x2 & 0xffff) | ((unsigned long)(x3 & 0xffff) << 16L);
185 }