1 /*-
2 * Copyright (c) 1992, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #include <config.h>
35
36 RCSID("$Id$");
37
38 #ifdef RSA_ENCPWD
39 /*
40 * COPYRIGHT (C) 1990 DIGITAL EQUIPMENT CORPORATION
41 * ALL RIGHTS RESERVED
42 *
43 * "Digital Equipment Corporation authorizes the reproduction,
44 * distribution and modification of this software subject to the following
45 * restrictions:
46 *
47 * 1. Any partial or whole copy of this software, or any modification
48 * thereof, must include this copyright notice in its entirety.
49 *
50 * 2. This software is supplied "as is" with no warranty of any kind,
51 * expressed or implied, for any purpose, including any warranty of fitness
52 * or merchantibility. DIGITAL assumes no responsibility for the use or
53 * reliability of this software, nor promises to provide any form of
54 * support for it on any basis.
55 *
56 * 3. Distribution of this software is authorized only if no profit or
57 * remuneration of any kind is received in exchange for such distribution.
58 *
59 * 4. This software produces public key authentication certificates
60 * bearing an expiration date established by DIGITAL and RSA Data
61 * Security, Inc. It may cease to generate certificates after the expiration
62 * date. Any modification of this software that changes or defeats
63 * the expiration date or its effect is unauthorized.
64 *
65 * 5. Software that will renew or extend the expiration date of
66 * authentication certificates produced by this software may be obtained
67 * from RSA Data Security, Inc., 10 Twin Dolphin Drive, Redwood City, CA
68 * 94065, (415)595-8782, or from DIGITAL"
69 *
70 */
71
72 #include <sys/types.h>
73 #ifdef HAVE_ARPA_TELNET_H
74 #include <arpa/telnet.h>
75 #endif
76 #include <pwd.h>
77 #include <stdio.h>
78
79 #include <stdlib.h>
80 #include <string.h>
81 #ifdef SOCKS
82 #include <socks.h>
83 #endif
84
85 #include "encrypt.h"
86 #include "auth.h"
87 #include "misc.h"
88 #include "cdc.h"
89
90 extern auth_debug_mode;
91
92 static unsigned char str_data[1024] = { IAC, SB, TELOPT_AUTHENTICATION, 0,
93 AUTHTYPE_RSA_ENCPWD, };
94 static unsigned char str_name[1024] = { IAC, SB, TELOPT_AUTHENTICATION,
95 TELQUAL_NAME, };
96
97 #define RSA_ENCPWD_AUTH 0 /* Authentication data follows */
98 #define RSA_ENCPWD_REJECT 1 /* Rejected (reason might follow) */
99 #define RSA_ENCPWD_ACCEPT 2 /* Accepted */
100 #define RSA_ENCPWD_CHALLENGEKEY 3 /* Challenge and public key */
101
102 #define NAME_SZ 40
103 #define CHAL_SZ 20
104 #define PWD_SZ 40
105
106 static KTEXT_ST auth;
107 static char name[NAME_SZ];
108 static char user_passwd[PWD_SZ];
109 static char key_file[2*NAME_SZ];
110 static char lhostname[NAME_SZ];
111 static char challenge[CHAL_SZ];
112 static int challenge_len;
113
114 static int
Data(ap,type,d,c)115 Data(ap, type, d, c)
116 Authenticator *ap;
117 int type;
118 void *d;
119 int c;
120 {
121 unsigned char *p = str_data + 4;
122 unsigned char *cd = (unsigned char *)d;
123
124 if (c == -1)
125 c = strlen((char *)cd);
126
127 if (0) {
128 printf("%s:%d: [%d] (%d)",
129 str_data[3] == TELQUAL_IS ? ">>>IS" : ">>>REPLY",
130 str_data[3],
131 type, c);
132 printd(d, c);
133 printf("\r\n");
134 }
135 *p++ = ap->type;
136 *p++ = ap->way;
137 if (type != NULL) *p++ = type;
138 while (c-- > 0) {
139 if ((*p++ = *cd++) == IAC)
140 *p++ = IAC;
141 }
142 *p++ = IAC;
143 *p++ = SE;
144 if (str_data[3] == TELQUAL_IS)
145 printsub('>', &str_data[2], p - (&str_data[2]));
146 return(telnet_net_write(str_data, p - str_data));
147 }
148
149 int
rsaencpwd_init(ap,server)150 rsaencpwd_init(ap, server)
151 Authenticator *ap;
152 int server;
153 {
154 char *cp;
155 FILE *fp;
156
157 if (server) {
158 str_data[3] = TELQUAL_REPLY;
159 memset(key_file, 0, sizeof(key_file));
160 gethostname(lhostname, sizeof(lhostname));
161 if ((cp = strchr(lhostname, '.')) != 0) *cp = '\0';
162 snprintf(key_file, sizeof(key_file),
163 SYSCONFDIR "/.%s_privkey", lhostname);
164 if ((fp=fopen(key_file, "r"))==NULL) return(0);
165 fclose(fp);
166 } else {
167 str_data[3] = TELQUAL_IS;
168 }
169 return(1);
170 }
171
172 int
rsaencpwd_send(ap)173 rsaencpwd_send(ap)
174 Authenticator *ap;
175 {
176
177 printf("[ Trying RSAENCPWD ... ]\r\n");
178 if (!UserNameRequested) {
179 return(0);
180 }
181 if (!auth_sendname(UserNameRequested, strlen(UserNameRequested))) {
182 return(0);
183 }
184 if (!Data(ap, NULL, NULL, 0)) {
185 return(0);
186 }
187
188
189 return(1);
190 }
191
192 void
rsaencpwd_is(ap,data,cnt)193 rsaencpwd_is(ap, data, cnt)
194 Authenticator *ap;
195 unsigned char *data;
196 int cnt;
197 {
198 Session_Key skey;
199 des_cblock datablock;
200 char r_passwd[PWD_SZ], r_user[NAME_SZ];
201 char *cp, key[160];
202 char chalkey[160], *ptr;
203 FILE *fp;
204 int r, i, j, chalkey_len, len;
205 time_t now;
206
207 cnt--;
208 switch (*data++) {
209 case RSA_ENCPWD_AUTH:
210 memmove(auth.dat, data, auth.length = cnt);
211
212 if ((fp=fopen(key_file, "r"))==NULL) {
213 Data(ap, RSA_ENCPWD_REJECT, "Auth failed", -1);
214 auth_finished(ap, AUTH_REJECT);
215 return;
216 }
217 /*
218 * get privkey
219 */
220 fscanf(fp, "%x;", &len);
221 for (i=0;i<len;i++) {
222 j = getc(fp); key[i]=j;
223 }
224 fclose(fp);
225
226 r = accept_rsa_encpwd(&auth, key, challenge,
227 challenge_len, r_passwd);
228 if (r < 0) {
229 Data(ap, RSA_ENCPWD_REJECT, "Auth failed", -1);
230 auth_finished(ap, AUTH_REJECT);
231 return;
232 }
233 auth_encrypt_userpwd(r_passwd);
234 if (rsaencpwd_passwdok(UserNameRequested, UserPassword) == 0) {
235 /*
236 * illegal username and password
237 */
238 Data(ap, RSA_ENCPWD_REJECT, "Illegal password", -1);
239 auth_finished(ap, AUTH_REJECT);
240 return;
241 }
242
243 Data(ap, RSA_ENCPWD_ACCEPT, 0, 0);
244 auth_finished(ap, AUTH_USER);
245 break;
246
247
248 case IAC:
249
250 /*
251 * If we are doing mutual authentication, get set up to send
252 * the challenge, and verify it when the response comes back.
253 */
254 if ((ap->way & AUTH_HOW_MASK) == AUTH_HOW_ONE_WAY) {
255 int i;
256
257
258 time(&now);
259 if ((now % 2) == 0) {
260 snprintf(challenge, sizeof(challenge), "%x", now);
261 challenge_len = strlen(challenge);
262 } else {
263 strlcpy(challenge, "randchal", sizeof(challenge));
264 challenge_len = 8;
265 }
266
267 if ((fp=fopen(key_file, "r"))==NULL) {
268 Data(ap, RSA_ENCPWD_REJECT, "Auth failed", -1);
269 auth_finished(ap, AUTH_REJECT);
270 return;
271 }
272 /*
273 * skip privkey
274 */
275 fscanf(fp, "%x;", &len);
276 for (i=0;i<len;i++) {
277 j = getc(fp);
278 }
279 /*
280 * get pubkey
281 */
282 fscanf(fp, "%x;", &len);
283 for (i=0;i<len;i++) {
284 j = getc(fp); key[i]=j;
285 }
286 fclose(fp);
287 chalkey[0] = 0x30;
288 ptr = (char *) &chalkey[1];
289 chalkey_len = 1+NumEncodeLengthOctets(i)+i+1+NumEncodeLengthOctets(challenge_len)+challenge_len;
290 EncodeLength(ptr, chalkey_len);
291 ptr +=NumEncodeLengthOctets(chalkey_len);
292 *ptr++ = 0x04; /* OCTET STRING */
293 *ptr++ = challenge_len;
294 memmove(ptr, challenge, challenge_len);
295 ptr += challenge_len;
296 *ptr++ = 0x04; /* OCTET STRING */
297 EncodeLength(ptr, i);
298 ptr += NumEncodeLengthOctets(i);
299 memmove(ptr, key, i);
300 chalkey_len = 1+NumEncodeLengthOctets(chalkey_len)+chalkey_len;
301 Data(ap, RSA_ENCPWD_CHALLENGEKEY, chalkey, chalkey_len);
302 }
303 break;
304
305 default:
306 Data(ap, RSA_ENCPWD_REJECT, 0, 0);
307 break;
308 }
309 }
310
311
312 void
rsaencpwd_reply(ap,data,cnt)313 rsaencpwd_reply(ap, data, cnt)
314 Authenticator *ap;
315 unsigned char *data;
316 int cnt;
317 {
318 Session_Key skey;
319 KTEXT_ST token;
320 des_cblock enckey;
321 int r, pubkey_len;
322 char randchal[CHAL_SZ], *cp;
323 char chalkey[160], pubkey[128], *ptr;
324
325 if (cnt-- < 1)
326 return;
327 switch (*data++) {
328 case RSA_ENCPWD_REJECT:
329 if (cnt > 0) {
330 printf("[ RSA_ENCPWD refuses authentication because %.*s ]\r\n",
331 cnt, data);
332 } else
333 printf("[ RSA_ENCPWD refuses authentication ]\r\n");
334 auth_send_retry();
335 return;
336 case RSA_ENCPWD_ACCEPT:
337 printf("[ RSA_ENCPWD accepts you ]\r\n");
338 auth_finished(ap, AUTH_USER);
339 return;
340 case RSA_ENCPWD_CHALLENGEKEY:
341 /*
342 * Verify that the response to the challenge is correct.
343 */
344
345 memmove(chalkey, data, cnt);
346 ptr = (char *) &chalkey[0];
347 ptr += DecodeHeaderLength(chalkey);
348 if (*ptr != 0x04) {
349 return;
350 }
351 *ptr++;
352 challenge_len = DecodeValueLength(ptr);
353 ptr += NumEncodeLengthOctets(challenge_len);
354 memmove(challenge, ptr, challenge_len);
355 ptr += challenge_len;
356 if (*ptr != 0x04) {
357 return;
358 }
359 *ptr++;
360 pubkey_len = DecodeValueLength(ptr);
361 ptr += NumEncodeLengthOctets(pubkey_len);
362 memmove(pubkey, ptr, pubkey_len);
363 memset(user_passwd, 0, sizeof(user_passwd));
364 des_read_pw_string(user_passwd, sizeof(user_passwd)-1, "Password: ", 0);
365 UserPassword = user_passwd;
366 Challenge = challenge;
367 r = init_rsa_encpwd(&token, user_passwd, challenge, challenge_len, pubkey);
368 if (r < 0) {
369 token.length = 1;
370 }
371
372 if (!Data(ap, RSA_ENCPWD_AUTH, token.dat, token.length)) {
373 return;
374 }
375
376 break;
377
378 default:
379 return;
380 }
381 }
382
383 int
rsaencpwd_status(ap,name,name_sz,level)384 rsaencpwd_status(ap, name, name_sz, level)
385 Authenticator *ap;
386 char *name;
387 size_t name_sz;
388 int level;
389 {
390
391 if (level < AUTH_USER)
392 return(level);
393
394 if (UserNameRequested && rsaencpwd_passwdok(UserNameRequested, UserPassword)) {
395 strlcpy(name, UserNameRequested, name_sz);
396 return(AUTH_VALID);
397 } else {
398 return(AUTH_USER);
399 }
400 }
401
402 #define BUMP(buf, len) while (*(buf)) {++(buf), --(len);}
403 #define ADDC(buf, len, c) if ((len) > 0) {*(buf)++ = (c); --(len);}
404
405 void
rsaencpwd_printsub(unsigned char * data,size_t cnt,unsigned char * buf,size_t buflen)406 rsaencpwd_printsub(unsigned char *data, size_t cnt,
407 unsigned char * buf, size_t buflen)
408 {
409 size_t i;
410
411 buf[buflen-1] = '\0'; /* make sure it's NULL terminated */
412 buflen -= 1;
413
414 switch(data[3]) {
415 case RSA_ENCPWD_REJECT: /* Rejected (reason might follow) */
416 strlcpy((char *)buf, " REJECT ", buflen);
417 goto common;
418
419 case RSA_ENCPWD_ACCEPT: /* Accepted (name might follow) */
420 strlcpy((char *)buf, " ACCEPT ", buflen);
421 common:
422 BUMP(buf, buflen);
423 if (cnt <= 4)
424 break;
425 ADDC(buf, buflen, '"');
426 for (i = 4; i < cnt; i++)
427 ADDC(buf, buflen, data[i]);
428 ADDC(buf, buflen, '"');
429 ADDC(buf, buflen, '\0');
430 break;
431
432 case RSA_ENCPWD_AUTH: /* Authentication data follows */
433 strlcpy((char *)buf, " AUTH", buflen);
434 goto common2;
435
436 case RSA_ENCPWD_CHALLENGEKEY:
437 strlcpy((char *)buf, " CHALLENGEKEY", buflen);
438 goto common2;
439
440 default:
441 snprintf(buf, buflen, " %d (unknown)", data[3]);
442 common2:
443 BUMP(buf, buflen);
444 for (i = 4; i < cnt; i++) {
445 snprintf(buf, buflen, " %d", data[i]);
446 BUMP(buf, buflen);
447 }
448 break;
449 }
450 }
451
rsaencpwd_passwdok(name,passwd)452 int rsaencpwd_passwdok(name, passwd)
453 char *name, *passwd;
454 {
455 char *crypt();
456 char *salt, *p;
457 struct passwd *pwd;
458 int passwdok_status = 0;
459
460 if (pwd = k_getpwnam(name))
461 salt = pwd->pw_passwd;
462 else salt = "xx";
463
464 p = crypt(passwd, salt);
465
466 if (pwd && !strcmp(p, pwd->pw_passwd)) {
467 passwdok_status = 1;
468 } else passwdok_status = 0;
469 return(passwdok_status);
470 }
471
472 #endif
473
474 #ifdef notdef
475
prkey(msg,key)476 prkey(msg, key)
477 char *msg;
478 unsigned char *key;
479 {
480 int i;
481 printf("%s:", msg);
482 for (i = 0; i < 8; i++)
483 printf(" %3d", key[i]);
484 printf("\r\n");
485 }
486 #endif
487