Print this page
4896 Performance improvements for KCF AES modes
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/common/crypto/blowfish/blowfish_impl.c
+++ new/usr/src/common/crypto/blowfish/blowfish_impl.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 +/*
26 + * Copyright 2015 by Saso Kiselkov. All rights reserved.
27 + */
25 28
26 29 /*
27 30 * Blowfish encryption/decryption and keyschedule code.
28 31 */
29 32
30 33 #include <sys/types.h>
31 34 #include <sys/systm.h>
32 35 #include <sys/ddi.h>
33 36 #include <sys/sysmacros.h>
34 37 #include <sys/strsun.h>
35 38 #include <sys/note.h>
36 39 #include <sys/byteorder.h>
37 40 #include <sys/crypto/spi.h>
38 41 #include <modes/modes.h>
39 42 #include <sys/crypto/common.h>
40 43 #include "blowfish_impl.h"
41 44
42 45 #ifdef _KERNEL
43 46
44 47 #define BLOWFISH_ASSERT(x) ASSERT(x)
45 48
46 49 #else /* !_KERNEL */
47 50
48 51 #include <strings.h>
49 52 #include <stdlib.h>
50 53 #define BLOWFISH_ASSERT(x)
51 54 #endif /* _KERNEL */
52 55
53 56 #if defined(__i386) || defined(__amd64)
54 57 #include <sys/byteorder.h>
55 58 #define UNALIGNED_POINTERS_PERMITTED
56 59 #endif
57 60
58 61 /*
59 62 * Blowfish initial P box and S boxes, derived from the hex digits of PI.
60 63 *
61 64 * NOTE: S boxes are placed into one large array.
62 65 */
63 66 static const uint32_t init_P[] = {
64 67 0x243f6a88U, 0x85a308d3U, 0x13198a2eU,
65 68 0x03707344U, 0xa4093822U, 0x299f31d0U,
66 69 0x082efa98U, 0xec4e6c89U, 0x452821e6U,
67 70 0x38d01377U, 0xbe5466cfU, 0x34e90c6cU,
68 71 0xc0ac29b7U, 0xc97c50ddU, 0x3f84d5b5U,
69 72 0xb5470917U, 0x9216d5d9U, 0x8979fb1bU
70 73 };
71 74
72 75 static const uint32_t init_S[] = {
73 76 /* S-Box 0. */
74 77 0xd1310ba6U, 0x98dfb5acU, 0x2ffd72dbU, 0xd01adfb7U,
75 78 0xb8e1afedU, 0x6a267e96U, 0xba7c9045U, 0xf12c7f99U,
76 79 0x24a19947U, 0xb3916cf7U, 0x0801f2e2U, 0x858efc16U,
77 80 0x636920d8U, 0x71574e69U, 0xa458fea3U, 0xf4933d7eU,
78 81 0x0d95748fU, 0x728eb658U, 0x718bcd58U, 0x82154aeeU,
79 82 0x7b54a41dU, 0xc25a59b5U, 0x9c30d539U, 0x2af26013U,
80 83 0xc5d1b023U, 0x286085f0U, 0xca417918U, 0xb8db38efU,
81 84 0x8e79dcb0U, 0x603a180eU, 0x6c9e0e8bU, 0xb01e8a3eU,
82 85 0xd71577c1U, 0xbd314b27U, 0x78af2fdaU, 0x55605c60U,
83 86 0xe65525f3U, 0xaa55ab94U, 0x57489862U, 0x63e81440U,
84 87 0x55ca396aU, 0x2aab10b6U, 0xb4cc5c34U, 0x1141e8ceU,
85 88 0xa15486afU, 0x7c72e993U, 0xb3ee1411U, 0x636fbc2aU,
86 89 0x2ba9c55dU, 0x741831f6U, 0xce5c3e16U, 0x9b87931eU,
87 90 0xafd6ba33U, 0x6c24cf5cU, 0x7a325381U, 0x28958677U,
88 91 0x3b8f4898U, 0x6b4bb9afU, 0xc4bfe81bU, 0x66282193U,
89 92 0x61d809ccU, 0xfb21a991U, 0x487cac60U, 0x5dec8032U,
90 93 0xef845d5dU, 0xe98575b1U, 0xdc262302U, 0xeb651b88U,
91 94 0x23893e81U, 0xd396acc5U, 0x0f6d6ff3U, 0x83f44239U,
92 95 0x2e0b4482U, 0xa4842004U, 0x69c8f04aU, 0x9e1f9b5eU,
93 96 0x21c66842U, 0xf6e96c9aU, 0x670c9c61U, 0xabd388f0U,
94 97 0x6a51a0d2U, 0xd8542f68U, 0x960fa728U, 0xab5133a3U,
95 98 0x6eef0b6cU, 0x137a3be4U, 0xba3bf050U, 0x7efb2a98U,
96 99 0xa1f1651dU, 0x39af0176U, 0x66ca593eU, 0x82430e88U,
97 100 0x8cee8619U, 0x456f9fb4U, 0x7d84a5c3U, 0x3b8b5ebeU,
98 101 0xe06f75d8U, 0x85c12073U, 0x401a449fU, 0x56c16aa6U,
99 102 0x4ed3aa62U, 0x363f7706U, 0x1bfedf72U, 0x429b023dU,
100 103 0x37d0d724U, 0xd00a1248U, 0xdb0fead3U, 0x49f1c09bU,
101 104 0x075372c9U, 0x80991b7bU, 0x25d479d8U, 0xf6e8def7U,
102 105 0xe3fe501aU, 0xb6794c3bU, 0x976ce0bdU, 0x04c006baU,
103 106 0xc1a94fb6U, 0x409f60c4U, 0x5e5c9ec2U, 0x196a2463U,
104 107 0x68fb6fafU, 0x3e6c53b5U, 0x1339b2ebU, 0x3b52ec6fU,
105 108 0x6dfc511fU, 0x9b30952cU, 0xcc814544U, 0xaf5ebd09U,
106 109 0xbee3d004U, 0xde334afdU, 0x660f2807U, 0x192e4bb3U,
107 110 0xc0cba857U, 0x45c8740fU, 0xd20b5f39U, 0xb9d3fbdbU,
108 111 0x5579c0bdU, 0x1a60320aU, 0xd6a100c6U, 0x402c7279U,
109 112 0x679f25feU, 0xfb1fa3ccU, 0x8ea5e9f8U, 0xdb3222f8U,
110 113 0x3c7516dfU, 0xfd616b15U, 0x2f501ec8U, 0xad0552abU,
111 114 0x323db5faU, 0xfd238760U, 0x53317b48U, 0x3e00df82U,
112 115 0x9e5c57bbU, 0xca6f8ca0U, 0x1a87562eU, 0xdf1769dbU,
113 116 0xd542a8f6U, 0x287effc3U, 0xac6732c6U, 0x8c4f5573U,
114 117 0x695b27b0U, 0xbbca58c8U, 0xe1ffa35dU, 0xb8f011a0U,
115 118 0x10fa3d98U, 0xfd2183b8U, 0x4afcb56cU, 0x2dd1d35bU,
116 119 0x9a53e479U, 0xb6f84565U, 0xd28e49bcU, 0x4bfb9790U,
117 120 0xe1ddf2daU, 0xa4cb7e33U, 0x62fb1341U, 0xcee4c6e8U,
118 121 0xef20cadaU, 0x36774c01U, 0xd07e9efeU, 0x2bf11fb4U,
119 122 0x95dbda4dU, 0xae909198U, 0xeaad8e71U, 0x6b93d5a0U,
120 123 0xd08ed1d0U, 0xafc725e0U, 0x8e3c5b2fU, 0x8e7594b7U,
121 124 0x8ff6e2fbU, 0xf2122b64U, 0x8888b812U, 0x900df01cU,
122 125 0x4fad5ea0U, 0x688fc31cU, 0xd1cff191U, 0xb3a8c1adU,
123 126 0x2f2f2218U, 0xbe0e1777U, 0xea752dfeU, 0x8b021fa1U,
124 127 0xe5a0cc0fU, 0xb56f74e8U, 0x18acf3d6U, 0xce89e299U,
125 128 0xb4a84fe0U, 0xfd13e0b7U, 0x7cc43b81U, 0xd2ada8d9U,
126 129 0x165fa266U, 0x80957705U, 0x93cc7314U, 0x211a1477U,
127 130 0xe6ad2065U, 0x77b5fa86U, 0xc75442f5U, 0xfb9d35cfU,
128 131 0xebcdaf0cU, 0x7b3e89a0U, 0xd6411bd3U, 0xae1e7e49U,
129 132 0x00250e2dU, 0x2071b35eU, 0x226800bbU, 0x57b8e0afU,
130 133 0x2464369bU, 0xf009b91eU, 0x5563911dU, 0x59dfa6aaU,
131 134 0x78c14389U, 0xd95a537fU, 0x207d5ba2U, 0x02e5b9c5U,
132 135 0x83260376U, 0x6295cfa9U, 0x11c81968U, 0x4e734a41U,
133 136 0xb3472dcaU, 0x7b14a94aU, 0x1b510052U, 0x9a532915U,
134 137 0xd60f573fU, 0xbc9bc6e4U, 0x2b60a476U, 0x81e67400U,
135 138 0x08ba6fb5U, 0x571be91fU, 0xf296ec6bU, 0x2a0dd915U,
136 139 0xb6636521U, 0xe7b9f9b6U, 0xff34052eU, 0xc5855664U,
137 140 0x53b02d5dU, 0xa99f8fa1U, 0x08ba4799U, 0x6e85076aU,
138 141
139 142 /* S-Box 1. */
140 143 0x4b7a70e9U, 0xb5b32944U, 0xdb75092eU, 0xc4192623U,
141 144 0xad6ea6b0U, 0x49a7df7dU, 0x9cee60b8U, 0x8fedb266U,
142 145 0xecaa8c71U, 0x699a17ffU, 0x5664526cU, 0xc2b19ee1U,
143 146 0x193602a5U, 0x75094c29U, 0xa0591340U, 0xe4183a3eU,
144 147 0x3f54989aU, 0x5b429d65U, 0x6b8fe4d6U, 0x99f73fd6U,
145 148 0xa1d29c07U, 0xefe830f5U, 0x4d2d38e6U, 0xf0255dc1U,
146 149 0x4cdd2086U, 0x8470eb26U, 0x6382e9c6U, 0x021ecc5eU,
147 150 0x09686b3fU, 0x3ebaefc9U, 0x3c971814U, 0x6b6a70a1U,
148 151 0x687f3584U, 0x52a0e286U, 0xb79c5305U, 0xaa500737U,
149 152 0x3e07841cU, 0x7fdeae5cU, 0x8e7d44ecU, 0x5716f2b8U,
150 153 0xb03ada37U, 0xf0500c0dU, 0xf01c1f04U, 0x0200b3ffU,
151 154 0xae0cf51aU, 0x3cb574b2U, 0x25837a58U, 0xdc0921bdU,
152 155 0xd19113f9U, 0x7ca92ff6U, 0x94324773U, 0x22f54701U,
153 156 0x3ae5e581U, 0x37c2dadcU, 0xc8b57634U, 0x9af3dda7U,
154 157 0xa9446146U, 0x0fd0030eU, 0xecc8c73eU, 0xa4751e41U,
155 158 0xe238cd99U, 0x3bea0e2fU, 0x3280bba1U, 0x183eb331U,
156 159 0x4e548b38U, 0x4f6db908U, 0x6f420d03U, 0xf60a04bfU,
157 160 0x2cb81290U, 0x24977c79U, 0x5679b072U, 0xbcaf89afU,
158 161 0xde9a771fU, 0xd9930810U, 0xb38bae12U, 0xdccf3f2eU,
159 162 0x5512721fU, 0x2e6b7124U, 0x501adde6U, 0x9f84cd87U,
160 163 0x7a584718U, 0x7408da17U, 0xbc9f9abcU, 0xe94b7d8cU,
161 164 0xec7aec3aU, 0xdb851dfaU, 0x63094366U, 0xc464c3d2U,
162 165 0xef1c1847U, 0x3215d908U, 0xdd433b37U, 0x24c2ba16U,
163 166 0x12a14d43U, 0x2a65c451U, 0x50940002U, 0x133ae4ddU,
164 167 0x71dff89eU, 0x10314e55U, 0x81ac77d6U, 0x5f11199bU,
165 168 0x043556f1U, 0xd7a3c76bU, 0x3c11183bU, 0x5924a509U,
166 169 0xf28fe6edU, 0x97f1fbfaU, 0x9ebabf2cU, 0x1e153c6eU,
167 170 0x86e34570U, 0xeae96fb1U, 0x860e5e0aU, 0x5a3e2ab3U,
168 171 0x771fe71cU, 0x4e3d06faU, 0x2965dcb9U, 0x99e71d0fU,
169 172 0x803e89d6U, 0x5266c825U, 0x2e4cc978U, 0x9c10b36aU,
170 173 0xc6150ebaU, 0x94e2ea78U, 0xa5fc3c53U, 0x1e0a2df4U,
171 174 0xf2f74ea7U, 0x361d2b3dU, 0x1939260fU, 0x19c27960U,
172 175 0x5223a708U, 0xf71312b6U, 0xebadfe6eU, 0xeac31f66U,
173 176 0xe3bc4595U, 0xa67bc883U, 0xb17f37d1U, 0x018cff28U,
174 177 0xc332ddefU, 0xbe6c5aa5U, 0x65582185U, 0x68ab9802U,
175 178 0xeecea50fU, 0xdb2f953bU, 0x2aef7dadU, 0x5b6e2f84U,
176 179 0x1521b628U, 0x29076170U, 0xecdd4775U, 0x619f1510U,
177 180 0x13cca830U, 0xeb61bd96U, 0x0334fe1eU, 0xaa0363cfU,
178 181 0xb5735c90U, 0x4c70a239U, 0xd59e9e0bU, 0xcbaade14U,
179 182 0xeecc86bcU, 0x60622ca7U, 0x9cab5cabU, 0xb2f3846eU,
180 183 0x648b1eafU, 0x19bdf0caU, 0xa02369b9U, 0x655abb50U,
181 184 0x40685a32U, 0x3c2ab4b3U, 0x319ee9d5U, 0xc021b8f7U,
182 185 0x9b540b19U, 0x875fa099U, 0x95f7997eU, 0x623d7da8U,
183 186 0xf837889aU, 0x97e32d77U, 0x11ed935fU, 0x16681281U,
184 187 0x0e358829U, 0xc7e61fd6U, 0x96dedfa1U, 0x7858ba99U,
185 188 0x57f584a5U, 0x1b227263U, 0x9b83c3ffU, 0x1ac24696U,
186 189 0xcdb30aebU, 0x532e3054U, 0x8fd948e4U, 0x6dbc3128U,
187 190 0x58ebf2efU, 0x34c6ffeaU, 0xfe28ed61U, 0xee7c3c73U,
188 191 0x5d4a14d9U, 0xe864b7e3U, 0x42105d14U, 0x203e13e0U,
189 192 0x45eee2b6U, 0xa3aaabeaU, 0xdb6c4f15U, 0xfacb4fd0U,
190 193 0xc742f442U, 0xef6abbb5U, 0x654f3b1dU, 0x41cd2105U,
191 194 0xd81e799eU, 0x86854dc7U, 0xe44b476aU, 0x3d816250U,
192 195 0xcf62a1f2U, 0x5b8d2646U, 0xfc8883a0U, 0xc1c7b6a3U,
193 196 0x7f1524c3U, 0x69cb7492U, 0x47848a0bU, 0x5692b285U,
194 197 0x095bbf00U, 0xad19489dU, 0x1462b174U, 0x23820e00U,
195 198 0x58428d2aU, 0x0c55f5eaU, 0x1dadf43eU, 0x233f7061U,
196 199 0x3372f092U, 0x8d937e41U, 0xd65fecf1U, 0x6c223bdbU,
197 200 0x7cde3759U, 0xcbee7460U, 0x4085f2a7U, 0xce77326eU,
198 201 0xa6078084U, 0x19f8509eU, 0xe8efd855U, 0x61d99735U,
199 202 0xa969a7aaU, 0xc50c06c2U, 0x5a04abfcU, 0x800bcadcU,
200 203 0x9e447a2eU, 0xc3453484U, 0xfdd56705U, 0x0e1e9ec9U,
201 204 0xdb73dbd3U, 0x105588cdU, 0x675fda79U, 0xe3674340U,
202 205 0xc5c43465U, 0x713e38d8U, 0x3d28f89eU, 0xf16dff20U,
203 206 0x153e21e7U, 0x8fb03d4aU, 0xe6e39f2bU, 0xdb83adf7U,
204 207
205 208 /* S-Box 2. */
206 209 0xe93d5a68U, 0x948140f7U, 0xf64c261cU, 0x94692934U,
207 210 0x411520f7U, 0x7602d4f7U, 0xbcf46b2eU, 0xd4a20068U,
208 211 0xd4082471U, 0x3320f46aU, 0x43b7d4b7U, 0x500061afU,
209 212 0x1e39f62eU, 0x97244546U, 0x14214f74U, 0xbf8b8840U,
210 213 0x4d95fc1dU, 0x96b591afU, 0x70f4ddd3U, 0x66a02f45U,
211 214 0xbfbc09ecU, 0x03bd9785U, 0x7fac6dd0U, 0x31cb8504U,
212 215 0x96eb27b3U, 0x55fd3941U, 0xda2547e6U, 0xabca0a9aU,
213 216 0x28507825U, 0x530429f4U, 0x0a2c86daU, 0xe9b66dfbU,
214 217 0x68dc1462U, 0xd7486900U, 0x680ec0a4U, 0x27a18deeU,
215 218 0x4f3ffea2U, 0xe887ad8cU, 0xb58ce006U, 0x7af4d6b6U,
216 219 0xaace1e7cU, 0xd3375fecU, 0xce78a399U, 0x406b2a42U,
217 220 0x20fe9e35U, 0xd9f385b9U, 0xee39d7abU, 0x3b124e8bU,
218 221 0x1dc9faf7U, 0x4b6d1856U, 0x26a36631U, 0xeae397b2U,
219 222 0x3a6efa74U, 0xdd5b4332U, 0x6841e7f7U, 0xca7820fbU,
220 223 0xfb0af54eU, 0xd8feb397U, 0x454056acU, 0xba489527U,
221 224 0x55533a3aU, 0x20838d87U, 0xfe6ba9b7U, 0xd096954bU,
222 225 0x55a867bcU, 0xa1159a58U, 0xcca92963U, 0x99e1db33U,
223 226 0xa62a4a56U, 0x3f3125f9U, 0x5ef47e1cU, 0x9029317cU,
224 227 0xfdf8e802U, 0x04272f70U, 0x80bb155cU, 0x05282ce3U,
225 228 0x95c11548U, 0xe4c66d22U, 0x48c1133fU, 0xc70f86dcU,
226 229 0x07f9c9eeU, 0x41041f0fU, 0x404779a4U, 0x5d886e17U,
227 230 0x325f51ebU, 0xd59bc0d1U, 0xf2bcc18fU, 0x41113564U,
228 231 0x257b7834U, 0x602a9c60U, 0xdff8e8a3U, 0x1f636c1bU,
229 232 0x0e12b4c2U, 0x02e1329eU, 0xaf664fd1U, 0xcad18115U,
230 233 0x6b2395e0U, 0x333e92e1U, 0x3b240b62U, 0xeebeb922U,
231 234 0x85b2a20eU, 0xe6ba0d99U, 0xde720c8cU, 0x2da2f728U,
232 235 0xd0127845U, 0x95b794fdU, 0x647d0862U, 0xe7ccf5f0U,
233 236 0x5449a36fU, 0x877d48faU, 0xc39dfd27U, 0xf33e8d1eU,
234 237 0x0a476341U, 0x992eff74U, 0x3a6f6eabU, 0xf4f8fd37U,
235 238 0xa812dc60U, 0xa1ebddf8U, 0x991be14cU, 0xdb6e6b0dU,
236 239 0xc67b5510U, 0x6d672c37U, 0x2765d43bU, 0xdcd0e804U,
237 240 0xf1290dc7U, 0xcc00ffa3U, 0xb5390f92U, 0x690fed0bU,
238 241 0x667b9ffbU, 0xcedb7d9cU, 0xa091cf0bU, 0xd9155ea3U,
239 242 0xbb132f88U, 0x515bad24U, 0x7b9479bfU, 0x763bd6ebU,
240 243 0x37392eb3U, 0xcc115979U, 0x8026e297U, 0xf42e312dU,
241 244 0x6842ada7U, 0xc66a2b3bU, 0x12754cccU, 0x782ef11cU,
242 245 0x6a124237U, 0xb79251e7U, 0x06a1bbe6U, 0x4bfb6350U,
243 246 0x1a6b1018U, 0x11caedfaU, 0x3d25bdd8U, 0xe2e1c3c9U,
244 247 0x44421659U, 0x0a121386U, 0xd90cec6eU, 0xd5abea2aU,
245 248 0x64af674eU, 0xda86a85fU, 0xbebfe988U, 0x64e4c3feU,
246 249 0x9dbc8057U, 0xf0f7c086U, 0x60787bf8U, 0x6003604dU,
247 250 0xd1fd8346U, 0xf6381fb0U, 0x7745ae04U, 0xd736fcccU,
248 251 0x83426b33U, 0xf01eab71U, 0xb0804187U, 0x3c005e5fU,
249 252 0x77a057beU, 0xbde8ae24U, 0x55464299U, 0xbf582e61U,
250 253 0x4e58f48fU, 0xf2ddfda2U, 0xf474ef38U, 0x8789bdc2U,
251 254 0x5366f9c3U, 0xc8b38e74U, 0xb475f255U, 0x46fcd9b9U,
252 255 0x7aeb2661U, 0x8b1ddf84U, 0x846a0e79U, 0x915f95e2U,
253 256 0x466e598eU, 0x20b45770U, 0x8cd55591U, 0xc902de4cU,
254 257 0xb90bace1U, 0xbb8205d0U, 0x11a86248U, 0x7574a99eU,
255 258 0xb77f19b6U, 0xe0a9dc09U, 0x662d09a1U, 0xc4324633U,
256 259 0xe85a1f02U, 0x09f0be8cU, 0x4a99a025U, 0x1d6efe10U,
257 260 0x1ab93d1dU, 0x0ba5a4dfU, 0xa186f20fU, 0x2868f169U,
258 261 0xdcb7da83U, 0x573906feU, 0xa1e2ce9bU, 0x4fcd7f52U,
259 262 0x50115e01U, 0xa70683faU, 0xa002b5c4U, 0x0de6d027U,
260 263 0x9af88c27U, 0x773f8641U, 0xc3604c06U, 0x61a806b5U,
261 264 0xf0177a28U, 0xc0f586e0U, 0x006058aaU, 0x30dc7d62U,
262 265 0x11e69ed7U, 0x2338ea63U, 0x53c2dd94U, 0xc2c21634U,
263 266 0xbbcbee56U, 0x90bcb6deU, 0xebfc7da1U, 0xce591d76U,
264 267 0x6f05e409U, 0x4b7c0188U, 0x39720a3dU, 0x7c927c24U,
265 268 0x86e3725fU, 0x724d9db9U, 0x1ac15bb4U, 0xd39eb8fcU,
266 269 0xed545578U, 0x08fca5b5U, 0xd83d7cd3U, 0x4dad0fc4U,
267 270 0x1e50ef5eU, 0xb161e6f8U, 0xa28514d9U, 0x6c51133cU,
268 271 0x6fd5c7e7U, 0x56e14ec4U, 0x362abfceU, 0xddc6c837U,
269 272 0xd79a3234U, 0x92638212U, 0x670efa8eU, 0x406000e0U,
270 273
271 274 /* S-Box 3. */
272 275 0x3a39ce37U, 0xd3faf5cfU, 0xabc27737U, 0x5ac52d1bU,
273 276 0x5cb0679eU, 0x4fa33742U, 0xd3822740U, 0x99bc9bbeU,
274 277 0xd5118e9dU, 0xbf0f7315U, 0xd62d1c7eU, 0xc700c47bU,
275 278 0xb78c1b6bU, 0x21a19045U, 0xb26eb1beU, 0x6a366eb4U,
276 279 0x5748ab2fU, 0xbc946e79U, 0xc6a376d2U, 0x6549c2c8U,
277 280 0x530ff8eeU, 0x468dde7dU, 0xd5730a1dU, 0x4cd04dc6U,
278 281 0x2939bbdbU, 0xa9ba4650U, 0xac9526e8U, 0xbe5ee304U,
279 282 0xa1fad5f0U, 0x6a2d519aU, 0x63ef8ce2U, 0x9a86ee22U,
280 283 0xc089c2b8U, 0x43242ef6U, 0xa51e03aaU, 0x9cf2d0a4U,
281 284 0x83c061baU, 0x9be96a4dU, 0x8fe51550U, 0xba645bd6U,
282 285 0x2826a2f9U, 0xa73a3ae1U, 0x4ba99586U, 0xef5562e9U,
283 286 0xc72fefd3U, 0xf752f7daU, 0x3f046f69U, 0x77fa0a59U,
284 287 0x80e4a915U, 0x87b08601U, 0x9b09e6adU, 0x3b3ee593U,
285 288 0xe990fd5aU, 0x9e34d797U, 0x2cf0b7d9U, 0x022b8b51U,
286 289 0x96d5ac3aU, 0x017da67dU, 0xd1cf3ed6U, 0x7c7d2d28U,
287 290 0x1f9f25cfU, 0xadf2b89bU, 0x5ad6b472U, 0x5a88f54cU,
288 291 0xe029ac71U, 0xe019a5e6U, 0x47b0acfdU, 0xed93fa9bU,
289 292 0xe8d3c48dU, 0x283b57ccU, 0xf8d56629U, 0x79132e28U,
290 293 0x785f0191U, 0xed756055U, 0xf7960e44U, 0xe3d35e8cU,
291 294 0x15056dd4U, 0x88f46dbaU, 0x03a16125U, 0x0564f0bdU,
292 295 0xc3eb9e15U, 0x3c9057a2U, 0x97271aecU, 0xa93a072aU,
293 296 0x1b3f6d9bU, 0x1e6321f5U, 0xf59c66fbU, 0x26dcf319U,
294 297 0x7533d928U, 0xb155fdf5U, 0x03563482U, 0x8aba3cbbU,
295 298 0x28517711U, 0xc20ad9f8U, 0xabcc5167U, 0xccad925fU,
296 299 0x4de81751U, 0x3830dc8eU, 0x379d5862U, 0x9320f991U,
297 300 0xea7a90c2U, 0xfb3e7bceU, 0x5121ce64U, 0x774fbe32U,
298 301 0xa8b6e37eU, 0xc3293d46U, 0x48de5369U, 0x6413e680U,
299 302 0xa2ae0810U, 0xdd6db224U, 0x69852dfdU, 0x09072166U,
300 303 0xb39a460aU, 0x6445c0ddU, 0x586cdecfU, 0x1c20c8aeU,
301 304 0x5bbef7ddU, 0x1b588d40U, 0xccd2017fU, 0x6bb4e3bbU,
302 305 0xdda26a7eU, 0x3a59ff45U, 0x3e350a44U, 0xbcb4cdd5U,
303 306 0x72eacea8U, 0xfa6484bbU, 0x8d6612aeU, 0xbf3c6f47U,
304 307 0xd29be463U, 0x542f5d9eU, 0xaec2771bU, 0xf64e6370U,
305 308 0x740e0d8dU, 0xe75b1357U, 0xf8721671U, 0xaf537d5dU,
306 309 0x4040cb08U, 0x4eb4e2ccU, 0x34d2466aU, 0x0115af84U,
307 310 0xe1b00428U, 0x95983a1dU, 0x06b89fb4U, 0xce6ea048U,
308 311 0x6f3f3b82U, 0x3520ab82U, 0x011a1d4bU, 0x277227f8U,
309 312 0x611560b1U, 0xe7933fdcU, 0xbb3a792bU, 0x344525bdU,
310 313 0xa08839e1U, 0x51ce794bU, 0x2f32c9b7U, 0xa01fbac9U,
311 314 0xe01cc87eU, 0xbcc7d1f6U, 0xcf0111c3U, 0xa1e8aac7U,
312 315 0x1a908749U, 0xd44fbd9aU, 0xd0dadecbU, 0xd50ada38U,
313 316 0x0339c32aU, 0xc6913667U, 0x8df9317cU, 0xe0b12b4fU,
314 317 0xf79e59b7U, 0x43f5bb3aU, 0xf2d519ffU, 0x27d9459cU,
315 318 0xbf97222cU, 0x15e6fc2aU, 0x0f91fc71U, 0x9b941525U,
316 319 0xfae59361U, 0xceb69cebU, 0xc2a86459U, 0x12baa8d1U,
317 320 0xb6c1075eU, 0xe3056a0cU, 0x10d25065U, 0xcb03a442U,
318 321 0xe0ec6e0eU, 0x1698db3bU, 0x4c98a0beU, 0x3278e964U,
319 322 0x9f1f9532U, 0xe0d392dfU, 0xd3a0342bU, 0x8971f21eU,
320 323 0x1b0a7441U, 0x4ba3348cU, 0xc5be7120U, 0xc37632d8U,
321 324 0xdf359f8dU, 0x9b992f2eU, 0xe60b6f47U, 0x0fe3f11dU,
322 325 0xe54cda54U, 0x1edad891U, 0xce6279cfU, 0xcd3e7e6fU,
323 326 0x1618b166U, 0xfd2c1d05U, 0x848fd2c5U, 0xf6fb2299U,
324 327 0xf523f357U, 0xa6327623U, 0x93a83531U, 0x56cccd02U,
325 328 0xacf08162U, 0x5a75ebb5U, 0x6e163697U, 0x88d273ccU,
326 329 0xde966292U, 0x81b949d0U, 0x4c50901bU, 0x71c65614U,
327 330 0xe6c6c7bdU, 0x327a140aU, 0x45e1d006U, 0xc3f27b9aU,
328 331 0xc9aa53fdU, 0x62a80f00U, 0xbb25bfe2U, 0x35bdd2f6U,
329 332 0x71126905U, 0xb2040222U, 0xb6cbcf7cU, 0xcd769c2bU,
330 333 0x53113ec0U, 0x1640e3d3U, 0x38abbd60U, 0x2547adf0U,
331 334 0xba38209cU, 0xf746ce76U, 0x77afa1c5U, 0x20756060U,
332 335 0x85cbfe4eU, 0x8ae88dd8U, 0x7aaaf9b0U, 0x4cf9aa7eU,
333 336 0x1948c25cU, 0x02fb8a8cU, 0x01c36ae4U, 0xd6ebe1f9U,
334 337 0x90d4f869U, 0xa65cdea0U, 0x3f09252dU, 0xc208e69fU,
335 338 0xb74e6132U, 0xce77e25bU, 0x578fdfe3U, 0x3ac372e6U,
336 339 };
337 340
338 341 typedef struct keysched_s {
339 342 uint32_t ksch_S[1024]; /* The 4 S boxes are 256 32-bit words. */
340 343 uint32_t ksch_P[18]; /* P box is 18 32-bit words. */
341 344 } keysched_t;
342 345
343 346 /*
344 347 * Since ROUND() is a macro, make sure that the things inside can be
345 348 * evaluated more than once. Especially when calling F().
346 349 * Assume the presence of local variables:
347 350 *
348 351 * uint32_t *P;
349 352 * uint32_t *S;
350 353 * uint32_t tmp;
351 354 *
352 355 *
353 356 * And to Microsoft interview survivors out there, perhaps I should do the
354 357 * XOR swap trick, or at least #ifdef (__i386) the tmp = ... = tmp; stuff.
355 358 */
356 359
357 360 #define F(word) \
358 361 (((S[(word >> 24) & 0xff] + S[256 + ((word >> 16) & 0xff)]) ^ \
359 362 S[512 + ((word >> 8) & 0xff)]) + S[768 + (word & 0xff)])
360 363
361 364 #define ROUND(left, right, i) \
362 365 (left) ^= P[i]; \
363 366 (right) ^= F((left)); \
364 367 tmp = (left); \
365 368 (left) = (right); \
366 369 (right) = tmp;
367 370
368 371 /*
369 372 * Encrypt a block of data. Because of addition operations, convert blocks
370 373 * to their big-endian representation, even on Intel boxen.
371 374 */
372 375 /* ARGSUSED */
373 376 int
374 377 blowfish_encrypt_block(const void *cookie, const uint8_t *block,
375 378 uint8_t *out_block)
376 379 {
377 380 keysched_t *ksch = (keysched_t *)cookie;
378 381
379 382 uint32_t left, right, tmp;
380 383 uint32_t *P = ksch->ksch_P;
381 384 uint32_t *S = ksch->ksch_S;
382 385 #ifdef _BIG_ENDIAN
383 386 uint32_t *b32;
384 387
385 388 if (IS_P2ALIGNED(block, sizeof (uint32_t))) {
386 389 /* LINTED: pointer alignment */
387 390 b32 = (uint32_t *)block;
388 391 left = b32[0];
389 392 right = b32[1];
390 393 } else
391 394 #endif
392 395 {
393 396 /*
394 397 * Read input block and place in left/right in big-endian order.
395 398 */
396 399 #ifdef UNALIGNED_POINTERS_PERMITTED
397 400 left = htonl(*(uint32_t *)(void *)&block[0]);
398 401 right = htonl(*(uint32_t *)(void *)&block[4]);
399 402 #else
400 403 left = ((uint32_t)block[0] << 24)
401 404 | ((uint32_t)block[1] << 16)
402 405 | ((uint32_t)block[2] << 8)
403 406 | (uint32_t)block[3];
404 407 right = ((uint32_t)block[4] << 24)
405 408 | ((uint32_t)block[5] << 16)
406 409 | ((uint32_t)block[6] << 8)
407 410 | (uint32_t)block[7];
408 411 #endif /* UNALIGNED_POINTERS_PERMITTED */
409 412 }
410 413
411 414 ROUND(left, right, 0);
412 415 ROUND(left, right, 1);
413 416 ROUND(left, right, 2);
414 417 ROUND(left, right, 3);
415 418 ROUND(left, right, 4);
416 419 ROUND(left, right, 5);
417 420 ROUND(left, right, 6);
418 421 ROUND(left, right, 7);
419 422 ROUND(left, right, 8);
420 423 ROUND(left, right, 9);
421 424 ROUND(left, right, 10);
422 425 ROUND(left, right, 11);
423 426 ROUND(left, right, 12);
424 427 ROUND(left, right, 13);
425 428 ROUND(left, right, 14);
426 429 ROUND(left, right, 15);
427 430
428 431 tmp = left;
429 432 left = right;
430 433 right = tmp;
431 434 right ^= P[16];
432 435 left ^= P[17];
433 436
434 437 #ifdef _BIG_ENDIAN
435 438 if (IS_P2ALIGNED(out_block, sizeof (uint32_t))) {
436 439 /* LINTED: pointer alignment */
437 440 b32 = (uint32_t *)out_block;
438 441 b32[0] = left;
439 442 b32[1] = right;
440 443 } else
441 444 #endif
442 445 {
443 446 /* Put the block back into the user's block with final swap */
444 447 #ifdef UNALIGNED_POINTERS_PERMITTED
445 448 *(uint32_t *)(void *)&out_block[0] = htonl(left);
446 449 *(uint32_t *)(void *)&out_block[4] = htonl(right);
447 450 #else
448 451 out_block[0] = left >> 24;
449 452 out_block[1] = left >> 16;
450 453 out_block[2] = left >> 8;
451 454 out_block[3] = left;
452 455 out_block[4] = right >> 24;
453 456 out_block[5] = right >> 16;
454 457 out_block[6] = right >> 8;
455 458 out_block[7] = right;
456 459 #endif /* UNALIGNED_POINTERS_PERMITTED */
457 460 }
458 461 return (CRYPTO_SUCCESS);
459 462 }
460 463
461 464 /*
462 465 * Decrypt a block of data. Because of addition operations, convert blocks
463 466 * to their big-endian representation, even on Intel boxen.
464 467 * It should look like the blowfish_encrypt_block() operation
465 468 * except for the order in which the S/P boxes are accessed.
466 469 */
467 470 /* ARGSUSED */
468 471 int
469 472 blowfish_decrypt_block(const void *cookie, const uint8_t *block,
470 473 uint8_t *out_block)
471 474 {
472 475 keysched_t *ksch = (keysched_t *)cookie;
473 476
474 477 uint32_t left, right, tmp;
475 478 uint32_t *P = ksch->ksch_P;
476 479 uint32_t *S = ksch->ksch_S;
477 480 #ifdef _BIG_ENDIAN
478 481 uint32_t *b32;
479 482
480 483 if (IS_P2ALIGNED(block, sizeof (uint32_t))) {
481 484 /* LINTED: pointer alignment */
482 485 b32 = (uint32_t *)block;
483 486 left = b32[0];
484 487 right = b32[1];
485 488 } else
486 489 #endif
487 490 {
488 491 /*
489 492 * Read input block and place in left/right in big-endian order.
490 493 */
491 494 #ifdef UNALIGNED_POINTERS_PERMITTED
492 495 left = htonl(*(uint32_t *)(void *)&block[0]);
493 496 right = htonl(*(uint32_t *)(void *)&block[4]);
494 497 #else
495 498 left = ((uint32_t)block[0] << 24)
496 499 | ((uint32_t)block[1] << 16)
497 500 | ((uint32_t)block[2] << 8)
498 501 | (uint32_t)block[3];
499 502 right = ((uint32_t)block[4] << 24)
500 503 | ((uint32_t)block[5] << 16)
501 504 | ((uint32_t)block[6] << 8)
502 505 | (uint32_t)block[7];
503 506 #endif /* UNALIGNED_POINTERS_PERMITTED */
504 507 }
505 508
506 509 ROUND(left, right, 17);
507 510 ROUND(left, right, 16);
508 511 ROUND(left, right, 15);
509 512 ROUND(left, right, 14);
510 513 ROUND(left, right, 13);
511 514 ROUND(left, right, 12);
512 515 ROUND(left, right, 11);
513 516 ROUND(left, right, 10);
514 517 ROUND(left, right, 9);
515 518 ROUND(left, right, 8);
516 519 ROUND(left, right, 7);
517 520 ROUND(left, right, 6);
518 521 ROUND(left, right, 5);
519 522 ROUND(left, right, 4);
520 523 ROUND(left, right, 3);
521 524 ROUND(left, right, 2);
522 525
523 526 tmp = left;
524 527 left = right;
525 528 right = tmp;
526 529 right ^= P[1];
527 530 left ^= P[0];
528 531
529 532 #ifdef _BIG_ENDIAN
530 533 if (IS_P2ALIGNED(out_block, sizeof (uint32_t))) {
531 534 /* LINTED: pointer alignment */
532 535 b32 = (uint32_t *)out_block;
533 536 b32[0] = left;
534 537 b32[1] = right;
535 538 } else
536 539 #endif
537 540 {
538 541 /* Put the block back into the user's block with final swap */
539 542 #ifdef UNALIGNED_POINTERS_PERMITTED
540 543 *(uint32_t *)(void *)&out_block[0] = htonl(left);
541 544 *(uint32_t *)(void *)&out_block[4] = htonl(right);
542 545 #else
543 546 out_block[0] = left >> 24;
544 547 out_block[1] = left >> 16;
545 548 out_block[2] = left >> 8;
546 549 out_block[3] = left;
547 550 out_block[4] = right >> 24;
548 551 out_block[5] = right >> 16;
549 552 out_block[6] = right >> 8;
550 553 out_block[7] = right;
551 554 #endif /* UNALIGNED_POINTERS_PERMITTED */
552 555 }
553 556 return (CRYPTO_SUCCESS);
554 557 }
555 558
556 559 static void
557 560 bitrepeat(uint8_t *pattern, uint_t len_bytes, uint_t len_bits, uint8_t *dst,
558 561 uint_t dst_len_bytes)
559 562 {
560 563 uint8_t *current = dst;
561 564 uint_t bitsleft = CRYPTO_BYTES2BITS(dst_len_bytes);
562 565 uint_t bitoffset = 0;
563 566 uint_t currentbits;
564 567 int i;
565 568
566 569 BLOWFISH_ASSERT(CRYPTO_BITS2BYTES(len_bits) == len_bytes);
567 570
568 571 bzero(dst, dst_len_bytes);
569 572
570 573 while (bitsleft != 0) {
571 574 if (bitsleft >= len_bits) {
572 575 currentbits = len_bits;
573 576
574 577 for (i = 0; i < len_bytes; i++) {
575 578 if (currentbits >= 8) {
576 579 *current++ |= pattern[i] >> bitoffset;
577 580 *current |= pattern[i] << 8 - bitoffset;
578 581 currentbits -= 8;
579 582 } else {
580 583 *current |= pattern[i] >> bitoffset;
581 584 bitoffset = bitoffset + currentbits;
582 585 bitoffset &= 0x7;
583 586 if (bitoffset == 0)
584 587 current++;
585 588 }
586 589 }
587 590 bitsleft -= len_bits;
588 591 } else {
589 592 currentbits = bitsleft;
590 593
591 594 for (i = 0; i < len_bytes && bitsleft != 0; i++) {
592 595 if (currentbits >= 8 &&
593 596 current < dst + dst_len_bytes) {
594 597 *current++ |= pattern[i] >> bitoffset;
595 598 *current |= pattern[i] << 8 - bitoffset;
596 599 currentbits -= 8;
597 600 bitsleft -= 8;
598 601 } else {
599 602 *current |= pattern[i] >> bitoffset;
600 603 bitsleft -= bitoffset;
601 604 bitoffset = bitoffset + currentbits;
602 605 bitoffset &= 0x7;
603 606 if (bitoffset == 0)
604 607 current++;
605 608 currentbits = 0;
606 609 }
607 610 }
608 611 bitsleft = 0;
609 612 }
610 613 }
611 614 }
612 615
613 616 /*
614 617 * Initialize key schedules for Blowfish.
615 618 */
616 619 void
617 620 blowfish_init_keysched(uint8_t *key, uint_t bits, void *keysched)
618 621 {
619 622 keysched_t *newbie = keysched;
620 623 uint32_t *P = newbie->ksch_P;
621 624 uint32_t *S = newbie->ksch_S;
622 625 uint32_t *initp;
623 626 uint32_t tmpblock[] = {0, 0};
624 627 uint8_t *rawkeybytes = (uint8_t *)P;
625 628 int i, slop, copylen;
626 629 uintptr_t bytesleft;
627 630 uint_t len;
628 631
629 632 len = CRYPTO_BITS2BYTES(bits);
630 633
631 634 if ((bits & 0x7) != 0) {
632 635 /*
633 636 * Really slow case, bits aren't on a byte boundary.
634 637 * Keep track of individual bits copied over. :-P
635 638 */
636 639 bitrepeat(key, len, bits, rawkeybytes, 72);
637 640 } else {
638 641 slop = 72 % len;
639 642
640 643 /* Someone gave us a nice amount (i.e. div by 8) of bits */
641 644 while (rawkeybytes != (uint8_t *)(P + 18)) {
642 645 bytesleft =
643 646 (uintptr_t)(P + 18) - (uintptr_t)rawkeybytes;
644 647 copylen = (bytesleft >= len) ? len : slop;
645 648 bcopy(key, rawkeybytes, copylen);
646 649 rawkeybytes += copylen;
647 650 }
648 651 }
649 652
650 653 for (i = 0; i < 18; i++)
651 654 P[i] = ntohl(P[i]) ^ init_P[i];
652 655
653 656 /* Go bcopy go! (Hope that Ultra's bcopy is faster than me!) */
654 657 bcopy(init_S, S, sizeof (init_S));
655 658
656 659 /*
657 660 * When initializing P and S boxes, store the results of a single
658 661 * encrypt-block operation in "host order", which on little-endian
659 662 * means byte-swapping. Fortunately, the ntohl() function does this
660 663 * quite nicely, and it a NOP on big-endian machine.
661 664 */
662 665 initp = P;
663 666 for (i = 0; i < 9; i++) {
664 667 (void) blowfish_encrypt_block(newbie, (uint8_t *)tmpblock,
665 668 (uint8_t *)tmpblock);
666 669 *initp++ = ntohl(tmpblock[0]);
667 670 *initp++ = ntohl(tmpblock[1]);
668 671 }
669 672
670 673 initp = S;
671 674 for (i = 0; i < 512; i++) {
672 675 (void) blowfish_encrypt_block(newbie, (uint8_t *)tmpblock,
673 676 (uint8_t *)tmpblock);
674 677 *initp++ = ntohl(tmpblock[0]);
675 678 *initp++ = ntohl(tmpblock[1]);
676 679 }
677 680 }
678 681
679 682 /*
680 683 * Allocate key schedule for Blowfish.
681 684 */
682 685 /* ARGSUSED */
683 686 void *
684 687 blowfish_alloc_keysched(size_t *size, int kmflag)
685 688 {
686 689 keysched_t *keysched;
687 690
688 691 #ifdef _KERNEL
689 692 keysched = (keysched_t *)kmem_alloc(sizeof (keysched_t), kmflag);
690 693 #else
691 694 keysched = (keysched_t *)malloc(sizeof (keysched_t));
|
↓ open down ↓ |
657 lines elided |
↑ open up ↑ |
692 695 #endif /* _KERNEL */
693 696 if (keysched != NULL) {
694 697 *size = sizeof (keysched_t);
695 698 return (keysched);
696 699 }
697 700
698 701 return (NULL);
699 702 }
700 703
701 704 void
702 -blowfish_copy_block(uint8_t *in, uint8_t *out)
705 +blowfish_copy_block(const uint8_t *in, uint8_t *out)
703 706 {
704 707 if (IS_P2ALIGNED(in, sizeof (uint32_t)) &&
705 708 IS_P2ALIGNED(out, sizeof (uint32_t))) {
706 709 /* LINTED: pointer alignment */
707 710 *(uint32_t *)&out[0] = *(uint32_t *)&in[0];
708 711 /* LINTED: pointer alignment */
709 712 *(uint32_t *)&out[4] = *(uint32_t *)&in[4];
710 713 } else {
711 714 BLOWFISH_COPY_BLOCK(in, out);
712 715 }
713 716 }
714 717
715 718 /* XOR block of data into dest */
716 719 void
717 -blowfish_xor_block(uint8_t *data, uint8_t *dst)
720 +blowfish_xor_block(const uint8_t *data, uint8_t *dst)
718 721 {
719 722 if (IS_P2ALIGNED(dst, sizeof (uint32_t)) &&
720 723 IS_P2ALIGNED(data, sizeof (uint32_t))) {
721 724 /* LINTED: pointer alignment */
722 725 *(uint32_t *)&dst[0] ^= *(uint32_t *)&data[0];
723 726 /* LINTED: pointer alignment */
724 727 *(uint32_t *)&dst[4] ^= *(uint32_t *)&data[4];
725 728 } else {
726 729 BLOWFISH_XOR_BLOCK(data, dst);
727 730 }
728 731 }
729 732
730 733 /*
731 734 * Encrypt multiple blocks of data according to mode.
732 735 */
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
733 736 int
734 737 blowfish_encrypt_contiguous_blocks(void *ctx, char *data, size_t length,
735 738 crypto_data_t *out)
736 739 {
737 740 blowfish_ctx_t *blowfish_ctx = ctx;
738 741 int rv;
739 742
740 743 if (blowfish_ctx->bc_flags & CBC_MODE) {
741 744 rv = cbc_encrypt_contiguous_blocks(ctx, data, length, out,
742 745 BLOWFISH_BLOCK_LEN, blowfish_encrypt_block,
743 - blowfish_copy_block, blowfish_xor_block);
746 + blowfish_copy_block, blowfish_xor_block, NULL);
744 747 } else {
745 748 rv = ecb_cipher_contiguous_blocks(ctx, data, length, out,
746 - BLOWFISH_BLOCK_LEN, blowfish_encrypt_block);
749 + BLOWFISH_BLOCK_LEN, blowfish_encrypt_block, NULL);
747 750 }
748 751 return (rv);
749 752 }
750 753
751 754 /*
752 755 * Decrypt multiple blocks of data according to mode.
753 756 */
754 757 int
755 758 blowfish_decrypt_contiguous_blocks(void *ctx, char *data, size_t length,
756 759 crypto_data_t *out)
757 760 {
758 761 blowfish_ctx_t *blowfish_ctx = ctx;
759 762 int rv;
760 763
761 764 if (blowfish_ctx->bc_flags & CBC_MODE) {
762 765 rv = cbc_decrypt_contiguous_blocks(ctx, data, length, out,
763 766 BLOWFISH_BLOCK_LEN, blowfish_decrypt_block,
764 - blowfish_copy_block, blowfish_xor_block);
767 + blowfish_copy_block, blowfish_xor_block, NULL, NULL);
765 768 } else {
766 769 rv = ecb_cipher_contiguous_blocks(ctx, data, length, out,
767 - BLOWFISH_BLOCK_LEN, blowfish_decrypt_block);
770 + BLOWFISH_BLOCK_LEN, blowfish_decrypt_block, NULL);
768 771 if (rv == CRYPTO_DATA_LEN_RANGE)
769 772 rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
770 773 }
771 774 return (rv);
772 775 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX