Print this page
6717509 Need to use bswap/bswapq for byte swap of 64-bit integer on x32/x64 (fix lint)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/common/crypto/des/des_impl.c
+++ new/usr/src/common/crypto/des/des_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.
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 2008 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 #include <sys/types.h>
27 27 #include <sys/systm.h>
28 28 #include <sys/ddi.h>
29 29 #include <sys/sysmacros.h>
30 30 #include <sys/strsun.h>
31 31 #include <sys/crypto/spi.h>
32 32 #include <modes/modes.h>
33 33 #include <sys/crypto/common.h>
34 34 #include "des_impl.h"
35 35 #ifndef _KERNEL
36 36 #include <strings.h>
37 37 #include <stdlib.h>
38 38 #endif /* !_KERNEL */
39 39
40 40 #if defined(__i386) || defined(__amd64)
41 41 #include <sys/byteorder.h>
42 42 #define UNALIGNED_POINTERS_PERMITTED
43 43 #endif
44 44
45 45 /* EXPORT DELETE START */
46 46
47 47 typedef struct keysched_s {
48 48 uint64_t ksch_encrypt[16];
49 49 uint64_t ksch_decrypt[16];
50 50 } keysched_t;
51 51
52 52 typedef struct keysched3_s {
53 53 uint64_t ksch_encrypt[48];
54 54 uint64_t ksch_decrypt[48];
55 55 } keysched3_t;
56 56
57 57 static void fix_des_parity(uint64_t *);
58 58
59 59 #ifndef sun4u
60 60
61 61 static const uint64_t sbox_table[8][64]=
62 62 {
63 63 /* BEGIN CSTYLED */
64 64 {
65 65 0x0000140140020000ULL, 0x0000000000000000ULL, 0x0000000140000000ULL, 0x0000140140020020ULL,
66 66 0x0000140140000020ULL, 0x0000000140020020ULL, 0x0000000000000020ULL, 0x0000000140000000ULL,
67 67 0x0000000000020000ULL, 0x0000140140020000ULL, 0x0000140140020020ULL, 0x0000000000020000ULL,
68 68 0x0000140000020020ULL, 0x0000140140000020ULL, 0x0000140000000000ULL, 0x0000000000000020ULL,
69 69 0x0000000000020020ULL, 0x0000140000020000ULL, 0x0000140000020000ULL, 0x0000000140020000ULL,
70 70 0x0000000140020000ULL, 0x0000140140000000ULL, 0x0000140140000000ULL, 0x0000140000020020ULL,
71 71 0x0000000140000020ULL, 0x0000140000000020ULL, 0x0000140000000020ULL, 0x0000000140000020ULL,
72 72 0x0000000000000000ULL, 0x0000000000020020ULL, 0x0000000140020020ULL, 0x0000140000000000ULL,
73 73 0x0000000140000000ULL, 0x0000140140020020ULL, 0x0000000000000020ULL, 0x0000140140000000ULL,
74 74 0x0000140140020000ULL, 0x0000140000000000ULL, 0x0000140000000000ULL, 0x0000000000020000ULL,
75 75 0x0000140140000020ULL, 0x0000000140000000ULL, 0x0000000140020000ULL, 0x0000140000000020ULL,
76 76 0x0000000000020000ULL, 0x0000000000000020ULL, 0x0000140000020020ULL, 0x0000000140020020ULL,
77 77 0x0000140140020020ULL, 0x0000000140000020ULL, 0x0000140140000000ULL, 0x0000140000020020ULL,
78 78 0x0000140000000020ULL, 0x0000000000020020ULL, 0x0000000140020020ULL, 0x0000140140020000ULL,
79 79 0x0000000000020020ULL, 0x0000140000020000ULL, 0x0000140000020000ULL, 0x0000000000000000ULL,
80 80 0x0000000140000020ULL, 0x0000000140020000ULL, 0x0000000000000000ULL, 0x0000140140000020ULL
81 81 },
82 82 {
83 83 0x2000005020000500ULL, 0x2000000020000000ULL, 0x0000000020000000ULL, 0x0000005020000500ULL,
84 84 0x0000005000000000ULL, 0x0000000000000500ULL, 0x2000005000000500ULL, 0x2000000020000500ULL,
85 85 0x2000000000000500ULL, 0x2000005020000500ULL, 0x2000005020000000ULL, 0x2000000000000000ULL,
86 86 0x2000000020000000ULL, 0x0000005000000000ULL, 0x0000000000000500ULL, 0x2000005000000500ULL,
87 87 0x0000005020000000ULL, 0x0000005000000500ULL, 0x2000000020000500ULL, 0x0000000000000000ULL,
88 88 0x2000000000000000ULL, 0x0000000020000000ULL, 0x0000005020000500ULL, 0x2000005000000000ULL,
89 89 0x0000005000000500ULL, 0x2000000000000500ULL, 0x0000000000000000ULL, 0x0000005020000000ULL,
90 90 0x0000000020000500ULL, 0x2000005020000000ULL, 0x2000005000000000ULL, 0x0000000020000500ULL,
91 91 0x0000000000000000ULL, 0x0000005020000500ULL, 0x2000005000000500ULL, 0x0000005000000000ULL,
92 92 0x2000000020000500ULL, 0x2000005000000000ULL, 0x2000005020000000ULL, 0x0000000020000000ULL,
93 93 0x2000005000000000ULL, 0x2000000020000000ULL, 0x0000000000000500ULL, 0x2000005020000500ULL,
94 94 0x0000005020000500ULL, 0x0000000000000500ULL, 0x0000000020000000ULL, 0x2000000000000000ULL,
95 95 0x0000000020000500ULL, 0x2000005020000000ULL, 0x0000005000000000ULL, 0x2000000000000500ULL,
96 96 0x0000005000000500ULL, 0x2000000020000500ULL, 0x2000000000000500ULL, 0x0000005000000500ULL,
97 97 0x0000005020000000ULL, 0x0000000000000000ULL, 0x2000000020000000ULL, 0x0000000020000500ULL,
98 98 0x2000000000000000ULL, 0x2000005000000500ULL, 0x2000005020000500ULL, 0x0000005020000000ULL
99 99 },
100 100 {
101 101 0x0000000000014040ULL, 0x0000800280014000ULL, 0x0000000000000000ULL, 0x0000800280000040ULL,
102 102 0x0000800000014000ULL, 0x0000000000000000ULL, 0x0000000280014040ULL, 0x0000800000014000ULL,
103 103 0x0000000280000040ULL, 0x0000800000000040ULL, 0x0000800000000040ULL, 0x0000000280000000ULL,
104 104 0x0000800280014040ULL, 0x0000000280000040ULL, 0x0000800280000000ULL, 0x0000000000014040ULL,
105 105 0x0000800000000000ULL, 0x0000000000000040ULL, 0x0000800280014000ULL, 0x0000000000014000ULL,
106 106 0x0000000280014000ULL, 0x0000800280000000ULL, 0x0000800280000040ULL, 0x0000000280014040ULL,
107 107 0x0000800000014040ULL, 0x0000000280014000ULL, 0x0000000280000000ULL, 0x0000800000014040ULL,
108 108 0x0000000000000040ULL, 0x0000800280014040ULL, 0x0000000000014000ULL, 0x0000800000000000ULL,
109 109 0x0000800280014000ULL, 0x0000800000000000ULL, 0x0000000280000040ULL, 0x0000000000014040ULL,
110 110 0x0000000280000000ULL, 0x0000800280014000ULL, 0x0000800000014000ULL, 0x0000000000000000ULL,
111 111 0x0000000000014000ULL, 0x0000000280000040ULL, 0x0000800280014040ULL, 0x0000800000014000ULL,
112 112 0x0000800000000040ULL, 0x0000000000014000ULL, 0x0000000000000000ULL, 0x0000800280000040ULL,
113 113 0x0000800000014040ULL, 0x0000000280000000ULL, 0x0000800000000000ULL, 0x0000800280014040ULL,
114 114 0x0000000000000040ULL, 0x0000000280014040ULL, 0x0000000280014000ULL, 0x0000800000000040ULL,
115 115 0x0000800280000000ULL, 0x0000800000014040ULL, 0x0000000000014040ULL, 0x0000800280000000ULL,
116 116 0x0000000280014040ULL, 0x0000000000000040ULL, 0x0000800280000040ULL, 0x0000000280014000ULL
117 117 },
118 118 {
119 119 0x4000020008100008ULL, 0x4000000008101008ULL, 0x4000000008101008ULL, 0x0000000000001000ULL,
120 120 0x0000020008101000ULL, 0x4000020000001008ULL, 0x4000020000000008ULL, 0x4000000008100008ULL,
121 121 0x0000000000000000ULL, 0x0000020008100000ULL, 0x0000020008100000ULL, 0x4000020008101008ULL,
122 122 0x4000000000001008ULL, 0x0000000000000000ULL, 0x0000020000001000ULL, 0x4000020000000008ULL,
123 123 0x4000000000000008ULL, 0x0000000008100000ULL, 0x0000020000000000ULL, 0x4000020008100008ULL,
124 124 0x0000000000001000ULL, 0x0000020000000000ULL, 0x4000000008100008ULL, 0x0000000008101000ULL,
125 125 0x4000020000001008ULL, 0x4000000000000008ULL, 0x0000000008101000ULL, 0x0000020000001000ULL,
126 126 0x0000000008100000ULL, 0x0000020008101000ULL, 0x4000020008101008ULL, 0x4000000000001008ULL,
127 127 0x0000020000001000ULL, 0x4000020000000008ULL, 0x0000020008100000ULL, 0x4000020008101008ULL,
128 128 0x4000000000001008ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000020008100000ULL,
129 129 0x0000000008101000ULL, 0x0000020000001000ULL, 0x4000020000001008ULL, 0x4000000000000008ULL,
130 130 0x4000020008100008ULL, 0x4000000008101008ULL, 0x4000000008101008ULL, 0x0000000000001000ULL,
131 131 0x4000020008101008ULL, 0x4000000000001008ULL, 0x4000000000000008ULL, 0x0000000008100000ULL,
132 132 0x4000020000000008ULL, 0x4000000008100008ULL, 0x0000020008101000ULL, 0x4000020000001008ULL,
133 133 0x4000000008100008ULL, 0x0000000008101000ULL, 0x0000020000000000ULL, 0x4000020008100008ULL,
134 134 0x0000000000001000ULL, 0x0000020000000000ULL, 0x0000000008100000ULL, 0x0000020008101000ULL
135 135 },
136 136 {
137 137 0x000000000000a000ULL, 0x000028080000a000ULL, 0x0000280800000000ULL, 0x100028000000a000ULL,
138 138 0x0000000800000000ULL, 0x000000000000a000ULL, 0x1000000000000000ULL, 0x0000280800000000ULL,
139 139 0x100000080000a000ULL, 0x0000000800000000ULL, 0x000028000000a000ULL, 0x100000080000a000ULL,
140 140 0x100028000000a000ULL, 0x1000280800000000ULL, 0x000000080000a000ULL, 0x1000000000000000ULL,
141 141 0x0000280000000000ULL, 0x1000000800000000ULL, 0x1000000800000000ULL, 0x0000000000000000ULL,
142 142 0x100000000000a000ULL, 0x100028080000a000ULL, 0x100028080000a000ULL, 0x000028000000a000ULL,
143 143 0x1000280800000000ULL, 0x100000000000a000ULL, 0x0000000000000000ULL, 0x1000280000000000ULL,
144 144 0x000028080000a000ULL, 0x0000280000000000ULL, 0x1000280000000000ULL, 0x000000080000a000ULL,
145 145 0x0000000800000000ULL, 0x100028000000a000ULL, 0x000000000000a000ULL, 0x0000280000000000ULL,
146 146 0x1000000000000000ULL, 0x0000280800000000ULL, 0x100028000000a000ULL, 0x100000080000a000ULL,
147 147 0x000028000000a000ULL, 0x1000000000000000ULL, 0x1000280800000000ULL, 0x000028080000a000ULL,
148 148 0x100000080000a000ULL, 0x000000000000a000ULL, 0x0000280000000000ULL, 0x1000280800000000ULL,
149 149 0x100028080000a000ULL, 0x000000080000a000ULL, 0x1000280000000000ULL, 0x100028080000a000ULL,
150 150 0x0000280800000000ULL, 0x0000000000000000ULL, 0x1000000800000000ULL, 0x1000280000000000ULL,
151 151 0x000000080000a000ULL, 0x000028000000a000ULL, 0x100000000000a000ULL, 0x0000000800000000ULL,
152 152 0x0000000000000000ULL, 0x1000000800000000ULL, 0x000028080000a000ULL, 0x100000000000a000ULL
153 153 },
154 154 {
155 155 0x0802000000000280ULL, 0x0802010000000000ULL, 0x0000000010000000ULL, 0x0802010010000280ULL,
156 156 0x0802010000000000ULL, 0x0000000000000280ULL, 0x0802010010000280ULL, 0x0000010000000000ULL,
157 157 0x0802000010000000ULL, 0x0000010010000280ULL, 0x0000010000000000ULL, 0x0802000000000280ULL,
158 158 0x0000010000000280ULL, 0x0802000010000000ULL, 0x0802000000000000ULL, 0x0000000010000280ULL,
159 159 0x0000000000000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL, 0x0000000010000000ULL,
160 160 0x0000010010000000ULL, 0x0802000010000280ULL, 0x0000000000000280ULL, 0x0802010000000280ULL,
161 161 0x0802010000000280ULL, 0x0000000000000000ULL, 0x0000010010000280ULL, 0x0802010010000000ULL,
162 162 0x0000000010000280ULL, 0x0000010010000000ULL, 0x0802010010000000ULL, 0x0802000000000000ULL,
163 163 0x0802000010000000ULL, 0x0000000000000280ULL, 0x0802010000000280ULL, 0x0000010010000000ULL,
164 164 0x0802010010000280ULL, 0x0000010000000000ULL, 0x0000000010000280ULL, 0x0802000000000280ULL,
165 165 0x0000010000000000ULL, 0x0802000010000000ULL, 0x0802000000000000ULL, 0x0000000010000280ULL,
166 166 0x0802000000000280ULL, 0x0802010010000280ULL, 0x0000010010000000ULL, 0x0802010000000000ULL,
167 167 0x0000010010000280ULL, 0x0802010010000000ULL, 0x0000000000000000ULL, 0x0802010000000280ULL,
168 168 0x0000000000000280ULL, 0x0000000010000000ULL, 0x0802010000000000ULL, 0x0000010010000280ULL,
169 169 0x0000000010000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL, 0x0000000000000000ULL,
170 170 0x0802010010000000ULL, 0x0802000000000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL
171 171 },
172 172 {
173 173 0x000000a000000000ULL, 0x800040a000000010ULL, 0x8000400000040010ULL, 0x0000000000000000ULL,
174 174 0x0000000000040000ULL, 0x8000400000040010ULL, 0x800000a000040010ULL, 0x000040a000040000ULL,
175 175 0x800040a000040010ULL, 0x000000a000000000ULL, 0x0000000000000000ULL, 0x8000400000000010ULL,
176 176 0x8000000000000010ULL, 0x0000400000000000ULL, 0x800040a000000010ULL, 0x8000000000040010ULL,
177 177 0x0000400000040000ULL, 0x800000a000040010ULL, 0x800000a000000010ULL, 0x0000400000040000ULL,
178 178 0x8000400000000010ULL, 0x000040a000000000ULL, 0x000040a000040000ULL, 0x800000a000000010ULL,
179 179 0x000040a000000000ULL, 0x0000000000040000ULL, 0x8000000000040010ULL, 0x800040a000040010ULL,
180 180 0x000000a000040000ULL, 0x8000000000000010ULL, 0x0000400000000000ULL, 0x000000a000040000ULL,
181 181 0x0000400000000000ULL, 0x000000a000040000ULL, 0x000000a000000000ULL, 0x8000400000040010ULL,
182 182 0x8000400000040010ULL, 0x800040a000000010ULL, 0x800040a000000010ULL, 0x8000000000000010ULL,
183 183 0x800000a000000010ULL, 0x0000400000000000ULL, 0x0000400000040000ULL, 0x000000a000000000ULL,
184 184 0x000040a000040000ULL, 0x8000000000040010ULL, 0x800000a000040010ULL, 0x000040a000040000ULL,
185 185 0x8000000000040010ULL, 0x8000400000000010ULL, 0x800040a000040010ULL, 0x000040a000000000ULL,
186 186 0x000000a000040000ULL, 0x0000000000000000ULL, 0x8000000000000010ULL, 0x800040a000040010ULL,
187 187 0x0000000000000000ULL, 0x800000a000040010ULL, 0x000040a000000000ULL, 0x0000000000040000ULL,
188 188 0x8000400000000010ULL, 0x0000400000040000ULL, 0x0000000000040000ULL, 0x800000a000000010ULL
189 189 },
190 190 {
191 191 0x0401000004080800ULL, 0x0000000004080000ULL, 0x0000000400000000ULL, 0x0401000404080800ULL,
192 192 0x0401000000000000ULL, 0x0401000004080800ULL, 0x0000000000000800ULL, 0x0401000000000000ULL,
193 193 0x0000000400000800ULL, 0x0401000400000000ULL, 0x0401000404080800ULL, 0x0000000404080000ULL,
194 194 0x0401000404080000ULL, 0x0000000404080800ULL, 0x0000000004080000ULL, 0x0000000000000800ULL,
195 195 0x0401000400000000ULL, 0x0401000000000800ULL, 0x0401000004080000ULL, 0x0000000004080800ULL,
196 196 0x0000000404080000ULL, 0x0000000400000800ULL, 0x0401000400000800ULL, 0x0401000404080000ULL,
197 197 0x0000000004080800ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0401000400000800ULL,
198 198 0x0401000000000800ULL, 0x0401000004080000ULL, 0x0000000404080800ULL, 0x0000000400000000ULL,
199 199 0x0000000404080800ULL, 0x0000000400000000ULL, 0x0401000404080000ULL, 0x0000000004080000ULL,
200 200 0x0000000000000800ULL, 0x0401000400000800ULL, 0x0000000004080000ULL, 0x0000000404080800ULL,
201 201 0x0401000004080000ULL, 0x0000000000000800ULL, 0x0401000000000800ULL, 0x0401000400000000ULL,
202 202 0x0401000400000800ULL, 0x0401000000000000ULL, 0x0000000400000000ULL, 0x0401000004080800ULL,
203 203 0x0000000000000000ULL, 0x0401000404080800ULL, 0x0000000400000800ULL, 0x0401000000000800ULL,
204 204 0x0401000400000000ULL, 0x0401000004080000ULL, 0x0401000004080800ULL, 0x0000000000000000ULL,
205 205 0x0401000404080800ULL, 0x0000000404080000ULL, 0x0000000404080000ULL, 0x0000000004080800ULL,
206 206 0x0000000004080800ULL, 0x0000000400000800ULL, 0x0401000000000000ULL, 0x0401000404080000ULL
207 207 }
208 208 /* END CSTYLED */
209 209 };
210 210
211 211
212 212 static const uint64_t ip_table[2][256]=
213 213 {
214 214 /* BEGIN CSTYLED */
215 215 {
216 216 0x0000000000000000ULL, 0x0000000000000400ULL, 0x0080000000000280ULL, 0x0080000000000680ULL,
217 217 0x0000000000400000ULL, 0x0000000000400400ULL, 0x0080000000400280ULL, 0x0080000000400680ULL,
218 218 0x0000000000280000ULL, 0x0000000000280400ULL, 0x0080000000280280ULL, 0x0080000000280680ULL,
219 219 0x0000000000680000ULL, 0x0000000000680400ULL, 0x0080000000680280ULL, 0x0080000000680680ULL,
220 220 0x0000000400000000ULL, 0x0000000400000400ULL, 0x0080000400000280ULL, 0x0080000400000680ULL,
221 221 0x0000000400400000ULL, 0x0000000400400400ULL, 0x0080000400400280ULL, 0x0080000400400680ULL,
222 222 0x0000000400280000ULL, 0x0000000400280400ULL, 0x0080000400280280ULL, 0x0080000400280680ULL,
223 223 0x0000000400680000ULL, 0x0000000400680400ULL, 0x0080000400680280ULL, 0x0080000400680680ULL,
224 224 0x0000000280000000ULL, 0x0000000280000400ULL, 0x0080000280000280ULL, 0x0080000280000680ULL,
225 225 0x0000000280400000ULL, 0x0000000280400400ULL, 0x0080000280400280ULL, 0x0080000280400680ULL,
226 226 0x0000000280280000ULL, 0x0000000280280400ULL, 0x0080000280280280ULL, 0x0080000280280680ULL,
227 227 0x0000000280680000ULL, 0x0000000280680400ULL, 0x0080000280680280ULL, 0x0080000280680680ULL,
228 228 0x0000000680000000ULL, 0x0000000680000400ULL, 0x0080000680000280ULL, 0x0080000680000680ULL,
229 229 0x0000000680400000ULL, 0x0000000680400400ULL, 0x0080000680400280ULL, 0x0080000680400680ULL,
230 230 0x0000000680280000ULL, 0x0000000680280400ULL, 0x0080000680280280ULL, 0x0080000680280680ULL,
231 231 0x0000000680680000ULL, 0x0000000680680400ULL, 0x0080000680680280ULL, 0x0080000680680680ULL,
232 232 0x0000400000000000ULL, 0x0000400000000400ULL, 0x0080400000000280ULL, 0x0080400000000680ULL,
233 233 0x0000400000400000ULL, 0x0000400000400400ULL, 0x0080400000400280ULL, 0x0080400000400680ULL,
234 234 0x0000400000280000ULL, 0x0000400000280400ULL, 0x0080400000280280ULL, 0x0080400000280680ULL,
235 235 0x0000400000680000ULL, 0x0000400000680400ULL, 0x0080400000680280ULL, 0x0080400000680680ULL,
236 236 0x0000400400000000ULL, 0x0000400400000400ULL, 0x0080400400000280ULL, 0x0080400400000680ULL,
237 237 0x0000400400400000ULL, 0x0000400400400400ULL, 0x0080400400400280ULL, 0x0080400400400680ULL,
238 238 0x0000400400280000ULL, 0x0000400400280400ULL, 0x0080400400280280ULL, 0x0080400400280680ULL,
239 239 0x0000400400680000ULL, 0x0000400400680400ULL, 0x0080400400680280ULL, 0x0080400400680680ULL,
240 240 0x0000400280000000ULL, 0x0000400280000400ULL, 0x0080400280000280ULL, 0x0080400280000680ULL,
241 241 0x0000400280400000ULL, 0x0000400280400400ULL, 0x0080400280400280ULL, 0x0080400280400680ULL,
242 242 0x0000400280280000ULL, 0x0000400280280400ULL, 0x0080400280280280ULL, 0x0080400280280680ULL,
243 243 0x0000400280680000ULL, 0x0000400280680400ULL, 0x0080400280680280ULL, 0x0080400280680680ULL,
244 244 0x0000400680000000ULL, 0x0000400680000400ULL, 0x0080400680000280ULL, 0x0080400680000680ULL,
245 245 0x0000400680400000ULL, 0x0000400680400400ULL, 0x0080400680400280ULL, 0x0080400680400680ULL,
246 246 0x0000400680280000ULL, 0x0000400680280400ULL, 0x0080400680280280ULL, 0x0080400680280680ULL,
247 247 0x0000400680680000ULL, 0x0000400680680400ULL, 0x0080400680680280ULL, 0x0080400680680680ULL,
248 248 0x0000280000000000ULL, 0x0000280000000400ULL, 0x0080280000000280ULL, 0x0080280000000680ULL,
249 249 0x0000280000400000ULL, 0x0000280000400400ULL, 0x0080280000400280ULL, 0x0080280000400680ULL,
250 250 0x0000280000280000ULL, 0x0000280000280400ULL, 0x0080280000280280ULL, 0x0080280000280680ULL,
251 251 0x0000280000680000ULL, 0x0000280000680400ULL, 0x0080280000680280ULL, 0x0080280000680680ULL,
252 252 0x0000280400000000ULL, 0x0000280400000400ULL, 0x0080280400000280ULL, 0x0080280400000680ULL,
253 253 0x0000280400400000ULL, 0x0000280400400400ULL, 0x0080280400400280ULL, 0x0080280400400680ULL,
254 254 0x0000280400280000ULL, 0x0000280400280400ULL, 0x0080280400280280ULL, 0x0080280400280680ULL,
255 255 0x0000280400680000ULL, 0x0000280400680400ULL, 0x0080280400680280ULL, 0x0080280400680680ULL,
256 256 0x0000280280000000ULL, 0x0000280280000400ULL, 0x0080280280000280ULL, 0x0080280280000680ULL,
257 257 0x0000280280400000ULL, 0x0000280280400400ULL, 0x0080280280400280ULL, 0x0080280280400680ULL,
258 258 0x0000280280280000ULL, 0x0000280280280400ULL, 0x0080280280280280ULL, 0x0080280280280680ULL,
259 259 0x0000280280680000ULL, 0x0000280280680400ULL, 0x0080280280680280ULL, 0x0080280280680680ULL,
260 260 0x0000280680000000ULL, 0x0000280680000400ULL, 0x0080280680000280ULL, 0x0080280680000680ULL,
261 261 0x0000280680400000ULL, 0x0000280680400400ULL, 0x0080280680400280ULL, 0x0080280680400680ULL,
262 262 0x0000280680280000ULL, 0x0000280680280400ULL, 0x0080280680280280ULL, 0x0080280680280680ULL,
263 263 0x0000280680680000ULL, 0x0000280680680400ULL, 0x0080280680680280ULL, 0x0080280680680680ULL,
264 264 0x0000680000000000ULL, 0x0000680000000400ULL, 0x0080680000000280ULL, 0x0080680000000680ULL,
265 265 0x0000680000400000ULL, 0x0000680000400400ULL, 0x0080680000400280ULL, 0x0080680000400680ULL,
266 266 0x0000680000280000ULL, 0x0000680000280400ULL, 0x0080680000280280ULL, 0x0080680000280680ULL,
267 267 0x0000680000680000ULL, 0x0000680000680400ULL, 0x0080680000680280ULL, 0x0080680000680680ULL,
268 268 0x0000680400000000ULL, 0x0000680400000400ULL, 0x0080680400000280ULL, 0x0080680400000680ULL,
269 269 0x0000680400400000ULL, 0x0000680400400400ULL, 0x0080680400400280ULL, 0x0080680400400680ULL,
270 270 0x0000680400280000ULL, 0x0000680400280400ULL, 0x0080680400280280ULL, 0x0080680400280680ULL,
271 271 0x0000680400680000ULL, 0x0000680400680400ULL, 0x0080680400680280ULL, 0x0080680400680680ULL,
272 272 0x0000680280000000ULL, 0x0000680280000400ULL, 0x0080680280000280ULL, 0x0080680280000680ULL,
273 273 0x0000680280400000ULL, 0x0000680280400400ULL, 0x0080680280400280ULL, 0x0080680280400680ULL,
274 274 0x0000680280280000ULL, 0x0000680280280400ULL, 0x0080680280280280ULL, 0x0080680280280680ULL,
275 275 0x0000680280680000ULL, 0x0000680280680400ULL, 0x0080680280680280ULL, 0x0080680280680680ULL,
276 276 0x0000680680000000ULL, 0x0000680680000400ULL, 0x0080680680000280ULL, 0x0080680680000680ULL,
277 277 0x0000680680400000ULL, 0x0000680680400400ULL, 0x0080680680400280ULL, 0x0080680680400680ULL,
278 278 0x0000680680280000ULL, 0x0000680680280400ULL, 0x0080680680280280ULL, 0x0080680680280680ULL,
279 279 0x0000680680680000ULL, 0x0000680680680400ULL, 0x0080680680680280ULL, 0x0080680680680680ULL
280 280 },
281 281 {
282 282 0x0000000000000000ULL, 0x0000000000005000ULL, 0x0000000000000800ULL, 0x0000000000005800ULL,
283 283 0x0000000005000000ULL, 0x0000000005005000ULL, 0x0000000005000800ULL, 0x0000000005005800ULL,
284 284 0x0000000000800000ULL, 0x0000000000805000ULL, 0x0000000000800800ULL, 0x0000000000805800ULL,
285 285 0x0000000005800000ULL, 0x0000000005805000ULL, 0x0000000005800800ULL, 0x0000000005805800ULL,
286 286 0x0000005000000000ULL, 0x0000005000005000ULL, 0x0000005000000800ULL, 0x0000005000005800ULL,
287 287 0x0000005005000000ULL, 0x0000005005005000ULL, 0x0000005005000800ULL, 0x0000005005005800ULL,
288 288 0x0000005000800000ULL, 0x0000005000805000ULL, 0x0000005000800800ULL, 0x0000005000805800ULL,
289 289 0x0000005005800000ULL, 0x0000005005805000ULL, 0x0000005005800800ULL, 0x0000005005805800ULL,
290 290 0x0000000800000000ULL, 0x0000000800005000ULL, 0x0000000800000800ULL, 0x0000000800005800ULL,
291 291 0x0000000805000000ULL, 0x0000000805005000ULL, 0x0000000805000800ULL, 0x0000000805005800ULL,
292 292 0x0000000800800000ULL, 0x0000000800805000ULL, 0x0000000800800800ULL, 0x0000000800805800ULL,
293 293 0x0000000805800000ULL, 0x0000000805805000ULL, 0x0000000805800800ULL, 0x0000000805805800ULL,
294 294 0x0000005800000000ULL, 0x0000005800005000ULL, 0x0000005800000800ULL, 0x0000005800005800ULL,
295 295 0x0000005805000000ULL, 0x0000005805005000ULL, 0x0000005805000800ULL, 0x0000005805005800ULL,
296 296 0x0000005800800000ULL, 0x0000005800805000ULL, 0x0000005800800800ULL, 0x0000005800805800ULL,
297 297 0x0000005805800000ULL, 0x0000005805805000ULL, 0x0000005805800800ULL, 0x0000005805805800ULL,
298 298 0x0005000000000004ULL, 0x0005000000005004ULL, 0x0005000000000804ULL, 0x0005000000005804ULL,
299 299 0x0005000005000004ULL, 0x0005000005005004ULL, 0x0005000005000804ULL, 0x0005000005005804ULL,
300 300 0x0005000000800004ULL, 0x0005000000805004ULL, 0x0005000000800804ULL, 0x0005000000805804ULL,
301 301 0x0005000005800004ULL, 0x0005000005805004ULL, 0x0005000005800804ULL, 0x0005000005805804ULL,
302 302 0x0005005000000004ULL, 0x0005005000005004ULL, 0x0005005000000804ULL, 0x0005005000005804ULL,
303 303 0x0005005005000004ULL, 0x0005005005005004ULL, 0x0005005005000804ULL, 0x0005005005005804ULL,
304 304 0x0005005000800004ULL, 0x0005005000805004ULL, 0x0005005000800804ULL, 0x0005005000805804ULL,
305 305 0x0005005005800004ULL, 0x0005005005805004ULL, 0x0005005005800804ULL, 0x0005005005805804ULL,
306 306 0x0005000800000004ULL, 0x0005000800005004ULL, 0x0005000800000804ULL, 0x0005000800005804ULL,
307 307 0x0005000805000004ULL, 0x0005000805005004ULL, 0x0005000805000804ULL, 0x0005000805005804ULL,
308 308 0x0005000800800004ULL, 0x0005000800805004ULL, 0x0005000800800804ULL, 0x0005000800805804ULL,
309 309 0x0005000805800004ULL, 0x0005000805805004ULL, 0x0005000805800804ULL, 0x0005000805805804ULL,
310 310 0x0005005800000004ULL, 0x0005005800005004ULL, 0x0005005800000804ULL, 0x0005005800005804ULL,
311 311 0x0005005805000004ULL, 0x0005005805005004ULL, 0x0005005805000804ULL, 0x0005005805005804ULL,
312 312 0x0005005800800004ULL, 0x0005005800805004ULL, 0x0005005800800804ULL, 0x0005005800805804ULL,
313 313 0x0005005805800004ULL, 0x0005005805805004ULL, 0x0005005805800804ULL, 0x0005005805805804ULL,
314 314 0x0000800000000000ULL, 0x0000800000005000ULL, 0x0000800000000800ULL, 0x0000800000005800ULL,
315 315 0x0000800005000000ULL, 0x0000800005005000ULL, 0x0000800005000800ULL, 0x0000800005005800ULL,
316 316 0x0000800000800000ULL, 0x0000800000805000ULL, 0x0000800000800800ULL, 0x0000800000805800ULL,
317 317 0x0000800005800000ULL, 0x0000800005805000ULL, 0x0000800005800800ULL, 0x0000800005805800ULL,
318 318 0x0000805000000000ULL, 0x0000805000005000ULL, 0x0000805000000800ULL, 0x0000805000005800ULL,
319 319 0x0000805005000000ULL, 0x0000805005005000ULL, 0x0000805005000800ULL, 0x0000805005005800ULL,
320 320 0x0000805000800000ULL, 0x0000805000805000ULL, 0x0000805000800800ULL, 0x0000805000805800ULL,
321 321 0x0000805005800000ULL, 0x0000805005805000ULL, 0x0000805005800800ULL, 0x0000805005805800ULL,
322 322 0x0000800800000000ULL, 0x0000800800005000ULL, 0x0000800800000800ULL, 0x0000800800005800ULL,
323 323 0x0000800805000000ULL, 0x0000800805005000ULL, 0x0000800805000800ULL, 0x0000800805005800ULL,
324 324 0x0000800800800000ULL, 0x0000800800805000ULL, 0x0000800800800800ULL, 0x0000800800805800ULL,
325 325 0x0000800805800000ULL, 0x0000800805805000ULL, 0x0000800805800800ULL, 0x0000800805805800ULL,
326 326 0x0000805800000000ULL, 0x0000805800005000ULL, 0x0000805800000800ULL, 0x0000805800005800ULL,
327 327 0x0000805805000000ULL, 0x0000805805005000ULL, 0x0000805805000800ULL, 0x0000805805005800ULL,
328 328 0x0000805800800000ULL, 0x0000805800805000ULL, 0x0000805800800800ULL, 0x0000805800805800ULL,
329 329 0x0000805805800000ULL, 0x0000805805805000ULL, 0x0000805805800800ULL, 0x0000805805805800ULL,
330 330 0x0005800000000004ULL, 0x0005800000005004ULL, 0x0005800000000804ULL, 0x0005800000005804ULL,
331 331 0x0005800005000004ULL, 0x0005800005005004ULL, 0x0005800005000804ULL, 0x0005800005005804ULL,
332 332 0x0005800000800004ULL, 0x0005800000805004ULL, 0x0005800000800804ULL, 0x0005800000805804ULL,
333 333 0x0005800005800004ULL, 0x0005800005805004ULL, 0x0005800005800804ULL, 0x0005800005805804ULL,
334 334 0x0005805000000004ULL, 0x0005805000005004ULL, 0x0005805000000804ULL, 0x0005805000005804ULL,
335 335 0x0005805005000004ULL, 0x0005805005005004ULL, 0x0005805005000804ULL, 0x0005805005005804ULL,
336 336 0x0005805000800004ULL, 0x0005805000805004ULL, 0x0005805000800804ULL, 0x0005805000805804ULL,
337 337 0x0005805005800004ULL, 0x0005805005805004ULL, 0x0005805005800804ULL, 0x0005805005805804ULL,
338 338 0x0005800800000004ULL, 0x0005800800005004ULL, 0x0005800800000804ULL, 0x0005800800005804ULL,
339 339 0x0005800805000004ULL, 0x0005800805005004ULL, 0x0005800805000804ULL, 0x0005800805005804ULL,
340 340 0x0005800800800004ULL, 0x0005800800805004ULL, 0x0005800800800804ULL, 0x0005800800805804ULL,
341 341 0x0005800805800004ULL, 0x0005800805805004ULL, 0x0005800805800804ULL, 0x0005800805805804ULL,
342 342 0x0005805800000004ULL, 0x0005805800005004ULL, 0x0005805800000804ULL, 0x0005805800005804ULL,
343 343 0x0005805805000004ULL, 0x0005805805005004ULL, 0x0005805805000804ULL, 0x0005805805005804ULL,
344 344 0x0005805800800004ULL, 0x0005805800805004ULL, 0x0005805800800804ULL, 0x0005805800805804ULL,
345 345 0x0005805805800004ULL, 0x0005805805805004ULL, 0x0005805805800804ULL, 0x0005805805805804ULL
346 346 }
347 347 /* END CSTYLED */
348 348 };
349 349
350 350 static const uint32_t fp_table[256]=
351 351 {
352 352 0x00000000, 0x80000000, 0x00800000, 0x80800000,
353 353 0x00008000, 0x80008000, 0x00808000, 0x80808000,
354 354 0x00000080, 0x80000080, 0x00800080, 0x80800080,
355 355 0x00008080, 0x80008080, 0x00808080, 0x80808080,
356 356 0x40000000, 0xc0000000, 0x40800000, 0xc0800000,
357 357 0x40008000, 0xc0008000, 0x40808000, 0xc0808000,
358 358 0x40000080, 0xc0000080, 0x40800080, 0xc0800080,
359 359 0x40008080, 0xc0008080, 0x40808080, 0xc0808080,
360 360 0x00400000, 0x80400000, 0x00c00000, 0x80c00000,
361 361 0x00408000, 0x80408000, 0x00c08000, 0x80c08000,
362 362 0x00400080, 0x80400080, 0x00c00080, 0x80c00080,
363 363 0x00408080, 0x80408080, 0x00c08080, 0x80c08080,
364 364 0x40400000, 0xc0400000, 0x40c00000, 0xc0c00000,
365 365 0x40408000, 0xc0408000, 0x40c08000, 0xc0c08000,
366 366 0x40400080, 0xc0400080, 0x40c00080, 0xc0c00080,
367 367 0x40408080, 0xc0408080, 0x40c08080, 0xc0c08080,
368 368 0x00004000, 0x80004000, 0x00804000, 0x80804000,
369 369 0x0000c000, 0x8000c000, 0x0080c000, 0x8080c000,
370 370 0x00004080, 0x80004080, 0x00804080, 0x80804080,
371 371 0x0000c080, 0x8000c080, 0x0080c080, 0x8080c080,
372 372 0x40004000, 0xc0004000, 0x40804000, 0xc0804000,
373 373 0x4000c000, 0xc000c000, 0x4080c000, 0xc080c000,
374 374 0x40004080, 0xc0004080, 0x40804080, 0xc0804080,
375 375 0x4000c080, 0xc000c080, 0x4080c080, 0xc080c080,
376 376 0x00404000, 0x80404000, 0x00c04000, 0x80c04000,
377 377 0x0040c000, 0x8040c000, 0x00c0c000, 0x80c0c000,
378 378 0x00404080, 0x80404080, 0x00c04080, 0x80c04080,
379 379 0x0040c080, 0x8040c080, 0x00c0c080, 0x80c0c080,
380 380 0x40404000, 0xc0404000, 0x40c04000, 0xc0c04000,
381 381 0x4040c000, 0xc040c000, 0x40c0c000, 0xc0c0c000,
382 382 0x40404080, 0xc0404080, 0x40c04080, 0xc0c04080,
383 383 0x4040c080, 0xc040c080, 0x40c0c080, 0xc0c0c080,
384 384 0x00000040, 0x80000040, 0x00800040, 0x80800040,
385 385 0x00008040, 0x80008040, 0x00808040, 0x80808040,
386 386 0x000000c0, 0x800000c0, 0x008000c0, 0x808000c0,
387 387 0x000080c0, 0x800080c0, 0x008080c0, 0x808080c0,
388 388 0x40000040, 0xc0000040, 0x40800040, 0xc0800040,
389 389 0x40008040, 0xc0008040, 0x40808040, 0xc0808040,
390 390 0x400000c0, 0xc00000c0, 0x408000c0, 0xc08000c0,
391 391 0x400080c0, 0xc00080c0, 0x408080c0, 0xc08080c0,
392 392 0x00400040, 0x80400040, 0x00c00040, 0x80c00040,
393 393 0x00408040, 0x80408040, 0x00c08040, 0x80c08040,
394 394 0x004000c0, 0x804000c0, 0x00c000c0, 0x80c000c0,
395 395 0x004080c0, 0x804080c0, 0x00c080c0, 0x80c080c0,
396 396 0x40400040, 0xc0400040, 0x40c00040, 0xc0c00040,
397 397 0x40408040, 0xc0408040, 0x40c08040, 0xc0c08040,
398 398 0x404000c0, 0xc04000c0, 0x40c000c0, 0xc0c000c0,
399 399 0x404080c0, 0xc04080c0, 0x40c080c0, 0xc0c080c0,
400 400 0x00004040, 0x80004040, 0x00804040, 0x80804040,
401 401 0x0000c040, 0x8000c040, 0x0080c040, 0x8080c040,
402 402 0x000040c0, 0x800040c0, 0x008040c0, 0x808040c0,
403 403 0x0000c0c0, 0x8000c0c0, 0x0080c0c0, 0x8080c0c0,
404 404 0x40004040, 0xc0004040, 0x40804040, 0xc0804040,
405 405 0x4000c040, 0xc000c040, 0x4080c040, 0xc080c040,
406 406 0x400040c0, 0xc00040c0, 0x408040c0, 0xc08040c0,
407 407 0x4000c0c0, 0xc000c0c0, 0x4080c0c0, 0xc080c0c0,
408 408 0x00404040, 0x80404040, 0x00c04040, 0x80c04040,
409 409 0x0040c040, 0x8040c040, 0x00c0c040, 0x80c0c040,
410 410 0x004040c0, 0x804040c0, 0x00c040c0, 0x80c040c0,
411 411 0x0040c0c0, 0x8040c0c0, 0x00c0c0c0, 0x80c0c0c0,
412 412 0x40404040, 0xc0404040, 0x40c04040, 0xc0c04040,
413 413 0x4040c040, 0xc040c040, 0x40c0c040, 0xc0c0c040,
414 414 0x404040c0, 0xc04040c0, 0x40c040c0, 0xc0c040c0,
415 415 0x4040c0c0, 0xc040c0c0, 0x40c0c0c0, 0xc0c0c0c0
416 416 };
417 417
418 418 static const uint64_t all_a = 0xaaaaaaaaaaaaaaaaULL;
419 419 static const uint64_t all_5 = 0x5555555555555555ULL;
420 420 static const uint64_t top_1 = 0xfc000000000000ULL;
421 421 static const uint64_t mid_4 = 0x3fffffc000000ULL;
422 422 static const uint64_t low_3 = 0x3ffff00ULL;
423 423
424 424
425 425 static void
426 426 des_ip(uint64_t *l, uint64_t *r, uint64_t pt)
427 427 {
428 428 uint64_t a, b;
429 429
430 430 a = pt & all_a;
431 431 b = pt & all_5;
432 432 a = a | (a << 7);
433 433 b = b | (b >> 7);
434 434
435 435 b = (ip_table[0][(b >> 48) & 255ULL]) |
436 436 (ip_table[1][(b >> 32) & 255ULL]) |
437 437 (ip_table[0][(b >> 16) & 255ULL] << 6) |
438 438 (ip_table[1][b & 255ULL] << 6);
439 439
440 440 a = (ip_table[0][(a >> 56) & 255]) |
441 441 (ip_table[1][(a >> 40) & 255]) |
442 442 (ip_table[0][(a >> 24) & 255] << 6) |
443 443 (ip_table[1][(a >> 8) & 255] << 6);
444 444
445 445 *l = ((b & top_1) << 8) |
446 446 (b & mid_4) |
447 447 ((b & low_3) >> 5);
448 448
449 449 *r = ((a & top_1) << 8) |
450 450 (a & mid_4) |
451 451 ((a & low_3) >> 5);
452 452 }
453 453
454 454
455 455 static uint64_t
456 456 des_fp(uint64_t l, uint64_t r)
457 457 {
458 458 uint32_t upper, lower;
459 459
460 460 lower = fp_table[((l >> 55) & 240) | ((r >> 59) & 15)] |
461 461 (fp_table[((l >> 35) & 240) | ((r>>39) & 15)] >> 2) |
462 462 (fp_table[((l >> 23) & 240) | ((r >> 27) & 15)] >> 4) |
463 463 (fp_table[((l >> 6) & 240) | ((r >> 10) & 15)] >> 6);
464 464
465 465 upper = fp_table[((l >> 41) & 240) | ((r >> 45) & 15)] |
466 466 (fp_table[((l >> 29) & 240) | ((r >> 33) & 15)] >> 2) |
467 467 (fp_table[((l >> 12) & 240) | ((r >> 16) & 15)] >> 4) |
468 468 (fp_table[(l & 240) | (r >> 4) & 15] >> 6);
469 469
470 470 return ((((uint64_t)upper) << 32) | (uint64_t)lower);
471 471
472 472 }
473 473
474 474 uint64_t
475 475 des_crypt_impl(uint64_t *ks, uint64_t block, int one_or_three)
476 476 {
477 477 int i, j;
478 478 uint64_t l, r, t;
479 479
480 480 des_ip(&l, &r, block);
481 481 for (j = 0; j < one_or_three; j++) {
482 482 for (i = j * 16; i < (j + 1) * 16; i++) {
483 483 t = r ^ ks[i];
484 484 t = sbox_table[0][t >> 58] |
485 485 sbox_table[1][(t >> 44) & 63] |
486 486 sbox_table[2][(t >> 38) & 63] |
487 487 sbox_table[3][(t >> 32) & 63] |
488 488 sbox_table[4][(t >> 26) & 63] |
489 489 sbox_table[5][(t >> 15) & 63] |
490 490 sbox_table[6][(t >> 9) & 63] |
491 491 sbox_table[7][(t >> 3) & 63];
492 492 t = t^l;
493 493 l = r;
494 494 r = t;
495 495 }
496 496 r = l;
497 497 l = t;
498 498 }
499 499
500 500 return (des_fp(l, r));
501 501 }
502 502 #endif /* !sun4u */
503 503
504 504 /* EXPORT DELETE END */
505 505
506 506 int
507 507 des3_crunch_block(const void *cookie, const uint8_t block[DES_BLOCK_LEN],
508 508 uint8_t out_block[DES_BLOCK_LEN], boolean_t decrypt)
509 509 {
510 510 /* EXPORT DELETE START */
511 511 keysched3_t *ksch = (keysched3_t *)cookie;
512 512
513 513 /*
514 514 * The code below, that is always executed on LITTLE_ENDIAN machines,
515 515 * reverses bytes in the block. On BIG_ENDIAN, the same code
516 516 * copies the block without reversing bytes.
517 517 */
518 518 #ifdef _BIG_ENDIAN
519 519 if (IS_P2ALIGNED(block, sizeof (uint64_t)) &&
520 520 IS_P2ALIGNED(out_block, sizeof (uint64_t))) {
521 521 if (decrypt == B_TRUE)
522 522 /* LINTED */
523 523 *(uint64_t *)out_block = des_crypt_impl(
524 524 ksch->ksch_decrypt, /* LINTED */
525 525 *(uint64_t *)block, 3);
526 526 else
|
↓ open down ↓ |
526 lines elided |
↑ open up ↑ |
527 527 /* LINTED */
528 528 *(uint64_t *)out_block = des_crypt_impl(
529 529 ksch->ksch_encrypt, /* LINTED */
530 530 *(uint64_t *)block, 3);
531 531 } else
532 532 #endif /* _BIG_ENDIAN */
533 533 {
534 534 uint64_t tmp;
535 535
536 536 #ifdef UNALIGNED_POINTERS_PERMITTED
537 - tmp = htonll(*(uint64_t *)&block[0]);
537 + tmp = htonll(*(uint64_t *)(void *)&block[0]);
538 538 #else
539 539 tmp = (((uint64_t)block[0] << 56) | ((uint64_t)block[1] << 48) |
540 540 ((uint64_t)block[2] << 40) | ((uint64_t)block[3] << 32) |
541 541 ((uint64_t)block[4] << 24) | ((uint64_t)block[5] << 16) |
542 542 ((uint64_t)block[6] << 8) | (uint64_t)block[7]);
543 543 #endif /* UNALIGNED_POINTERS_PERMITTED */
544 544
545 545 if (decrypt == B_TRUE)
546 546 tmp = des_crypt_impl(ksch->ksch_decrypt, tmp, 3);
547 547 else
548 548 tmp = des_crypt_impl(ksch->ksch_encrypt, tmp, 3);
549 549
550 550 #ifdef UNALIGNED_POINTERS_PERMITTED
551 - *(uint64_t *)&out_block[0] = htonll(tmp);
551 + *(uint64_t *)(void *)&out_block[0] = htonll(tmp);
552 552 #else
553 553 out_block[0] = tmp >> 56;
554 554 out_block[1] = tmp >> 48;
555 555 out_block[2] = tmp >> 40;
556 556 out_block[3] = tmp >> 32;
557 557 out_block[4] = tmp >> 24;
558 558 out_block[5] = tmp >> 16;
559 559 out_block[6] = tmp >> 8;
560 560 out_block[7] = (uint8_t)tmp;
561 561 #endif /* UNALIGNED_POINTERS_PERMITTED */
562 562 }
563 563 /* EXPORT DELETE END */
564 564 return (CRYPTO_SUCCESS);
565 565 }
566 566
567 567 int
568 568 des_crunch_block(const void *cookie, const uint8_t block[DES_BLOCK_LEN],
569 569 uint8_t out_block[DES_BLOCK_LEN], boolean_t decrypt)
570 570 {
571 571 /* EXPORT DELETE START */
572 572 keysched_t *ksch = (keysched_t *)cookie;
573 573
574 574 /*
575 575 * The code below, that is always executed on LITTLE_ENDIAN machines,
576 576 * reverses bytes in the block. On BIG_ENDIAN, the same code
577 577 * copies the block without reversing bytes.
578 578 */
579 579 #ifdef _BIG_ENDIAN
580 580 if (IS_P2ALIGNED(block, sizeof (uint64_t)) &&
581 581 IS_P2ALIGNED(out_block, sizeof (uint64_t))) {
582 582 if (decrypt == B_TRUE)
583 583 /* LINTED */
584 584 *(uint64_t *)out_block = des_crypt_impl(
585 585 ksch->ksch_decrypt, /* LINTED */
586 586 *(uint64_t *)block, 1);
587 587 else
588 588 /* LINTED */
|
↓ open down ↓ |
27 lines elided |
↑ open up ↑ |
589 589 *(uint64_t *)out_block = des_crypt_impl(
590 590 ksch->ksch_encrypt, /* LINTED */
591 591 *(uint64_t *)block, 1);
592 592
593 593 } else
594 594 #endif /* _BIG_ENDIAN */
595 595 {
596 596 uint64_t tmp;
597 597
598 598 #ifdef UNALIGNED_POINTERS_PERMITTED
599 - tmp = htonll(*(uint64_t *)&block[0]);
599 + tmp = htonll(*(uint64_t *)(void *)&block[0]);
600 600 #else
601 601 tmp = (((uint64_t)block[0] << 56) | ((uint64_t)block[1] << 48) |
602 602 ((uint64_t)block[2] << 40) | ((uint64_t)block[3] << 32) |
603 603 ((uint64_t)block[4] << 24) | ((uint64_t)block[5] << 16) |
604 604 ((uint64_t)block[6] << 8) | (uint64_t)block[7]);
605 605 #endif /* UNALIGNED_POINTERS_PERMITTED */
606 606
607 607
608 608 if (decrypt == B_TRUE)
609 609 tmp = des_crypt_impl(ksch->ksch_decrypt, tmp, 1);
610 610 else
611 611 tmp = des_crypt_impl(ksch->ksch_encrypt, tmp, 1);
612 612
613 613 #ifdef UNALIGNED_POINTERS_PERMITTED
614 - *(uint64_t *)&out_block[0] = htonll(tmp);
614 + *(uint64_t *)(void *)&out_block[0] = htonll(tmp);
615 615 #else
616 616 out_block[0] = tmp >> 56;
617 617 out_block[1] = tmp >> 48;
618 618 out_block[2] = tmp >> 40;
619 619 out_block[3] = tmp >> 32;
620 620 out_block[4] = tmp >> 24;
621 621 out_block[5] = tmp >> 16;
622 622 out_block[6] = tmp >> 8;
623 623 out_block[7] = (uint8_t)tmp;
624 624 #endif /* UNALIGNED_POINTERS_PERMITTED */
625 625 }
626 626 /* EXPORT DELETE END */
627 627 return (CRYPTO_SUCCESS);
628 628 }
629 629
630 630 static boolean_t
631 631 keycheck(uint8_t *key, uint8_t *corrected_key)
632 632 {
633 633 /* EXPORT DELETE START */
634 634 uint64_t key_so_far;
635 635 uint_t i;
636 636 /*
637 637 * Table of weak and semi-weak keys. Fortunately, weak keys are
638 638 * endian-independent, and some semi-weak keys can be paired up in
639 639 * endian-opposite order. Since keys are stored as uint64_t's,
640 640 * use the ifdef _LITTLE_ENDIAN where appropriate.
641 641 */
642 642 static uint64_t des_weak_keys[] = {
643 643 /* Really weak keys. Byte-order independent values. */
644 644 0x0101010101010101ULL,
645 645 0x1f1f1f1f0e0e0e0eULL,
646 646 0xe0e0e0e0f1f1f1f1ULL,
647 647 0xfefefefefefefefeULL,
648 648
649 649 /* Semi-weak (and a few possibly-weak) keys. */
650 650
651 651 /* Byte-order independent semi-weak keys. */
652 652 0x01fe01fe01fe01feULL, 0xfe01fe01fe01fe01ULL,
653 653
654 654 /* Byte-order dependent semi-weak keys. */
655 655 #ifdef _LITTLE_ENDIAN
656 656 0xf10ef10ee01fe01fULL, 0x0ef10ef11fe01fe0ULL,
657 657 0x01f101f101e001e0ULL, 0xf101f101e001e001ULL,
658 658 0x0efe0efe1ffe1ffeULL, 0xfe0efe0efe1ffe1fULL,
659 659 0x010e010e011f011fULL, 0x0e010e011f011f01ULL,
660 660 0xf1fef1fee0fee0feULL, 0xfef1fef1fee0fee0ULL,
661 661 #else /* Big endian */
662 662 0x1fe01fe00ef10ef1ULL, 0xe01fe01ff10ef10eULL,
663 663 0x01e001e001f101f1ULL, 0xe001e001f101f101ULL,
664 664 0x1ffe1ffe0efe0efeULL, 0xfe1ffe1ffe0efe0eULL,
665 665 0x011f011f010e010eULL, 0x1f011f010e010e01ULL,
|
↓ open down ↓ |
41 lines elided |
↑ open up ↑ |
666 666 0xe0fee0fef1fef1feULL, 0xfee0fee0fef1fef1ULL,
667 667 #endif /* _LITTLE_ENDIAN */
668 668
669 669 /* We'll save the other possibly-weak keys for the future. */
670 670 };
671 671
672 672 if (key == NULL)
673 673 return (B_FALSE);
674 674
675 675 #ifdef UNALIGNED_POINTERS_PERMITTED
676 - key_so_far = htonll(*(uint64_t *)&key[0]);
676 + key_so_far = htonll(*(uint64_t *)(void *)&key[0]);
677 677 #else
678 678 /*
679 679 * The code below reverses the bytes on LITTLE_ENDIAN machines.
680 680 * On BIG_ENDIAN, the same code copies without reversing
681 681 * the bytes.
682 682 */
683 683 key_so_far = (((uint64_t)key[0] << 56) | ((uint64_t)key[1] << 48) |
684 684 ((uint64_t)key[2] << 40) | ((uint64_t)key[3] << 32) |
685 685 ((uint64_t)key[4] << 24) | ((uint64_t)key[5] << 16) |
686 686 ((uint64_t)key[6] << 8) | (uint64_t)key[7]);
687 687 #endif /* UNALIGNED_POINTERS_PERMITTED */
688 688
689 689 /*
690 690 * Fix parity.
691 691 */
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
692 692 fix_des_parity(&key_so_far);
693 693
694 694 /* Do weak key check itself. */
695 695 for (i = 0; i < (sizeof (des_weak_keys) / sizeof (uint64_t)); i++)
696 696 if (key_so_far == des_weak_keys[i]) {
697 697 return (B_FALSE);
698 698 }
699 699
700 700 if (corrected_key != NULL) {
701 701 #ifdef UNALIGNED_POINTERS_PERMITTED
702 - *(uint64_t *)&corrected_key[0] = htonll(key_so_far);
702 + *(uint64_t *)(void *)&corrected_key[0] = htonll(key_so_far);
703 703 #else
704 704 /*
705 705 * The code below reverses the bytes on LITTLE_ENDIAN machines.
706 706 * On BIG_ENDIAN, the same code copies without reversing
707 707 * the bytes.
708 708 */
709 709 corrected_key[0] = key_so_far >> 56;
710 710 corrected_key[1] = key_so_far >> 48;
711 711 corrected_key[2] = key_so_far >> 40;
712 712 corrected_key[3] = key_so_far >> 32;
713 713 corrected_key[4] = key_so_far >> 24;
714 714 corrected_key[5] = key_so_far >> 16;
715 715 corrected_key[6] = key_so_far >> 8;
716 716 corrected_key[7] = (uint8_t)key_so_far;
717 717 #endif /* UNALIGNED_POINTERS_PERMITTED */
718 718 }
719 719 /* EXPORT DELETE END */
720 720 return (B_TRUE);
721 721 }
722 722
723 723 static boolean_t
724 724 des3_keycheck(uint8_t *key, uint8_t *corrected_key)
725 725 {
726 726 /* EXPORT DELETE START */
727 727 uint64_t aligned_key[DES3_KEYSIZE / sizeof (uint64_t)];
728 728 uint64_t key_so_far, scratch, *currentkey;
729 729 uint_t j, num_weakkeys = 0;
730 730
731 731 if (key == NULL) {
732 732 return (B_FALSE);
733 733 }
734 734
735 735 if (!IS_P2ALIGNED(key, sizeof (uint64_t))) {
736 736 bcopy(key, aligned_key, DES3_KEYSIZE);
737 737 currentkey = (uint64_t *)aligned_key;
738 738 } else {
739 739 /* LINTED */
740 740 currentkey = (uint64_t *)key;
741 741 }
742 742
743 743 for (j = 0; j < 3; j++) {
744 744 key_so_far = currentkey[j];
745 745
746 746 if (!keycheck((uint8_t *)&key_so_far, (uint8_t *)&scratch)) {
747 747 if (++num_weakkeys > 1) {
748 748 return (B_FALSE);
749 749 }
750 750 /*
751 751 * We found a weak key, but since
752 752 * we've only found one weak key,
753 753 * we can not reject the whole 3DES
754 754 * set of keys as weak.
755 755 *
756 756 * Break from the weak key loop
757 757 * (since this DES key is weak) and
758 758 * continue on.
759 759 */
760 760 }
761 761
762 762 currentkey[j] = scratch;
763 763 }
764 764
765 765 /*
766 766 * Perform key equivalence checks, now that parity is properly set.
767 767 * 1st and 2nd keys must be unique, the 3rd key can be the same as
768 768 * the 1st key for the 2 key variant of 3DES.
769 769 */
770 770 if (currentkey[0] == currentkey[1] || currentkey[1] == currentkey[2])
771 771 return (B_FALSE);
772 772
773 773 if (corrected_key != NULL) {
774 774 bcopy(currentkey, corrected_key, DES3_KEYSIZE);
775 775 }
776 776
777 777 /* EXPORT DELETE END */
778 778 return (B_TRUE);
779 779 }
780 780
781 781 boolean_t
782 782 des_keycheck(uint8_t *key, des_strength_t strength, uint8_t *corrected_key)
783 783 {
784 784 if (strength == DES) {
785 785 return (keycheck(key, corrected_key));
786 786 } else if (strength == DES3) {
787 787 return (des3_keycheck(key, corrected_key));
788 788 } else {
789 789 return (B_FALSE);
790 790 }
791 791 }
792 792
793 793 void
794 794 des_parity_fix(uint8_t *key, des_strength_t strength, uint8_t *corrected_key)
795 795 {
796 796 /* EXPORT DELETE START */
797 797 uint64_t aligned_key[DES3_KEYSIZE / sizeof (uint64_t)];
798 798 uint8_t *paritied_key;
799 799 uint64_t key_so_far;
800 800 int i = 0, offset = 0;
|
↓ open down ↓ |
88 lines elided |
↑ open up ↑ |
801 801
802 802 if (strength == DES)
803 803 bcopy(key, aligned_key, DES_KEYSIZE);
804 804 else
805 805 bcopy(key, aligned_key, DES3_KEYSIZE);
806 806
807 807 paritied_key = (uint8_t *)aligned_key;
808 808 while (strength > i) {
809 809 offset = 8 * i;
810 810 #ifdef UNALIGNED_POINTERS_PERMITTED
811 - key_so_far = htonll(*(uint64_t *)&paritied_key[offset]);
811 + key_so_far = htonll(*(uint64_t *)(void *)&paritied_key[offset]);
812 812 #else
813 813 key_so_far = (((uint64_t)paritied_key[offset + 0] << 56) |
814 814 ((uint64_t)paritied_key[offset + 1] << 48) |
815 815 ((uint64_t)paritied_key[offset + 2] << 40) |
816 816 ((uint64_t)paritied_key[offset + 3] << 32) |
817 817 ((uint64_t)paritied_key[offset + 4] << 24) |
818 818 ((uint64_t)paritied_key[offset + 5] << 16) |
819 819 ((uint64_t)paritied_key[offset + 6] << 8) |
820 820 (uint64_t)paritied_key[offset + 7]);
821 821 #endif /* UNALIGNED_POINTERS_PERMITTED */
822 822
823 823 fix_des_parity(&key_so_far);
824 824
825 825 #ifdef UNALIGNED_POINTERS_PERMITTED
826 - *(uint64_t *)&paritied_key[offset] = htonll(key_so_far);
826 + *(uint64_t *)(void *)&paritied_key[offset] = htonll(key_so_far);
827 827 #else
828 828 paritied_key[offset + 0] = key_so_far >> 56;
829 829 paritied_key[offset + 1] = key_so_far >> 48;
830 830 paritied_key[offset + 2] = key_so_far >> 40;
831 831 paritied_key[offset + 3] = key_so_far >> 32;
832 832 paritied_key[offset + 4] = key_so_far >> 24;
833 833 paritied_key[offset + 5] = key_so_far >> 16;
834 834 paritied_key[offset + 6] = key_so_far >> 8;
835 835 paritied_key[offset + 7] = (uint8_t)key_so_far;
836 836 #endif /* UNALIGNED_POINTERS_PERMITTED */
837 837
838 838 i++;
839 839 }
840 840
841 841 bcopy(paritied_key, corrected_key, DES_KEYSIZE * strength);
842 842 /* EXPORT DELETE END */
843 843 }
844 844
845 845
846 846 /*
847 847 * Initialize key schedule for DES, DES2, and DES3
848 848 */
849 849 void
850 850 des_init_keysched(uint8_t *cipherKey, des_strength_t strength, void *ks)
851 851 {
852 852 /* EXPORT DELETE START */
853 853 uint64_t *encryption_ks;
854 854 uint64_t *decryption_ks;
855 855 uint64_t keysched[48];
856 856 uint64_t key_uint64[3];
857 857 uint64_t tmp;
858 858 uint_t keysize, i, j;
859 859
860 860 switch (strength) {
861 861 case DES:
862 862 keysize = DES_KEYSIZE;
863 863 encryption_ks = ((keysched_t *)ks)->ksch_encrypt;
864 864 decryption_ks = ((keysched_t *)ks)->ksch_decrypt;
865 865 break;
866 866 case DES2:
867 867 keysize = DES2_KEYSIZE;
868 868 encryption_ks = ((keysched3_t *)ks)->ksch_encrypt;
869 869 decryption_ks = ((keysched3_t *)ks)->ksch_decrypt;
870 870 break;
871 871 case DES3:
872 872 keysize = DES3_KEYSIZE;
873 873 encryption_ks = ((keysched3_t *)ks)->ksch_encrypt;
874 874 decryption_ks = ((keysched3_t *)ks)->ksch_decrypt;
875 875 }
876 876
877 877 /*
878 878 * The code below, that is always executed on LITTLE_ENDIAN machines,
879 879 * reverses every 8 bytes in the key. On BIG_ENDIAN, the same code
880 880 * copies the key without reversing bytes.
881 881 */
882 882 #ifdef _BIG_ENDIAN
|
↓ open down ↓ |
46 lines elided |
↑ open up ↑ |
883 883 if (IS_P2ALIGNED(cipherKey, sizeof (uint64_t))) {
884 884 for (i = 0, j = 0; j < keysize; i++, j += 8) {
885 885 /* LINTED: pointer alignment */
886 886 key_uint64[i] = *((uint64_t *)&cipherKey[j]);
887 887 }
888 888 } else
889 889 #endif /* _BIG_ENDIAN */
890 890 {
891 891 for (i = 0, j = 0; j < keysize; i++, j += 8) {
892 892 #ifdef UNALIGNED_POINTERS_PERMITTED
893 - key_uint64[i] = htonll(*(uint64_t *)&cipherKey[j]);
893 + key_uint64[i] =
894 + htonll(*(uint64_t *)(void *)&cipherKey[j]);
894 895 #else
895 896 key_uint64[i] = (((uint64_t)cipherKey[j] << 56) |
896 897 ((uint64_t)cipherKey[j + 1] << 48) |
897 898 ((uint64_t)cipherKey[j + 2] << 40) |
898 899 ((uint64_t)cipherKey[j + 3] << 32) |
899 900 ((uint64_t)cipherKey[j + 4] << 24) |
900 901 ((uint64_t)cipherKey[j + 5] << 16) |
901 902 ((uint64_t)cipherKey[j + 6] << 8) |
902 903 (uint64_t)cipherKey[j + 7]);
903 904 #endif /* UNALIGNED_POINTERS_PERMITTED */
904 905 }
905 906 }
906 907
907 908 switch (strength) {
908 909 case DES:
909 910 des_ks(keysched, key_uint64[0]);
910 911 break;
911 912
912 913 case DES2:
913 914 /* DES2 is just DES3 with the first and third keys the same */
914 915 bcopy(key_uint64, key_uint64 + 2, DES_KEYSIZE);
915 916 /* FALLTHRU */
916 917 case DES3:
917 918 des_ks(keysched, key_uint64[0]);
918 919 des_ks(keysched + 16, key_uint64[1]);
919 920 for (i = 0; i < 8; i++) {
920 921 tmp = keysched[16+i];
921 922 keysched[16+i] = keysched[31-i];
922 923 keysched[31-i] = tmp;
923 924 }
924 925 des_ks(keysched+32, key_uint64[2]);
925 926 keysize = DES3_KEYSIZE;
926 927 }
927 928
928 929 /* save the encryption keyschedule */
929 930 bcopy(keysched, encryption_ks, keysize * 16);
930 931
931 932 /* reverse the key schedule */
932 933 for (i = 0; i < keysize; i++) {
933 934 tmp = keysched[i];
934 935 keysched[i] = keysched[2 * keysize - 1 - i];
935 936 keysched[2 * keysize -1 -i] = tmp;
936 937 }
937 938
938 939 /* save the decryption keyschedule */
939 940 bcopy(keysched, decryption_ks, keysize * 16);
940 941 /* EXPORT DELETE END */
941 942 }
942 943
943 944 /*
944 945 * Allocate key schedule.
945 946 */
946 947 /*ARGSUSED*/
947 948 void *
948 949 des_alloc_keysched(size_t *keysched_size, des_strength_t strength, int kmflag)
949 950 {
950 951 void *keysched;
951 952
952 953 /* EXPORT DELETE START */
953 954
954 955 size_t size;
955 956
956 957 switch (strength) {
957 958 case DES:
958 959 size = sizeof (keysched_t);
959 960 break;
960 961 case DES2:
961 962 case DES3:
962 963 size = sizeof (keysched3_t);
963 964 }
964 965
965 966 #ifdef _KERNEL
966 967 keysched = (keysched_t *)kmem_alloc(size, kmflag);
967 968 #else /* !_KERNEL */
968 969 keysched = (keysched_t *)malloc(size);
969 970 #endif /* _KERNEL */
970 971
971 972 if (keysched == NULL)
972 973 return (NULL);
973 974
974 975 if (keysched_size != NULL)
975 976 *keysched_size = size;
976 977
977 978 /* EXPORT DELETE END */
978 979
979 980 return (keysched);
980 981 }
981 982
982 983 /*
983 984 * Replace the LSB of each byte by the xor of the other
984 985 * 7 bits. The tricky thing is that the original contents of the LSBs
985 986 * are nullified by including them twice in the xor computation.
986 987 */
987 988 static void
988 989 fix_des_parity(uint64_t *keyp)
989 990 {
990 991 /* EXPORT DELETE START */
991 992 uint64_t k = *keyp;
992 993 k ^= k >> 1;
993 994 k ^= k >> 2;
994 995 k ^= k >> 4;
995 996 *keyp ^= (k & 0x0101010101010101ULL);
996 997 *keyp ^= 0x0101010101010101ULL;
997 998 /* EXPORT DELETE END */
998 999 }
999 1000
1000 1001 void
1001 1002 des_copy_block(uint8_t *in, uint8_t *out)
1002 1003 {
1003 1004 if (IS_P2ALIGNED(in, sizeof (uint32_t)) &&
1004 1005 IS_P2ALIGNED(out, sizeof (uint32_t))) {
1005 1006 /* LINTED: pointer alignment */
1006 1007 *(uint32_t *)&out[0] = *(uint32_t *)&in[0];
1007 1008 /* LINTED: pointer alignment */
1008 1009 *(uint32_t *)&out[4] = *(uint32_t *)&in[4];
1009 1010 } else {
1010 1011 DES_COPY_BLOCK(in, out);
1011 1012 }
1012 1013 }
1013 1014
1014 1015 /* XOR block of data into dest */
1015 1016 void
1016 1017 des_xor_block(uint8_t *data, uint8_t *dst)
1017 1018 {
1018 1019 if (IS_P2ALIGNED(dst, sizeof (uint32_t)) &&
1019 1020 IS_P2ALIGNED(data, sizeof (uint32_t))) {
1020 1021 /* LINTED: pointer alignment */
1021 1022 *(uint32_t *)&dst[0] ^=
1022 1023 /* LINTED: pointer alignment */
1023 1024 *(uint32_t *)&data[0];
1024 1025 /* LINTED: pointer alignment */
1025 1026 *(uint32_t *)&dst[4] ^=
1026 1027 /* LINTED: pointer alignment */
1027 1028 *(uint32_t *)&data[4];
1028 1029 } else {
1029 1030 DES_XOR_BLOCK(data, dst);
1030 1031 }
1031 1032 }
1032 1033
1033 1034 int
1034 1035 des_encrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
1035 1036 {
1036 1037 return (des_crunch_block(keysched, in, out, B_FALSE));
1037 1038 }
1038 1039
1039 1040 int
1040 1041 des3_encrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
1041 1042 {
1042 1043 return (des3_crunch_block(keysched, in, out, B_FALSE));
1043 1044 }
1044 1045
1045 1046 int
1046 1047 des_decrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
1047 1048 {
1048 1049 return (des_crunch_block(keysched, in, out, B_TRUE));
1049 1050 }
1050 1051
1051 1052 int
1052 1053 des3_decrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
1053 1054 {
1054 1055 return (des3_crunch_block(keysched, in, out, B_TRUE));
1055 1056 }
1056 1057
1057 1058 /*
1058 1059 * Encrypt multiple blocks of data according to mode.
1059 1060 */
1060 1061 int
1061 1062 des_encrypt_contiguous_blocks(void *ctx, char *data, size_t length,
1062 1063 crypto_data_t *out)
1063 1064 {
1064 1065 des_ctx_t *des_ctx = ctx;
1065 1066 int rv;
1066 1067
1067 1068 if (des_ctx->dc_flags & DES3_STRENGTH) {
1068 1069 if (des_ctx->dc_flags & CBC_MODE) {
1069 1070 rv = cbc_encrypt_contiguous_blocks(ctx, data,
1070 1071 length, out, DES_BLOCK_LEN, des3_encrypt_block,
1071 1072 des_copy_block, des_xor_block);
1072 1073 } else {
1073 1074 rv = ecb_cipher_contiguous_blocks(ctx, data, length,
1074 1075 out, DES_BLOCK_LEN, des3_encrypt_block);
1075 1076 }
1076 1077 } else {
1077 1078 if (des_ctx->dc_flags & CBC_MODE) {
1078 1079 rv = cbc_encrypt_contiguous_blocks(ctx, data,
1079 1080 length, out, DES_BLOCK_LEN, des_encrypt_block,
1080 1081 des_copy_block, des_xor_block);
1081 1082 } else {
1082 1083 rv = ecb_cipher_contiguous_blocks(ctx, data, length,
1083 1084 out, DES_BLOCK_LEN, des_encrypt_block);
1084 1085 }
1085 1086 }
1086 1087 return (rv);
1087 1088 }
1088 1089
1089 1090 /*
1090 1091 * Decrypt multiple blocks of data according to mode.
1091 1092 */
1092 1093 int
1093 1094 des_decrypt_contiguous_blocks(void *ctx, char *data, size_t length,
1094 1095 crypto_data_t *out)
1095 1096 {
1096 1097 des_ctx_t *des_ctx = ctx;
1097 1098 int rv;
1098 1099
1099 1100 if (des_ctx->dc_flags & DES3_STRENGTH) {
1100 1101 if (des_ctx->dc_flags & CBC_MODE) {
1101 1102 rv = cbc_decrypt_contiguous_blocks(ctx, data,
1102 1103 length, out, DES_BLOCK_LEN, des3_decrypt_block,
1103 1104 des_copy_block, des_xor_block);
1104 1105 } else {
1105 1106 rv = ecb_cipher_contiguous_blocks(ctx, data, length,
1106 1107 out, DES_BLOCK_LEN, des3_decrypt_block);
1107 1108 if (rv == CRYPTO_DATA_LEN_RANGE)
1108 1109 rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
1109 1110 }
1110 1111 } else {
1111 1112 if (des_ctx->dc_flags & CBC_MODE) {
1112 1113 rv = cbc_decrypt_contiguous_blocks(ctx, data,
1113 1114 length, out, DES_BLOCK_LEN, des_decrypt_block,
1114 1115 des_copy_block, des_xor_block);
1115 1116 } else {
1116 1117 rv = ecb_cipher_contiguous_blocks(ctx, data, length,
1117 1118 out, DES_BLOCK_LEN, des_decrypt_block);
1118 1119 if (rv == CRYPTO_DATA_LEN_RANGE)
1119 1120 rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
1120 1121 }
1121 1122 }
1122 1123 return (rv);
1123 1124 }
|
↓ open down ↓ |
220 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX