===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/ssh/Attic/auth-rsa.c,v
retrieving revision 1.44
retrieving revision 1.44.2.2
diff -u -r1.44 -r1.44.2.2
--- src/usr.bin/ssh/Attic/auth-rsa.c	2001/07/23 18:14:58	1.44
+++ src/usr.bin/ssh/Attic/auth-rsa.c	2002/05/17 00:03:23	1.44.2.2
@@ -14,7 +14,7 @@
  */
 
 #include "includes.h"
-RCSID("$OpenBSD: auth-rsa.c,v 1.44 2001/07/23 18:14:58 stevesk Exp $");
+RCSID("$OpenBSD: auth-rsa.c,v 1.44.2.2 2002/05/17 00:03:23 miod Exp $");
 
 #include <openssl/rsa.h>
 #include <openssl/md5.h>
@@ -31,6 +31,9 @@
 #include "log.h"
 #include "servconf.h"
 #include "auth.h"
+#include "hostfile.h"
+#include "monitor_wrap.h"
+#include "ssh.h"
 
 /* import */
 extern ServerOptions options;
@@ -51,6 +54,58 @@
  * description of the options.
  */
 
+BIGNUM *
+auth_rsa_generate_challenge(Key *key)
+{
+	BIGNUM *challenge;
+	BN_CTX *ctx;
+
+	if ((challenge = BN_new()) == NULL)
+		fatal("auth_rsa_generate_challenge: BN_new() failed");
+	/* Generate a random challenge. */
+	BN_rand(challenge, 256, 0, 0);
+	if ((ctx = BN_CTX_new()) == NULL)
+		fatal("auth_rsa_generate_challenge: BN_CTX_new() failed");
+	BN_mod(challenge, challenge, key->rsa->n, ctx);
+	BN_CTX_free(ctx);
+
+	return challenge;
+}
+
+int
+auth_rsa_verify_response(Key *key, BIGNUM *challenge, u_char response[16])
+{
+	u_char buf[32], mdbuf[16];
+	MD5_CTX md;
+	int len;
+
+	/* don't allow short keys */
+	if (BN_num_bits(key->rsa->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
+		error("auth_rsa_verify_response: n too small: %d bits",
+		    BN_num_bits(key->rsa->n));
+		return (0);
+	}
+
+	/* The response is MD5 of decrypted challenge plus session id. */
+	len = BN_num_bytes(challenge);
+	if (len <= 0 || len > 32)
+		fatal("auth_rsa_verify_response: bad challenge length %d", len);
+	memset(buf, 0, 32);
+	BN_bn2bin(challenge, buf + 32 - len);
+	MD5_Init(&md);
+	MD5_Update(&md, buf, 32);
+	MD5_Update(&md, session_id, 16);
+	MD5_Final(mdbuf, &md);
+
+	/* Verify that the response is the original challenge. */
+	if (memcmp(response, mdbuf, 16) != 0) {
+		/* Wrong answer. */
+		return (0);
+	}
+	/* Correct answer. */
+	return (1);
+}
+
 /*
  * Performs the RSA authentication challenge-response dialog with the client,
  * and returns true (non-zero) if the client gave the correct answer to
@@ -58,26 +113,19 @@
  */
 
 int
-auth_rsa_challenge_dialog(RSA *pk)
+auth_rsa_challenge_dialog(Key *key)
 {
 	BIGNUM *challenge, *encrypted_challenge;
-	BN_CTX *ctx;
-	u_char buf[32], mdbuf[16], response[16];
-	MD5_CTX md;
-	u_int i;
-	int plen, len;
+	u_char response[16];
+	int i, success;
 
-	encrypted_challenge = BN_new();
-	challenge = BN_new();
+	if ((encrypted_challenge = BN_new()) == NULL)
+		fatal("auth_rsa_challenge_dialog: BN_new() failed");
 
-	/* Generate a random challenge. */
-	BN_rand(challenge, 256, 0, 0);
-	ctx = BN_CTX_new();
-	BN_mod(challenge, challenge, pk->n, ctx);
-	BN_CTX_free(ctx);
+	challenge = PRIVSEP(auth_rsa_generate_challenge(key));
 
 	/* Encrypt the challenge with the public key. */
-	rsa_public_encrypt(encrypted_challenge, challenge, pk);
+	rsa_public_encrypt(encrypted_challenge, challenge, key->rsa);
 
 	/* Send the encrypted challenge to the client. */
 	packet_start(SSH_SMSG_AUTH_RSA_CHALLENGE);
@@ -87,53 +135,32 @@
 	packet_write_wait();
 
 	/* Wait for a response. */
-	packet_read_expect(&plen, SSH_CMSG_AUTH_RSA_RESPONSE);
-	packet_integrity_check(plen, 16, SSH_CMSG_AUTH_RSA_RESPONSE);
+	packet_read_expect(SSH_CMSG_AUTH_RSA_RESPONSE);
 	for (i = 0; i < 16; i++)
 		response[i] = packet_get_char();
+	packet_check_eom();
 
-	/* The response is MD5 of decrypted challenge plus session id. */
-	len = BN_num_bytes(challenge);
-	if (len <= 0 || len > 32)
-		fatal("auth_rsa_challenge_dialog: bad challenge length %d", len);
-	memset(buf, 0, 32);
-	BN_bn2bin(challenge, buf + 32 - len);
-	MD5_Init(&md);
-	MD5_Update(&md, buf, 32);
-	MD5_Update(&md, session_id, 16);
-	MD5_Final(mdbuf, &md);
+	success = PRIVSEP(auth_rsa_verify_response(key, challenge, response));
 	BN_clear_free(challenge);
-
-	/* Verify that the response is the original challenge. */
-	if (memcmp(response, mdbuf, 16) != 0) {
-		/* Wrong answer. */
-		return 0;
-	}
-	/* Correct answer. */
-	return 1;
+	return (success);
 }
 
 /*
- * Performs the RSA authentication dialog with the client.  This returns
- * 0 if the client could not be authenticated, and 1 if authentication was
- * successful.  This may exit if there is a serious protocol violation.
+ * check if there's user key matching client_n,
+ * return key if login is allowed, NULL otherwise
  */
 
 int
-auth_rsa(struct passwd *pw, BIGNUM *client_n)
+auth_rsa_key_allowed(struct passwd *pw, BIGNUM *client_n, Key **rkey)
 {
 	char line[8192], *file;
-	int authenticated;
+	int allowed = 0;
 	u_int bits;
 	FILE *f;
 	u_long linenum = 0;
 	struct stat st;
-	RSA *pk;
+	Key *key;
 
-	/* no user given */
-	if (pw == NULL)
-		return 0;
-
 	/* Temporarily use the user's uid. */
 	temporarily_use_uid(pw);
 
@@ -146,34 +173,30 @@
 		/* Restore the privileged uid. */
 		restore_uid();
 		xfree(file);
-		return 0;
+		return (0);
 	}
 	/* Open the file containing the authorized keys. */
 	f = fopen(file, "r");
 	if (!f) {
 		/* Restore the privileged uid. */
 		restore_uid();
-		packet_send_debug("Could not open %.900s for reading.", file);
-		packet_send_debug("If your home is on an NFS volume, it may need to be world-readable.");
 		xfree(file);
-		return 0;
+		return (0);
 	}
 	if (options.strict_modes &&
 	    secure_filename(f, file, pw, line, sizeof(line)) != 0) {
 		xfree(file);
 		fclose(f);
 		log("Authentication refused: %s", line);
-		packet_send_debug("Authentication refused: %s", line);
 		restore_uid();
-		return 0;
+		return (0);
 	}
-	/* Flag indicating whether authentication has succeeded. */
-	authenticated = 0;
 
-	pk = RSA_new();
-	pk->e = BN_new();
-	pk->n = BN_new();
+	/* Flag indicating whether the key is allowed. */
+	allowed = 0;
 
+	key = key_new(KEY_RSA1);
+
 	/*
 	 * Go though the accepted keys, looking for the current key.  If
 	 * found, perform a challenge-response dialog to verify that the
@@ -210,7 +233,7 @@
 			options = NULL;
 
 		/* Parse the key from the line. */
-		if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {
+		if (hostfile_read_key(&cp, &bits, key) == 0) {
 			debug("%.100s, line %lu: non ssh1 key syntax",
 			    file, linenum);
 			continue;
@@ -218,14 +241,14 @@
 		/* cp now points to the comment part. */
 
 		/* Check if the we have found the desired key (identified by its modulus). */
-		if (BN_cmp(pk->n, client_n) != 0)
+		if (BN_cmp(key->rsa->n, client_n) != 0)
 			continue;
 
 		/* check the real bits  */
-		if (bits != BN_num_bits(pk->n))
+		if (bits != BN_num_bits(key->rsa->n))
 			log("Warning: %s, line %lu: keysize mismatch: "
 			    "actual %d vs. announced %d.",
-			    file, linenum, BN_num_bits(pk->n), bits);
+			    file, linenum, BN_num_bits(key->rsa->n), bits);
 
 		/* We have found the desired key. */
 		/*
@@ -235,22 +258,8 @@
 		if (!auth_parse_options(pw, options, file, linenum))
 			continue;
 
-		/* Perform the challenge-response dialog for this key. */
-		if (!auth_rsa_challenge_dialog(pk)) {
-			/* Wrong response. */
-			verbose("Wrong response to RSA authentication challenge.");
-			packet_send_debug("Wrong response to RSA authentication challenge.");
-			continue;
-		}
-		/*
-		 * Correct response.  The client has been successfully
-		 * authenticated. Note that we have not yet processed the
-		 * options; this will be reset if the options cause the
-		 * authentication to be rejected.
-		 * Break out of the loop if authentication was successful;
-		 * otherwise continue searching.
-		 */
-		authenticated = 1;
+		/* break out, this key is allowed */
+		allowed = 1;
 		break;
 	}
 
@@ -261,13 +270,58 @@
 	xfree(file);
 	fclose(f);
 
-	RSA_free(pk);
-
-	if (authenticated)
-		packet_send_debug("RSA authentication accepted.");
+	/* return key if allowed */
+	if (allowed && rkey != NULL)
+		*rkey = key;
 	else
+		key_free(key);
+	return (allowed);
+}
+
+/*
+ * Performs the RSA authentication dialog with the client.  This returns
+ * 0 if the client could not be authenticated, and 1 if authentication was
+ * successful.  This may exit if there is a serious protocol violation.
+ */
+int
+auth_rsa(struct passwd *pw, BIGNUM *client_n)
+{
+	Key *key;
+	char *fp;
+
+	/* no user given */
+	if (pw == NULL)
+		return 0;
+
+	if (!PRIVSEP(auth_rsa_key_allowed(pw, client_n, &key))) {
 		auth_clear_options();
+		return (0);
+	}
 
-	/* Return authentication result. */
-	return authenticated;
+	/* Perform the challenge-response dialog for this key. */
+	if (!auth_rsa_challenge_dialog(key)) {
+		/* Wrong response. */
+		verbose("Wrong response to RSA authentication challenge.");
+		packet_send_debug("Wrong response to RSA authentication challenge.");
+		/*
+		 * Break out of the loop. Otherwise we might send
+		 * another challenge and break the protocol.
+		 */
+		key_free(key);
+		return (0);
+	}
+	/*
+	 * Correct response.  The client has been successfully
+	 * authenticated. Note that we have not yet processed the
+	 * options; this will be reset if the options cause the
+	 * authentication to be rejected.
+	 */
+	fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
+	verbose("Found matching %s key: %s",
+	    key_type(key), fp);
+	xfree(fp);
+	key_free(key);
+
+	packet_send_debug("RSA authentication accepted.");
+	return (1);
 }