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