1 files changed, 285 insertions, 0 deletions
diff --git a/other/openssh-reverse/auth-rsa.c b/other/openssh-reverse/auth-rsa.c
new file mode 100644
index 0000000..65f9bf7
--- /dev/null
+++ b/other/openssh-reverse/auth-rsa.c
@@ -0,0 +1,285 @@
+/*
+ *
+ * auth-rsa.c
+ *
+ * Author: Tatu Ylonen <ylo@cs.hut.fi>
+ *
+ * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
+ *                    All rights reserved
+ *
+ * Created: Mon Mar 27 01:46:52 1995 ylo
+ *
+ * RSA-based authentication.  This code determines whether to admit a login
+ * based on RSA authentication.  This file also contains functions to check
+ * validity of the host key.
+ *
+ */
+#include "includes.h"
+RCSID("$OpenBSD: auth-rsa.c,v 1.27 2000/07/07 03:55:03 todd Exp $");
+#include "rsa.h"
+#include "packet.h"
+#include "xmalloc.h"
+#include "ssh.h"
+#include "mpaux.h"
+#include "uidswap.h"
+#include "match.h"
+#include "servconf.h"
+#include "auth-options.h"
+#include <openssl/rsa.h>
+#include <openssl/md5.h>
+/*
+ * Session identifier that is used to bind key exchange and authentication
+ * responses to a particular session.
+ */
+extern unsigned char session_id[16];
+/*
+ * The .ssh/authorized_keys file contains public keys, one per line, in the
+ * following format:
+ *   options bits e n comment
+ * where bits, e and n are decimal numbers,
+ * and comment is any string of characters up to newline.  The maximum
+ * length of a line is 8000 characters.  See the documentation for a
+ * description of the options.
+ */
+/*
+ * Performs the RSA authentication challenge-response dialog with the client,
+ * and returns true (non-zero) if the client gave the correct answer to
+ * our challenge; returns zero if the client gives a wrong answer.
+ */
+int
+auth_rsa_challenge_dialog(RSA *pk)
+{
+        BIGNUM *challenge, *encrypted_challenge;
+        BN_CTX *ctx;
+        unsigned char buf[32], mdbuf[16], response[16];
+        MD5_CTX md;
+        unsigned int i;
+        int plen, len;
+        encrypted_challenge = BN_new();
+        challenge = BN_new();
+        /* 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);
+        /* Encrypt the challenge with the public key. */
+        rsa_public_encrypt(encrypted_challenge, challenge, pk);
+        /* Send the encrypted challenge to the client. */
+        packet_start(SSH_SMSG_AUTH_RSA_CHALLENGE);
+        packet_put_bignum(encrypted_challenge);
+        packet_send();
+        BN_clear_free(encrypted_challenge);
+        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);
+        for (i = 0; i < 16; i++)
+                response[i] = packet_get_char();
+        /* 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);
+        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;
+}
+/*
+ * 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)
+{
+        extern ServerOptions options;
+        char line[8192], file[1024];
+        int authenticated;
+        unsigned int bits;
+        FILE *f;
+        unsigned long linenum = 0;
+        struct stat st;
+        RSA *pk;
+        /* Temporarily use the user's uid. */
+        temporarily_use_uid(pw->pw_uid);
+        /* The authorized keys. */
+        snprintf(file, sizeof file, "%.500s/%.100s", pw->pw_dir,
+                 SSH_USER_PERMITTED_KEYS);
+        /* Fail quietly if file does not exist */
+        if (stat(file, &st) < 0) {
+                /* Restore the privileged uid. */
+                restore_uid();
+                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.");
+                return 0;
+        }
+        if (options.strict_modes) {
+                int fail = 0;
+                char buf[1024];
+                /* Check open file in order to avoid open/stat races */
+                if (fstat(fileno(f), &st) < 0 ||
+                    (st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
+                    (st.st_mode & 022) != 0) {
+                        snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
+                                 "bad ownership or modes for '%s'.", pw->pw_name, file);
+                        fail = 1;
+                } else {
+                        /* Check path to SSH_USER_PERMITTED_KEYS */
+                        int i;
+                        static const char *check[] = {
+                                "", SSH_USER_DIR, NULL
+                        };
+                        for (i = 0; check[i]; i++) {
+                                snprintf(line, sizeof line, "%.500s/%.100s", pw->pw_dir, check[i]);
+                                if (stat(line, &st) < 0 ||
+                                    (st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
+                                    (st.st_mode & 022) != 0) {
+                                        snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
+                                                 "bad ownership or modes for '%s'.", pw->pw_name, line);
+                                        fail = 1;
+                                        break;
+                                }
+                        }
+                }
+                if (fail) {
+                        fclose(f);
+                        log("%s",buf);
+                        packet_send_debug("%s",buf);
+                        restore_uid();
+                        return 0;
+                }
+        }
+        /* Flag indicating whether authentication has succeeded. */
+        authenticated = 0;
+        pk = RSA_new();
+        pk->e = BN_new();
+        pk->n = BN_new();
+        /*
+         * Go though the accepted keys, looking for the current key.  If
+         * found, perform a challenge-response dialog to verify that the
+         * user really has the corresponding private key.
+         */
+        while (fgets(line, sizeof(line), f)) {
+                char *cp;
+                char *options;
+                linenum++;
+                /* Skip leading whitespace, empty and comment lines. */
+                for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
+                        ;
+                if (!*cp || *cp == '\n' || *cp == '#')
+                        continue;
+                /*
+                 * Check if there are options for this key, and if so,
+                 * save their starting address and skip the option part
+                 * for now.  If there are no options, set the starting
+                 * address to NULL.
+                 */
+                if (*cp < '0' || *cp > '9') {
+                        int quoted = 0;
+                        options = cp;
+                        for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) {
+                                if (*cp == '\\' && cp[1] == '"')
+                                        cp++;   /* Skip both */
+                                else if (*cp == '"')
+                                        quoted = !quoted;
+                        }
+                } else
+                        options = NULL;
+                /* Parse the key from the line. */
+                if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {
+                        debug("%.100s, line %lu: bad key syntax",
+                              SSH_USER_PERMITTED_KEYS, linenum);
+                        packet_send_debug("%.100s, line %lu: bad key syntax",
+                                          SSH_USER_PERMITTED_KEYS, linenum);
+                        continue;
+                }
+                /* 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)
+                        continue;
+                /* check the real bits  */
+                if (bits != BN_num_bits(pk->n))
+                        log("Warning: %s, line %ld: keysize mismatch: "
+                            "actual %d vs. announced %d.",
+                            file, linenum, BN_num_bits(pk->n), bits);
+                /* We have found the desired key. */
+                /* 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 = auth_parse_options(pw, options, linenum);
+                if (authenticated)
+                        break;
+        }
+        /* Restore the privileged uid. */
+        restore_uid();
+        /* Close the file. */
+        fclose(f);
+        RSA_free(pk);
+        if (authenticated)
+                packet_send_debug("RSA authentication accepted.");
+        /* Return authentication result. */
+        return authenticated;
+}

diff --git a/other/openssh-reverse/auth-rsa.c b/other/openssh-reverse/auth-rsa.c new file mode 100644 index 0000000..65f9bf7 --- /dev/null +++ b/other/openssh-reverse/auth-rsa.c
@@ -0,0 +1,285 @@
	1	/*
	2	*
	3	* auth-rsa.c
	4	*
	5	* Author: Tatu Ylonen <ylo@cs.hut.fi>
	6	*
	7	* Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
	8	* All rights reserved
	9	*
	10	* Created: Mon Mar 27 01:46:52 1995 ylo
	11	*
	12	* RSA-based authentication. This code determines whether to admit a login
	13	* based on RSA authentication. This file also contains functions to check
	14	* validity of the host key.
	15	*
	16	*/
	17
	18	#include "includes.h"
	19	RCSID("$OpenBSD: auth-rsa.c,v 1.27 2000/07/07 03:55:03 todd Exp $");
	20
	21	#include "rsa.h"
	22	#include "packet.h"
	23	#include "xmalloc.h"
	24	#include "ssh.h"
	25	#include "mpaux.h"
	26	#include "uidswap.h"
	27	#include "match.h"
	28	#include "servconf.h"
	29	#include "auth-options.h"
	30
	31	#include <openssl/rsa.h>
	32	#include <openssl/md5.h>
	33
	34	/*
	35	* Session identifier that is used to bind key exchange and authentication
	36	* responses to a particular session.
	37	*/
	38	extern unsigned char session_id[16];
	39
	40	/*
	41	* The .ssh/authorized_keys file contains public keys, one per line, in the
	42	* following format:
	43	* options bits e n comment
	44	* where bits, e and n are decimal numbers,
	45	* and comment is any string of characters up to newline. The maximum
	46	* length of a line is 8000 characters. See the documentation for a
	47	* description of the options.
	48	*/
	49
	50	/*
	51	* Performs the RSA authentication challenge-response dialog with the client,
	52	* and returns true (non-zero) if the client gave the correct answer to
	53	* our challenge; returns zero if the client gives a wrong answer.
	54	*/
	55
	56	int
	57	auth_rsa_challenge_dialog(RSA *pk)
	58	{
	59	BIGNUM challenge, encrypted_challenge;
	60	BN_CTX *ctx;
	61	unsigned char buf[32], mdbuf[16], response[16];
	62	MD5_CTX md;
	63	unsigned int i;
	64	int plen, len;
	65
	66	encrypted_challenge = BN_new();
	67	challenge = BN_new();
	68
	69	/* Generate a random challenge. */
	70	BN_rand(challenge, 256, 0, 0);
	71	ctx = BN_CTX_new();
	72	BN_mod(challenge, challenge, pk->n, ctx);
	73	BN_CTX_free(ctx);
	74
	75	/* Encrypt the challenge with the public key. */
	76	rsa_public_encrypt(encrypted_challenge, challenge, pk);
	77
	78	/* Send the encrypted challenge to the client. */
	79	packet_start(SSH_SMSG_AUTH_RSA_CHALLENGE);
	80	packet_put_bignum(encrypted_challenge);
	81	packet_send();
	82	BN_clear_free(encrypted_challenge);
	83	packet_write_wait();
	84
	85	/* Wait for a response. */
	86	packet_read_expect(&plen, SSH_CMSG_AUTH_RSA_RESPONSE);
	87	packet_integrity_check(plen, 16, SSH_CMSG_AUTH_RSA_RESPONSE);
	88	for (i = 0; i < 16; i++)
	89	response[i] = packet_get_char();
	90
	91	/* The response is MD5 of decrypted challenge plus session id. */
	92	len = BN_num_bytes(challenge);
	93	if (len <= 0 \|\| len > 32)
	94	fatal("auth_rsa_challenge_dialog: bad challenge length %d", len);
	95	memset(buf, 0, 32);
	96	BN_bn2bin(challenge, buf + 32 - len);
	97	MD5_Init(&md);
	98	MD5_Update(&md, buf, 32);
	99	MD5_Update(&md, session_id, 16);
	100	MD5_Final(mdbuf, &md);
	101	BN_clear_free(challenge);
	102
	103	/* Verify that the response is the original challenge. */
	104	if (memcmp(response, mdbuf, 16) != 0) {
	105	/* Wrong answer. */
	106	return 0;
	107	}
	108	/* Correct answer. */
	109	return 1;
	110	}
	111
	112	/*
	113	* Performs the RSA authentication dialog with the client. This returns
	114	* 0 if the client could not be authenticated, and 1 if authentication was
	115	* successful. This may exit if there is a serious protocol violation.
	116	*/
	117
	118	int
	119	auth_rsa(struct passwd pw, BIGNUM client_n)
	120	{
	121	extern ServerOptions options;
	122	char line[8192], file[1024];
	123	int authenticated;
	124	unsigned int bits;
	125	FILE *f;
	126	unsigned long linenum = 0;
	127	struct stat st;
	128	RSA *pk;
	129
	130	/* Temporarily use the user's uid. */
	131	temporarily_use_uid(pw->pw_uid);
	132
	133	/* The authorized keys. */
	134	snprintf(file, sizeof file, "%.500s/%.100s", pw->pw_dir,
	135	SSH_USER_PERMITTED_KEYS);
	136
	137	/* Fail quietly if file does not exist */
	138	if (stat(file, &st) < 0) {
	139	/* Restore the privileged uid. */
	140	restore_uid();
	141	return 0;
	142	}
	143	/* Open the file containing the authorized keys. */
	144	f = fopen(file, "r");
	145	if (!f) {
	146	/* Restore the privileged uid. */
	147	restore_uid();
	148	packet_send_debug("Could not open %.900s for reading.", file);
	149	packet_send_debug("If your home is on an NFS volume, it may need to be world-readable.");
	150	return 0;
	151	}
	152	if (options.strict_modes) {
	153	int fail = 0;
	154	char buf[1024];
	155	/* Check open file in order to avoid open/stat races */
	156	if (fstat(fileno(f), &st) < 0 \|\|
	157	(st.st_uid != 0 && st.st_uid != pw->pw_uid) \|\|
	158	(st.st_mode & 022) != 0) {
	159	snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
	160	"bad ownership or modes for '%s'.", pw->pw_name, file);
	161	fail = 1;
	162	} else {
	163	/* Check path to SSH_USER_PERMITTED_KEYS */
	164	int i;
	165	static const char *check[] = {
	166	"", SSH_USER_DIR, NULL
	167	};
	168	for (i = 0; check[i]; i++) {
	169	snprintf(line, sizeof line, "%.500s/%.100s", pw->pw_dir, check[i]);
	170	if (stat(line, &st) < 0 \|\|
	171	(st.st_uid != 0 && st.st_uid != pw->pw_uid) \|\|
	172	(st.st_mode & 022) != 0) {
	173	snprintf(buf, sizeof buf, "RSA authentication refused for %.100s: "
	174	"bad ownership or modes for '%s'.", pw->pw_name, line);
	175	fail = 1;
	176	break;
	177	}
	178	}
	179	}
	180	if (fail) {
	181	fclose(f);
	182	log("%s",buf);
	183	packet_send_debug("%s",buf);
	184	restore_uid();
	185	return 0;
	186	}
	187	}
	188	/* Flag indicating whether authentication has succeeded. */
	189	authenticated = 0;
	190
	191	pk = RSA_new();
	192	pk->e = BN_new();
	193	pk->n = BN_new();
	194
	195	/*
	196	* Go though the accepted keys, looking for the current key. If
	197	* found, perform a challenge-response dialog to verify that the
	198	* user really has the corresponding private key.
	199	*/
	200	while (fgets(line, sizeof(line), f)) {
	201	char *cp;
	202	char *options;
	203
	204	linenum++;
	205
	206	/* Skip leading whitespace, empty and comment lines. */
	207	for (cp = line; cp == ' ' \|\| cp == '\t'; cp++)
	208	;
	209	if (!cp \|\| cp == '\n' \|\| *cp == '#')
	210	continue;
	211
	212	/*
	213	* Check if there are options for this key, and if so,
	214	* save their starting address and skip the option part
	215	* for now. If there are no options, set the starting
	216	* address to NULL.
	217	*/
	218	if (cp < '0' \|\| cp > '9') {
	219	int quoted = 0;
	220	options = cp;
	221	for (; cp && (quoted \|\| (cp != ' ' && *cp != '\t')); cp++) {
	222	if (*cp == '\\' && cp[1] == '"')
	223	cp++; /* Skip both */
	224	else if (*cp == '"')
	225	quoted = !quoted;
	226	}
	227	} else
	228	options = NULL;
	229
	230	/* Parse the key from the line. */
	231	if (!auth_rsa_read_key(&cp, &bits, pk->e, pk->n)) {
	232	debug("%.100s, line %lu: bad key syntax",
	233	SSH_USER_PERMITTED_KEYS, linenum);
	234	packet_send_debug("%.100s, line %lu: bad key syntax",
	235	SSH_USER_PERMITTED_KEYS, linenum);
	236	continue;
	237	}
	238	/* cp now points to the comment part. */
	239
	240	/* Check if the we have found the desired key (identified by its modulus). */
	241	if (BN_cmp(pk->n, client_n) != 0)
	242	continue;
	243
	244	/* check the real bits */
	245	if (bits != BN_num_bits(pk->n))
	246	log("Warning: %s, line %ld: keysize mismatch: "
	247	"actual %d vs. announced %d.",
	248	file, linenum, BN_num_bits(pk->n), bits);
	249
	250	/* We have found the desired key. */
	251
	252	/* Perform the challenge-response dialog for this key. */
	253	if (!auth_rsa_challenge_dialog(pk)) {
	254	/* Wrong response. */
	255	verbose("Wrong response to RSA authentication challenge.");
	256	packet_send_debug("Wrong response to RSA authentication challenge.");
	257	continue;
	258	}
	259	/*
	260	* Correct response. The client has been successfully
	261	* authenticated. Note that we have not yet processed the
	262	* options; this will be reset if the options cause the
	263	* authentication to be rejected.
	264	* Break out of the loop if authentication was successful;
	265	* otherwise continue searching.
	266	*/
	267	authenticated = auth_parse_options(pw, options, linenum);
	268	if (authenticated)
	269	break;
	270	}
	271
	272	/* Restore the privileged uid. */
	273	restore_uid();
	274
	275	/* Close the file. */
	276	fclose(f);
	277
	278	RSA_free(pk);
	279
	280	if (authenticated)
	281	packet_send_debug("RSA authentication accepted.");
	282
	283	/* Return authentication result. */
	284	return authenticated;
	285	}