Print this page
first pass
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/lib/libnsl/des/des_crypt.c
+++ new/usr/src/lib/libnsl/des/des_crypt.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, Version 1.0 only
6 6 * (the "License"). You may not use this file except in compliance
7 7 * with the License.
8 8 *
9 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 * or http://www.opensolaris.org/os/licensing.
11 11 * See the License for the specific language governing permissions
12 12 * and limitations under the License.
13 13 *
14 14 * When distributing Covered Code, include this CDDL HEADER in each
15 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 * If applicable, add the following below this CDDL HEADER, with the
17 17 * fields enclosed by brackets "[]" replaced with your own identifying
18 18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 19 *
20 20 * CDDL HEADER END
21 21 */
22 22
23 23 /*
24 24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
25 25 * Use is subject to license terms.
26 26 */
27 27
28 28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 29 /* All Rights Reserved */
30 30
31 31 /*
32 32 * Portions of this source code were derived from Berkeley 4.3 BSD
33 33 * under license from the Regents of the University of California.
34 34 */
35 35
36 36 #pragma ident "%Z%%M% %I% %E% SMI"
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
37 37
38 38 /*
39 39 * DES encryption library routines
40 40 */
41 41
42 42 #include "mt.h"
43 43 #include <unistd.h>
44 44 #include <fcntl.h>
45 45 #include <sys/types.h>
46 46 #include <rpc/des_crypt.h>
47 -/* EXPORT DELETE START */
48 47 #ifdef sun
49 48 #include <sys/ioctl.h>
50 49 #include <sys/des.h>
51 50 #define getdesfd() (open("/dev/des", 0, 0))
52 51 #else
53 52 #include <des/des.h>
54 53 #endif
55 -/* EXPORT DELETE END */
56 54 #include <rpc/rpc.h>
57 -/* EXPORT DELETE START */
58 55
59 56 extern int __des_crypt(char *, unsigned, struct desparams *);
60 57
61 58 static int common_crypt(char *, char *, unsigned, unsigned, struct desparams *);
62 59
63 60 /*
64 61 * To see if chip is installed
65 62 */
66 63 #define UNOPENED (-2)
67 64 static int g_desfd = UNOPENED;
68 65
69 66
70 67 /*
71 68 * Copy 8 bytes
72 69 */
73 70 #define COPY8(src, dst) { \
74 71 char *a = (char *)dst; \
75 72 char *b = (char *)src; \
76 73 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
77 74 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
78 75 }
79 76
80 77 /*
81 78 * Copy multiple of 8 bytes
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
82 79 */
83 80 #define DESCOPY(src, dst, len) { \
84 81 char *a = (char *)dst; \
85 82 char *b = (char *)src; \
86 83 int i; \
87 84 for (i = (int)len; i > 0; i -= 8) { \
88 85 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
89 86 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
90 87 } \
91 88 }
92 -/* EXPORT DELETE END */
93 89
94 90 /*
95 91 * CBC mode encryption
96 92 */
97 93 int
98 94 cbc_crypt(char *key, char *buf, size_t len, unsigned int mode, char *ivec)
99 95 {
100 -/* EXPORT DELETE START */
101 96 int err;
102 97 struct desparams dp;
103 98
104 99 dp.des_mode = CBC;
105 100 COPY8(ivec, dp.des_ivec);
106 101 err = common_crypt(key, buf, len, mode, &dp);
107 102 COPY8(dp.des_ivec, ivec);
108 103 return (err);
109 -#if 0
110 -/* EXPORT DELETE END */
111 - return (DESERR_HWERROR);
112 -/* EXPORT DELETE START */
113 -#endif
114 -/* EXPORT DELETE END */
115 104 }
116 105
117 106
118 107 /*
119 108 * ECB mode encryption
120 109 */
121 110 int
122 111 ecb_crypt(char *key, char *buf, size_t len, unsigned int mode)
123 112 {
124 -/* EXPORT DELETE START */
125 113 struct desparams dp;
126 114
127 115 dp.des_mode = ECB;
128 116 return (common_crypt(key, buf, len, mode, &dp));
129 -#if 0
130 -/* EXPORT DELETE END */
131 - return (DESERR_HWERROR);
132 -/* EXPORT DELETE START */
133 -#endif
134 -/* EXPORT DELETE END */
135 117 }
136 118
137 119
138 -/* EXPORT DELETE START */
139 120
140 121 /*
141 122 * Common code to cbc_crypt() & ecb_crypt()
142 123 */
143 124 static int
144 125 common_crypt(char *key, char *buf, unsigned len, unsigned mode,
145 126 struct desparams *desp)
146 127 {
147 128 int desdev;
148 129 int res;
149 130
150 131 if ((len % 8) != 0 || len > DES_MAXDATA)
151 132 return (DESERR_BADPARAM);
152 133 desp->des_dir =
153 134 ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT;
154 135
155 136 desdev = mode & DES_DEVMASK;
156 137 COPY8(key, desp->des_key);
157 138 #ifdef sun
158 139 if (desdev == DES_HW) {
159 140 if (g_desfd < 0) {
160 141 if (g_desfd == -1 || (g_desfd = getdesfd()) < 0) {
161 142 goto software; /* no hardware device */
162 143 }
163 144 }
164 145
165 146 /*
166 147 * hardware
167 148 */
168 149 desp->des_len = len;
169 150 if (len <= DES_QUICKLEN) {
170 151 DESCOPY(buf, desp->des_data, len);
171 152 res = ioctl(g_desfd, DESIOCQUICK, (char *)desp);
172 153 DESCOPY(desp->des_data, buf, len);
173 154 } else {
174 155 desp->des_buf = (uchar_t *)buf;
175 156 res = ioctl(g_desfd, DESIOCBLOCK, (char *)desp);
176 157 }
177 158 return (res == 0 ? DESERR_NONE : DESERR_HWERROR);
↓ open down ↓ |
29 lines elided |
↑ open up ↑ |
178 159 }
179 160 software:
180 161 #endif
181 162 /*
182 163 * software
183 164 */
184 165 if (!__des_crypt(buf, len, desp))
185 166 return (DESERR_HWERROR);
186 167 return (desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE);
187 168 }
188 -/* EXPORT DELETE END */
189 169
190 -/* EXPORT DELETE START */
191 170 static int
192 171 desN_crypt(des_block keys[], int keynum, char *buf, unsigned int len,
193 172 unsigned int mode, char *ivec)
194 173 {
195 174 unsigned int m = mode & (DES_ENCRYPT | DES_DECRYPT);
196 175 unsigned int flags = mode & ~(DES_ENCRYPT | DES_DECRYPT);
197 176 des_block svec, dvec;
198 177 int i, j, stat;
199 178
200 179 if (keynum < 1)
201 180 return (DESERR_BADPARAM);
202 181
203 182 (void) memcpy(svec.c, ivec, sizeof (des_block));
204 183 for (i = 0; i < keynum; i++) {
205 184 j = (mode & DES_DECRYPT) ? keynum - 1 - i : i;
206 185 stat = cbc_crypt(keys[j].c, buf, len, m | flags, ivec);
207 186 if (mode & DES_DECRYPT && i == 0)
208 187 (void) memcpy(dvec.c, ivec, sizeof (des_block));
209 188
210 189 if (DES_FAILED(stat))
211 190 return (stat);
212 191
213 192 m = (m == DES_ENCRYPT ? DES_DECRYPT : DES_ENCRYPT);
214 193
215 194 if ((mode & DES_DECRYPT) || i != keynum - 1 || i%2)
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
216 195 (void) memcpy(ivec, svec.c, sizeof (des_block));
217 196 }
218 197 if (keynum % 2 == 0)
219 198 stat = cbc_crypt(keys[0].c, buf, len, mode, ivec);
220 199
221 200 if (mode & DES_DECRYPT)
222 201 (void) memcpy(ivec, dvec.c, sizeof (des_block));
223 202
224 203 return (stat);
225 204 }
226 -/* EXPORT DELETE END */
227 205
228 206
229 207
230 208 int
231 209 __cbc_triple_crypt(des_block keys[], char *buf, uint_t len,
232 210 uint_t mode, char *ivec)
233 211 {
234 -/* EXPORT DELETE START */
235 212 return (desN_crypt(keys, 3, buf, len, mode, ivec));
236 -#if 0
237 -/* EXPORT DELETE END */
238 - return (DESERR_HWERROR);
239 -/* EXPORT DELETE START */
240 -#endif
241 -/* EXPORT DELETE END */
242 213 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX