1 | /* |
2 | * Copyright (c) 2010, Oracle America, Inc. |
3 | * |
4 | * Redistribution and use in source and binary forms, with or without |
5 | * modification, are permitted provided that the following conditions are |
6 | * met: |
7 | * |
8 | * * Redistributions of source code must retain the above copyright |
9 | * notice, this list of conditions and the following disclaimer. |
10 | * * Redistributions in binary form must reproduce the above |
11 | * copyright notice, this list of conditions and the following |
12 | * disclaimer in the documentation and/or other materials |
13 | * provided with the distribution. |
14 | * * Neither the name of the "Oracle America, Inc." nor the names of its |
15 | * contributors may be used to endorse or promote products derived |
16 | * from this software without specific prior written permission. |
17 | * |
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
21 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
22 | * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |
23 | * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE |
25 | * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
26 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
27 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
28 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
29 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
30 | */ |
31 | /* |
32 | * auth_des.c, client-side implementation of DES authentication |
33 | */ |
34 | |
35 | #include <string.h> |
36 | #include <stdint.h> |
37 | #include <rpc/des_crypt.h> |
38 | #include <rpc/types.h> |
39 | #include <rpc/auth.h> |
40 | #include <rpc/auth_des.h> |
41 | #include <rpc/xdr.h> |
42 | #include <netinet/in.h> /* XXX: just to get htonl() and ntohl() */ |
43 | #include <sys/socket.h> |
44 | #include <shlib-compat.h> |
45 | |
46 | #define MILLION 1000000L |
47 | #define RTIME_TIMEOUT 5 /* seconds to wait for sync */ |
48 | |
49 | #define AUTH_PRIVATE(auth) (struct ad_private *) auth->ah_private |
50 | #define ALLOC(object_type) (object_type *) mem_alloc(sizeof(object_type)) |
51 | #define FREE(ptr, size) mem_free((char *)(ptr), (int) size) |
52 | #define ATTEMPT(xdr_op) if (!(xdr_op)) return (FALSE) |
53 | |
54 | #define debug(msg) /* printf("%s\n", msg) */ |
55 | |
56 | |
57 | /* |
58 | * DES authenticator operations vector |
59 | */ |
60 | static void authdes_nextverf (AUTH *); |
61 | static bool_t authdes_marshal (AUTH *, XDR *); |
62 | static bool_t authdes_validate (AUTH *, struct opaque_auth *); |
63 | static bool_t authdes_refresh (AUTH *); |
64 | static void authdes_destroy (AUTH *); |
65 | static bool_t synchronize (struct sockaddr *, struct rpc_timeval *) |
66 | internal_function; |
67 | |
68 | static const struct auth_ops authdes_ops = { |
69 | authdes_nextverf, |
70 | authdes_marshal, |
71 | authdes_validate, |
72 | authdes_refresh, |
73 | authdes_destroy |
74 | }; |
75 | |
76 | |
77 | /* |
78 | * This struct is pointed to by the ah_private field of an "AUTH *" |
79 | */ |
80 | struct ad_private { |
81 | char *ad_fullname; /* client's full name */ |
82 | u_int ad_fullnamelen; /* length of name, rounded up */ |
83 | char *ad_servername; /* server's full name */ |
84 | u_int ad_servernamelen; /* length of name, rounded up */ |
85 | uint32_t ad_window; /* client specified window */ |
86 | bool_t ad_dosync; /* synchronize? */ |
87 | struct sockaddr ad_syncaddr; /* remote host to synch with */ |
88 | struct rpc_timeval ad_timediff; /* server's time - client's time */ |
89 | uint32_t ad_nickname; /* server's nickname for client */ |
90 | struct authdes_cred ad_cred; /* storage for credential */ |
91 | struct authdes_verf ad_verf; /* storage for verifier */ |
92 | struct rpc_timeval ad_timestamp; /* timestamp sent */ |
93 | des_block ad_xkey; /* encrypted conversation key */ |
94 | u_char ad_pkey[1024]; /* Servers actual public key */ |
95 | }; |
96 | |
97 | |
98 | /* |
99 | * Create the client des authentication object |
100 | */ |
101 | AUTH * |
102 | authdes_create (const char *servername, u_int window, |
103 | struct sockaddr *syncaddr, des_block *ckey) |
104 | /* servername - network name of server */ |
105 | /* window - time to live */ |
106 | /* syncaddr - optional addr of host to sync with */ |
107 | /* ckey - optional conversation key to use */ |
108 | { |
109 | char pkey_data[1024]; |
110 | netobj pkey; |
111 | |
112 | if (!getpublickey (servername, pkey_data)) |
113 | return NULL; |
114 | |
115 | pkey.n_bytes = pkey_data; |
116 | pkey.n_len = strlen (pkey_data) + 1; |
117 | return authdes_pk_create (servername, &pkey, window, syncaddr, ckey); |
118 | } |
119 | #ifdef EXPORT_RPC_SYMBOLS |
120 | libc_hidden_def (authdes_create) |
121 | #else |
122 | libc_hidden_nolink_sunrpc (authdes_create, GLIBC_2_1) |
123 | #endif |
124 | |
125 | AUTH * |
126 | authdes_pk_create (const char *servername, netobj *pkey, u_int window, |
127 | struct sockaddr *syncaddr, des_block *ckey) |
128 | { |
129 | AUTH *auth; |
130 | struct ad_private *ad; |
131 | char namebuf[MAXNETNAMELEN + 1]; |
132 | |
133 | /* |
134 | * Allocate everything now |
135 | */ |
136 | auth = ALLOC (AUTH); |
137 | ad = ALLOC (struct ad_private); |
138 | |
139 | if (auth == NULL || ad == NULL) |
140 | { |
141 | debug ("authdes_create: out of memory" ); |
142 | goto failed; |
143 | } |
144 | |
145 | memset (ad, 0, sizeof (struct ad_private)); |
146 | memcpy (ad->ad_pkey, pkey->n_bytes, pkey->n_len); |
147 | if (!getnetname (namebuf)) |
148 | goto failed; |
149 | ad->ad_fullnamelen = RNDUP (strlen (namebuf)); |
150 | ad->ad_fullname = mem_alloc (ad->ad_fullnamelen + 1); |
151 | |
152 | ad->ad_servernamelen = strlen (servername); |
153 | ad->ad_servername = mem_alloc (ad->ad_servernamelen + 1); |
154 | |
155 | if (ad->ad_fullname == NULL || ad->ad_servername == NULL) |
156 | { |
157 | debug ("authdes_create: out of memory" ); |
158 | goto failed; |
159 | } |
160 | |
161 | /* |
162 | * Set up private data |
163 | */ |
164 | memcpy (ad->ad_fullname, namebuf, ad->ad_fullnamelen + 1); |
165 | memcpy (ad->ad_servername, servername, ad->ad_servernamelen + 1); |
166 | ad->ad_timediff.tv_sec = ad->ad_timediff.tv_usec = 0; |
167 | if (syncaddr != NULL) |
168 | { |
169 | ad->ad_syncaddr = *syncaddr; |
170 | ad->ad_dosync = TRUE; |
171 | } |
172 | else |
173 | ad->ad_dosync = FALSE; |
174 | |
175 | ad->ad_window = window; |
176 | if (ckey == NULL) |
177 | { |
178 | if (key_gendes (&auth->ah_key) < 0) |
179 | { |
180 | debug ("authdes_create: unable to gen conversation key" ); |
181 | goto failed; |
182 | } |
183 | } |
184 | else |
185 | auth->ah_key = *ckey; |
186 | |
187 | /* |
188 | * Set up auth handle |
189 | */ |
190 | auth->ah_cred.oa_flavor = AUTH_DES; |
191 | auth->ah_verf.oa_flavor = AUTH_DES; |
192 | auth->ah_ops = (struct auth_ops *) &authdes_ops; |
193 | auth->ah_private = (caddr_t) ad; |
194 | |
195 | if (!authdes_refresh (auth)) |
196 | goto failed; |
197 | |
198 | return auth; |
199 | |
200 | failed: |
201 | if (auth != NULL) |
202 | FREE (auth, sizeof (AUTH)); |
203 | if (ad != NULL) |
204 | { |
205 | if (ad->ad_fullname != NULL) |
206 | FREE (ad->ad_fullname, ad->ad_fullnamelen + 1); |
207 | if (ad->ad_servername != NULL) |
208 | FREE (ad->ad_servername, ad->ad_servernamelen + 1); |
209 | FREE (ad, sizeof (struct ad_private)); |
210 | } |
211 | return NULL; |
212 | } |
213 | #ifdef EXPORT_RPC_SYMBOLS |
214 | libc_hidden_def (authdes_pk_create) |
215 | #else |
216 | libc_hidden_nolink_sunrpc (authdes_pk_create, GLIBC_2_1) |
217 | #endif |
218 | |
219 | /* |
220 | * Implement the five authentication operations |
221 | */ |
222 | |
223 | |
224 | /* |
225 | * 1. Next Verifier |
226 | */ |
227 | /*ARGSUSED */ |
228 | static void |
229 | authdes_nextverf (AUTH *auth) |
230 | { |
231 | /* what the heck am I supposed to do??? */ |
232 | } |
233 | |
234 | |
235 | |
236 | /* |
237 | * 2. Marshal |
238 | */ |
239 | static bool_t |
240 | authdes_marshal (AUTH *auth, XDR *xdrs) |
241 | { |
242 | struct ad_private *ad = AUTH_PRIVATE (auth); |
243 | struct authdes_cred *cred = &ad->ad_cred; |
244 | struct authdes_verf *verf = &ad->ad_verf; |
245 | des_block cryptbuf[2]; |
246 | des_block ivec; |
247 | int status; |
248 | int len; |
249 | register int32_t *ixdr; |
250 | struct timeval tval; |
251 | |
252 | /* |
253 | * Figure out the "time", accounting for any time difference |
254 | * with the server if necessary. |
255 | */ |
256 | __gettimeofday (&tval, (struct timezone *) NULL); |
257 | ad->ad_timestamp.tv_sec = tval.tv_sec + ad->ad_timediff.tv_sec; |
258 | ad->ad_timestamp.tv_usec = tval.tv_usec + ad->ad_timediff.tv_usec; |
259 | if (ad->ad_timestamp.tv_usec >= MILLION) |
260 | { |
261 | ad->ad_timestamp.tv_usec -= MILLION; |
262 | ad->ad_timestamp.tv_sec += 1; |
263 | } |
264 | |
265 | /* |
266 | * XDR the timestamp and possibly some other things, then |
267 | * encrypt them. |
268 | * XXX We have a real Year 2038 problem here. |
269 | */ |
270 | ixdr = (int32_t *) cryptbuf; |
271 | IXDR_PUT_INT32 (ixdr, ad->ad_timestamp.tv_sec); |
272 | IXDR_PUT_INT32 (ixdr, ad->ad_timestamp.tv_usec); |
273 | if (ad->ad_cred.adc_namekind == ADN_FULLNAME) |
274 | { |
275 | IXDR_PUT_U_INT32 (ixdr, ad->ad_window); |
276 | IXDR_PUT_U_INT32 (ixdr, ad->ad_window - 1); |
277 | ivec.key.high = ivec.key.low = 0; |
278 | status = cbc_crypt ((char *) &auth->ah_key, (char *) cryptbuf, |
279 | 2 * sizeof (des_block), DES_ENCRYPT | DES_HW, (char *) &ivec); |
280 | } |
281 | else |
282 | status = ecb_crypt ((char *) &auth->ah_key, (char *) cryptbuf, |
283 | sizeof (des_block), DES_ENCRYPT | DES_HW); |
284 | |
285 | if (DES_FAILED (status)) |
286 | { |
287 | debug ("authdes_marshal: DES encryption failure" ); |
288 | return FALSE; |
289 | } |
290 | ad->ad_verf.adv_xtimestamp = cryptbuf[0]; |
291 | if (ad->ad_cred.adc_namekind == ADN_FULLNAME) |
292 | { |
293 | ad->ad_cred.adc_fullname.window = cryptbuf[1].key.high; |
294 | ad->ad_verf.adv_winverf = cryptbuf[1].key.low; |
295 | } |
296 | else |
297 | { |
298 | ad->ad_cred.adc_nickname = ad->ad_nickname; |
299 | ad->ad_verf.adv_winverf = 0; |
300 | } |
301 | |
302 | /* |
303 | * Serialize the credential and verifier into opaque |
304 | * authentication data. |
305 | */ |
306 | if (ad->ad_cred.adc_namekind == ADN_FULLNAME) |
307 | len = ((1 + 1 + 2 + 1) * BYTES_PER_XDR_UNIT + ad->ad_fullnamelen); |
308 | else |
309 | len = (1 + 1) * BYTES_PER_XDR_UNIT; |
310 | |
311 | if ((ixdr = xdr_inline (xdrs, 2 * BYTES_PER_XDR_UNIT)) != NULL) |
312 | { |
313 | IXDR_PUT_INT32 (ixdr, AUTH_DES); |
314 | IXDR_PUT_U_INT32 (ixdr, len); |
315 | } |
316 | else |
317 | { |
318 | ATTEMPT (xdr_putint32 (xdrs, &auth->ah_cred.oa_flavor)); |
319 | ATTEMPT (xdr_putint32 (xdrs, &len)); |
320 | } |
321 | ATTEMPT (xdr_authdes_cred (xdrs, cred)); |
322 | |
323 | len = (2 + 1) * BYTES_PER_XDR_UNIT; |
324 | if ((ixdr = xdr_inline (xdrs, 2 * BYTES_PER_XDR_UNIT)) != NULL) |
325 | { |
326 | IXDR_PUT_INT32 (ixdr, AUTH_DES); |
327 | IXDR_PUT_U_INT32 (ixdr, len); |
328 | } |
329 | else |
330 | { |
331 | ATTEMPT (xdr_putint32 (xdrs, &auth->ah_verf.oa_flavor)); |
332 | ATTEMPT (xdr_putint32 (xdrs, &len)); |
333 | } |
334 | ATTEMPT (xdr_authdes_verf (xdrs, verf)); |
335 | |
336 | return TRUE; |
337 | } |
338 | |
339 | |
340 | /* |
341 | * 3. Validate |
342 | */ |
343 | static bool_t |
344 | authdes_validate (AUTH *auth, struct opaque_auth *rverf) |
345 | { |
346 | struct ad_private *ad = AUTH_PRIVATE (auth); |
347 | struct authdes_verf verf; |
348 | int status; |
349 | register uint32_t *ixdr; |
350 | |
351 | if (rverf->oa_length != (2 + 1) * BYTES_PER_XDR_UNIT) |
352 | return FALSE; |
353 | |
354 | ixdr = (uint32_t *) rverf->oa_base; |
355 | verf.adv_xtimestamp.key.high = *ixdr++; |
356 | verf.adv_xtimestamp.key.low = *ixdr++; |
357 | verf.adv_int_u = *ixdr++; /* nickname not XDR'd ! */ |
358 | |
359 | /* |
360 | * Decrypt the timestamp |
361 | */ |
362 | status = ecb_crypt ((char *) &auth->ah_key, (char *) &verf.adv_xtimestamp, |
363 | sizeof (des_block), DES_DECRYPT | DES_HW); |
364 | |
365 | if (DES_FAILED (status)) |
366 | { |
367 | debug ("authdes_validate: DES decryption failure" ); |
368 | return FALSE; |
369 | } |
370 | |
371 | /* |
372 | * xdr the decrypted timestamp |
373 | */ |
374 | ixdr = (uint32_t *) verf.adv_xtimestamp.c; |
375 | verf.adv_timestamp.tv_sec = IXDR_GET_U_INT32 (ixdr) + 1; |
376 | verf.adv_timestamp.tv_usec = IXDR_GET_U_INT32 (ixdr); |
377 | |
378 | /* |
379 | * validate |
380 | */ |
381 | if (memcmp ((char *) &ad->ad_timestamp, (char *) &verf.adv_timestamp, |
382 | sizeof (struct rpc_timeval)) != 0) |
383 | { |
384 | debug ("authdes_validate: verifier mismatch\n" ); |
385 | return FALSE; |
386 | } |
387 | |
388 | /* |
389 | * We have a nickname now, let's use it |
390 | */ |
391 | ad->ad_nickname = verf.adv_nickname; |
392 | ad->ad_cred.adc_namekind = ADN_NICKNAME; |
393 | return TRUE; |
394 | } |
395 | |
396 | /* |
397 | * 4. Refresh |
398 | */ |
399 | static bool_t |
400 | authdes_refresh (AUTH *auth) |
401 | { |
402 | netobj pkey; |
403 | struct ad_private *ad = AUTH_PRIVATE (auth); |
404 | struct authdes_cred *cred = &ad->ad_cred; |
405 | |
406 | if (ad->ad_dosync && !synchronize (&ad->ad_syncaddr, &ad->ad_timediff)) |
407 | { |
408 | /* |
409 | * Hope the clocks are synced! |
410 | */ |
411 | ad->ad_timediff.tv_sec = ad->ad_timediff.tv_usec = 0; |
412 | debug ("authdes_refresh: unable to synchronize with server" ); |
413 | } |
414 | ad->ad_xkey = auth->ah_key; |
415 | pkey.n_bytes = (char *) (ad->ad_pkey); |
416 | pkey.n_len = strlen ((char *) ad->ad_pkey) + 1; |
417 | if (key_encryptsession_pk (ad->ad_servername, &pkey, &ad->ad_xkey) < 0) |
418 | { |
419 | debug ("authdes_create: unable to encrypt conversation key" ); |
420 | return FALSE; |
421 | } |
422 | cred->adc_fullname.key = ad->ad_xkey; |
423 | cred->adc_namekind = ADN_FULLNAME; |
424 | cred->adc_fullname.name = ad->ad_fullname; |
425 | return TRUE; |
426 | } |
427 | |
428 | /* |
429 | * 5. Destroy |
430 | */ |
431 | static void |
432 | authdes_destroy (AUTH *auth) |
433 | { |
434 | struct ad_private *ad = AUTH_PRIVATE (auth); |
435 | |
436 | FREE (ad->ad_fullname, ad->ad_fullnamelen + 1); |
437 | FREE (ad->ad_servername, ad->ad_servernamelen + 1); |
438 | FREE (ad, sizeof (struct ad_private)); |
439 | FREE (auth, sizeof (AUTH)); |
440 | } |
441 | |
442 | /* |
443 | * Synchronize with the server at the given address, that is, |
444 | * adjust timep to reflect the delta between our clocks |
445 | */ |
446 | static bool_t |
447 | internal_function |
448 | synchronize (struct sockaddr *syncaddr, struct rpc_timeval *timep) |
449 | { |
450 | struct timeval mytime; |
451 | struct rpc_timeval timeout; |
452 | |
453 | timeout.tv_sec = RTIME_TIMEOUT; |
454 | timeout.tv_usec = 0; |
455 | if (rtime ((struct sockaddr_in *) syncaddr, timep, &timeout) < 0) |
456 | return FALSE; |
457 | |
458 | __gettimeofday (&mytime, (struct timezone *) NULL); |
459 | timep->tv_sec -= mytime.tv_sec; |
460 | if (mytime.tv_usec > timep->tv_usec) |
461 | { |
462 | timep->tv_sec -= 1; |
463 | timep->tv_usec += MILLION; |
464 | } |
465 | timep->tv_usec -= mytime.tv_usec; |
466 | return TRUE; |
467 | } |
468 | |