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
36RCSID("$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
90extern auth_debug_mode;
91
92static unsigned char str_data[1024] = { IAC, SB, TELOPT_AUTHENTICATION, 0,
93			  		AUTHTYPE_RSA_ENCPWD, };
94static 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
106static	KTEXT_ST auth;
107static	char name[NAME_SZ];
108static	char user_passwd[PWD_SZ];
109static  char key_file[2*NAME_SZ];
110static  char lhostname[NAME_SZ];
111static char  challenge[CHAL_SZ];
112static int   challenge_len;
113
114	static int
115Data(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
150rsaencpwd_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
173rsaencpwd_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
193rsaencpwd_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
313rsaencpwd_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
384rsaencpwd_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
406rsaencpwd_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
452int rsaencpwd_passwdok(name, passwd)
453char *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
476prkey(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