Convert to keyserv, telnetd and telnet to libcrypto's BIGNUM
authorJoerg Sonnenberger <joerg@dragonflybsd.org>
Tue, 11 Jan 2005 13:22:41 +0000 (13:22 +0000)
committerJoerg Sonnenberger <joerg@dragonflybsd.org>
Tue, 11 Jan 2005 13:22:41 +0000 (13:22 +0000)
implementatation.

crypto/telnet/libtelnet/pk.c
kerberos5/libexec/telnetd/Makefile
kerberos5/usr.bin/telnet/Makefile
secure/libexec/telnetd/Makefile
secure/usr.bin/telnet/Makefile
usr.sbin/keyserv/Makefile
usr.sbin/keyserv/setkey.c

index 06d211d..355a13e 100644 (file)
@@ -28,7 +28,7 @@
  * 
  *
  * $FreeBSD: src/crypto/telnet/libtelnet/pk.c,v 1.2.2.4 2002/08/24 07:28:35 nsayer Exp $
- * $DragonFly: src/crypto/telnet/libtelnet/pk.c,v 1.2 2003/06/17 04:24:37 dillon Exp $
+ * $DragonFly: src/crypto/telnet/libtelnet/pk.c,v 1.3 2005/01/11 13:22:41 joerg Exp $
  */
 
 /* public key routines */
  */
 
 #include <sys/time.h>
-#include <openssl/des.h>
+#include <err.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "mp.h"
+#include <openssl/bn.h>
+#include <openssl/crypto.h>
+#include <openssl/des.h>
+#include <openssl/err.h>
+
 #include "pk.h"
  
 static void adjust(char keyout[HEXKEYBYTES+1], char *keyin);
@@ -58,28 +62,30 @@ static void adjust(char keyout[HEXKEYBYTES+1], char *keyin);
  * Choose top 128 bits of the common key to use as our idea key.
  */
 static void
-extractideakey(MINT *ck, IdeaData *ideakey)
+extractideakey(BIGNUM *ck, IdeaData *ideakey)
 {
-        MINT *a;
-        MINT *z;
-        short r;
+        BIGNUM *a, *z;
         int i;
-        short base = (1 << 8);
+        BN_ULONG r, base = (1 << 8);
         char *k;
 
-        z = itom(0);
-        a = itom(0);
-        madd(ck, z, a);
+       if ((z = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM");
+       BN_zero(z);
+       if ((a = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM");
+       BN_zero(a);
+       BN_add(a, ck, z);
         for (i = 0; i < ((KEYSIZE - 128) / 8); i++) {
-                sdiv(a, base, a, &r);
+               r = BN_div_word(a, base);
         }
         k = (char *)ideakey;
         for (i = 0; i < 16; i++) {
-                sdiv(a, base, a, &r);
+                r = BN_div_word(a, base);
                 *k++ = r;
         }
-       mfree(z);
-        mfree(a);
+       BN_free(z);
+       BN_free(a);
 }
 
 /*
@@ -87,28 +93,30 @@ extractideakey(MINT *ck, IdeaData *ideakey)
  * overwriting the lower order bits by setting parity. 
  */
 static void
-extractdeskey(MINT *ck, DesData *deskey)
+extractdeskey(BIGNUM *ck, DesData *deskey)
 {
-        MINT *a;
-        MINT *z;
-        short r;
+        BIGNUM *a, *z;
         int i;
-        short base = (1 << 8);
+        BN_ULONG r, base = (1 << 8);
         char *k;
 
-        z = itom(0);
-        a = itom(0);
-        madd(ck, z, a);
+       if ((z = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM");
+       BN_zero(z);
+       if ((a = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM");
+       BN_zero(a);
+       BN_add(a, ck, z);
         for (i = 0; i < ((KEYSIZE - 64) / 2) / 8; i++) {
-                sdiv(a, base, a, &r);
+               r = BN_div_word(a, base);
         }
         k = (char *)deskey;
         for (i = 0; i < 8; i++) {
-                sdiv(a, base, a, &r);
+               r = BN_div_word(a, base);
                 *k++ = r;
         }
-       mfree(z);
-        mfree(a);
+       BN_free(z);
+       BN_free(a);
 }
 
 /*
@@ -117,22 +125,30 @@ extractdeskey(MINT *ck, DesData *deskey)
 void
 common_key(char *xsecret, char *xpublic, IdeaData *ideakey, DesData *deskey)
 {
-        MINT *public;
-        MINT *secret;
-        MINT *common;
-       MINT *modulus = xtom(HEXMODULUS);
+        BIGNUM *public, *secret, *common, *modulus;
+       BN_CTX *ctx;
 
-        public = xtom(xpublic);
-        secret = xtom(xsecret);
-        common = itom(0);
-        pow(public, secret, modulus, common);
+       if ((ctx = BN_CTX_new()) == NULL)
+               errx(1, "could not create BN_CTX");
+       if (BN_hex2bn(&modulus, HEXMODULUS) == NULL)
+               errx(1, "could not convert modulus");
+       if (BN_hex2bn(&public, xpublic) == NULL)
+               errx(1, "could not convert public");
+       if (BN_hex2bn(&secret, xsecret) == NULL)
+               errx(1, "could not convert secret");
+
+       if ((common = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM");
+       BN_zero(common);
+       BN_mod_exp(common, public, secret, modulus, ctx);
         extractdeskey(common, deskey);
         extractideakey(common, ideakey);
        des_set_odd_parity(deskey);
-        mfree(common);
-        mfree(secret);
-        mfree(public);
-       mfree(modulus);
+       BN_free(common);
+       BN_free(secret);
+       BN_free(public);
+       BN_free(modulus);
+       BN_CTX_free(ctx);
 }
 
 /*
@@ -143,54 +159,88 @@ getseed(char *seed, int seedsize)
 {
        int i;
 
-       srandomdev();
        for (i = 0; i < seedsize; i++) {
-               seed[i] = random() & 0xff;
+               seed[i] = arc4random() & 0xff;
        }
 }
 
+static BIGNUM *
+itobn(long i)
+{
+       BIGNUM *n = 0;
+
+       if ((n = BN_new()) == NULL)
+               errx(1, "could not create BIGNUM: %s",
+                    ERR_error_string(ERR_get_error(), 0));
+       BN_init(n);
+       if (i > 0)
+               BN_add_word(n, (u_long)i);
+       else
+               BN_sub_word(n, (u_long)(-i));
+       return(n);
+}
+
 /*
  * Generate a random public/secret key pair
  */
 void
 genkeys(char *public, char *secret)
 {
-        size_t i;
-#       define BASEBITS (8*sizeof(short) - 1)
-#       define BASE (1 << BASEBITS)
-        MINT *pk = itom(0);
-        MINT *sk = itom(0);
-        MINT *tmp;
-        MINT *base = itom(BASE);
-        MINT *root = itom(PROOT);
-        MINT *modulus = xtom(HEXMODULUS);
-        short r;
-        unsigned short seed[KEYSIZE/BASEBITS + 1];
-        char *xkey;
+#define        BASEBITS (8*sizeof (short) - 1)
+#define        BASE (short)(1 << BASEBITS)
 
-        getseed((char *)seed, sizeof(seed));    
-        for (i = 0; i < KEYSIZE/BASEBITS + 1; i++) {
-                r = seed[i] % BASE;
-                tmp = itom(r);
-                mult(sk, base, sk);
-                madd(sk, tmp, sk);
-                mfree(tmp);  
-        }
-        tmp = itom(0);
-        mdiv(sk, modulus, tmp, sk);
-        mfree(tmp);
-        pow(root, sk, modulus, pk); 
-        xkey = mtox(sk);   
-        adjust(secret, xkey);
-        xkey = mtox(pk);
-        adjust(public, xkey);
-        mfree(sk);
-        mfree(base);
-        mfree(pk);
-        mfree(root);
-        mfree(modulus);
+       unsigned int i;
+       short r;
+       unsigned short seed[KEYSIZE/BASEBITS + 1];
+       char *xkey;
+
+       BN_CTX *ctx;
+       BIGNUM *pk, *sk, *tmp, *base, *root, *modulus;
+
+       pk = itobn(0);
+       sk = itobn(0);
+       tmp = itobn(0);
+       base = itobn(BASE);
+       root = itobn(PROOT);
+       modulus = NULL;
+       if (BN_hex2bn(&modulus, HEXMODULUS) == NULL)
+               errx(1, "could not convert modulus to BIGNUM: %s",
+                    ERR_error_string(ERR_get_error(), 0));
+
+       if ((ctx = BN_CTX_new()) == NULL)
+               errx(1, "could not create BN_CTX: %s",
+                    ERR_error_string(ERR_get_error(), 0));
+
+       getseed((char *)seed, sizeof (seed));
+       for (i = 0; i < KEYSIZE/BASEBITS + 1; i++) {
+               r = seed[i] % BASE;
+               BN_zero(tmp);
+               BN_add_word(tmp, r);
+               BN_mul(sk, base, sk, ctx);
+               BN_add(sk, tmp, sk);
+       }
+       BN_zero(tmp);
+       BN_div(tmp, sk, sk, modulus, ctx);
+       BN_mod_exp(pk, root, sk, modulus, ctx);
+
+       if ((xkey = BN_bn2hex(sk)) == NULL)
+               errx(1, "could convert sk to hex: %s",
+                    ERR_error_string(ERR_get_error(), 0));
+       adjust(secret, xkey);
+       OPENSSL_free(xkey);
+
+       if ((xkey = BN_bn2hex(pk)) == NULL)
+               errx(1, "could convert pk to hex: %s",
+                    ERR_error_string(ERR_get_error(), 0));
+       adjust(public, xkey);
+       OPENSSL_free(xkey);
+
+       BN_free(base);
+       BN_free(modulus);
+       BN_free(pk);
+       BN_free(sk);
+       BN_free(root);
+       BN_free(tmp);
 } 
 
 /*
index 2382aa4..235d292 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/kerberos5/libexec/telnetd/Makefile,v 1.15.2.2 2003/04/24 19:14:00 nectar Exp $
-# $DragonFly: src/kerberos5/libexec/telnetd/Attic/Makefile,v 1.3 2003/08/05 07:45:40 asmodai Exp $
+# $DragonFly: src/kerberos5/libexec/telnetd/Attic/Makefile,v 1.4 2005/01/11 13:22:41 joerg Exp $
 
 # Do not define -DKLUDGELINEMODE, as it does not interact well with many
 # telnet implementations.
@@ -17,10 +17,10 @@ CFLAGS+=    -DKRB5 -DFORWARD -Dnet_write=telnet_net_write
 
 WARNS?=                2
 
-DPADD=         ${LIBUTIL} ${LIBTERMCAP} ${LIBTELNET} ${LIBMP} ${LIBCRYPTO} \
+DPADD=         ${LIBUTIL} ${LIBTERMCAP} ${LIBTELNET} ${LIBCRYPTO} \
                ${LIBKRB5} ${LIBASN1} ${LIBROKEN} ${LIBCOM_ERR} \
                ${LIBCRYPT} ${LIBPAM}
-LDADD=         -lutil -ltermcap ${LIBTELNET} -lmp -lcrypto \
+LDADD=         -lutil -ltermcap ${LIBTELNET} -lcrypto \
                -L${KRB5OBJDIR} -lkrb5 -L${ASN1OBJDIR} -lasn1 \
                -L${ROKENOBJDIR} -lroken -lcom_err \
                -lcrypt ${MINUSLPAM}
index 04501c3..984b3e8 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/kerberos5/usr.bin/telnet/Makefile,v 1.16.2.2 2003/04/24 19:14:00 nectar Exp $
-# $DragonFly: src/kerberos5/usr.bin/telnet/Attic/Makefile,v 1.3 2003/08/05 07:45:41 asmodai Exp $
+# $DragonFly: src/kerberos5/usr.bin/telnet/Attic/Makefile,v 1.4 2005/01/11 13:22:41 joerg Exp $
 
 PROG=          telnet
 
@@ -14,10 +14,10 @@ CFLAGS+=    -DKRB5 -DFORWARD -Dnet_write=telnet_net_write
 
 WARNS?=                2
 
-DPADD=         ${LIBTERMCAP} ${LIBTELNET} ${LIBMP} \
+DPADD=         ${LIBTERMCAP} ${LIBTELNET} \
                ${LIBKRB5} ${LIBASN1} ${LIBCOM_ERR} ${LIBROKEN} \
                ${LIBCRYPTO} ${LIBCRYPT} ${LIBIPSEC} ${LIBPAM}
-LDADD=         -ltermcap ${LIBTELNET} -lmp \
+LDADD=         -ltermcap ${LIBTELNET} \
                -L${KRB5OBJDIR} -lkrb5 -L${ASN1OBJDIR} -lasn1 -lcom_err \
                -L${ROKENOBJDIR} -lroken \
                -lcrypto -lcrypt -lipsec ${MINUSLPAM}
index 85cffb7..05d800e 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/secure/libexec/telnetd/Makefile,v 1.19.2.4 2002/07/03 22:20:25 des Exp $
-# $DragonFly: src/secure/libexec/telnetd/Makefile,v 1.2 2003/06/17 04:27:48 dillon Exp $
+# $DragonFly: src/secure/libexec/telnetd/Makefile,v 1.3 2005/01/11 13:22:40 joerg Exp $
 
 # Do not define -DKLUDGELINEMODE, as it does not interact well with many
 # telnet implementations.
@@ -17,10 +17,9 @@ CFLAGS+=     -DLINEMODE -DUSE_TERMIO -DDIAGNOSTICS -DOLD_ENVIRON \
 WARNS?=                2
 WFORMAT?=      0
 
-DPADD=         ${LIBUTIL} ${LIBTERMCAP} ${LIBTELNET} ${LIBMP} ${LIBCRYPTO} \
+DPADD=         ${LIBUTIL} ${LIBTERMCAP} ${LIBTELNET} ${LIBCRYPTO} \
                ${LIBCRYPT} ${LIBPAM}
-LDADD=         -lutil -ltermcap ${LIBTELNET} -lmp -lcrypto \
-               -lcrypt ${MINUSLPAM}
+LDADD=         -lutil -ltermcap ${LIBTELNET} -lcrypto -lcrypt ${MINUSLPAM}
 
 .include <bsd.prog.mk>
 
index aadaeaa..aed3509 100644 (file)
@@ -1,5 +1,5 @@
 # $FreeBSD: src/secure/usr.bin/telnet/Makefile,v 1.21.2.4 2002/07/03 22:20:33 des Exp $
-# $DragonFly: src/secure/usr.bin/telnet/Makefile,v 1.2 2003/06/17 04:27:48 dillon Exp $
+# $DragonFly: src/secure/usr.bin/telnet/Makefile,v 1.3 2005/01/11 13:22:41 joerg Exp $
 
 PROG=          telnet
 
@@ -12,9 +12,9 @@ CFLAGS+=      -DKLUDGELINEMODE -DUSE_TERMIO -DENV_HACK -DOPIE \
 
 WARNS?=                2
 
-DPADD=         ${LIBTERMCAP} ${LIBTELNET} ${LIBMP} \
+DPADD=         ${LIBTERMCAP} ${LIBTELNET} \
                ${LIBCRYPTO} ${LIBCRYPT} ${LIBIPSEC} ${LIBPAM}
-LDADD=         -ltermcap ${LIBTELNET} -lmp \
+LDADD=         -ltermcap ${LIBTELNET} \
                -lcrypto -lcrypt -lipsec ${MINUSLPAM}
 
 .include <bsd.prog.mk>
index 956f04d..d7c7b70 100644 (file)
@@ -1,15 +1,16 @@
 # $FreeBSD: src/usr.sbin/keyserv/Makefile,v 1.5.2.1 2001/04/25 12:09:50 ru Exp $
-# $DragonFly: src/usr.sbin/keyserv/Makefile,v 1.3 2004/03/20 16:27:42 drhodus Exp $
+# $DragonFly: src/usr.sbin/keyserv/Makefile,v 1.4 2005/01/11 13:22:40 joerg Exp $
 
 PROG=  keyserv
 SRCS=  keyserv.c setkey.c keyserv_uid.c crypt_svc.c crypt_server.c crypt.h
+WARNS?=        6
 
 MAN=   keyserv.8
 
 CFLAGS+= -DKEYSERV_RANDOM -DBROKEN_DES -I.
 
-DPADD= ${LIBMP} ${LIBRPCSVC}
-LDADD= -lmp -lrpcsvc
+DPADD= ${LIBCRYPTO} ${LIBRPCSVC}
+LDADD= -lcrypto -lrpcsvc
 
 RPCDIR=        ${DESTDIR}/usr/include/rpcsvc
 
index b5db919..d27a0ca 100644 (file)
@@ -28,7 +28,7 @@
  *
  * @(#)setkey.c        1.11    94/04/25 SMI
  * $FreeBSD: src/usr.sbin/keyserv/setkey.c,v 1.3 1999/08/28 01:16:41 peter Exp $
- * $DragonFly: src/usr.sbin/keyserv/setkey.c,v 1.7 2004/12/18 22:48:03 swildner Exp $
+ * $DragonFly: src/usr.sbin/keyserv/setkey.c,v 1.8 2005/01/11 13:22:40 joerg Exp $
  */
 
 /*
@@ -41,7 +41,7 @@
  * and use them to decrypt and encrypt DES keys.
  * Cache the common keys, so the expensive computation is avoided.
  */
-#include <mp.h>
+#include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <rpc/des.h>
 #include <sys/errno.h>
 #include "keyserv.h"
+#include <openssl/bn.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
 
-static MINT *MODULUS;
+static BIGNUM *modulus;
 static char *fetchsecretkey( uid_t );
 static void writecache( char *, char *, des_block * );
 static int readcache( char *, char *, des_block * );
-static void extractdeskey ( MINT *, des_block * );
+static void extractdeskey ( BIGNUM *, des_block * );
 static int storesecretkey( uid_t, keybuf );
 static keystatus pk_crypt( uid_t, char *, netobj *, des_block *, int);
 static int nodefaultkeys = 0;
@@ -79,7 +82,9 @@ pk_nodefaultkeys(void)
 void
 setmodulus(char *modx)
 {
-       MODULUS = xtom(modx);
+       if (BN_hex2bn(&modulus, modx) == NULL)
+               errx(1, "could not convert modulus to BIGNUM: %s",
+                    ERR_error_string(ERR_get_error(), 0));
 }
 
 /*
@@ -147,10 +152,9 @@ pk_crypt(uid_t uid, char *remote_name, netobj *remote_key, des_block *key,
        char xpublic[1024];
        char xsecret_hold[1024];
        des_block deskey;
-       int err;
-       MINT *public;
-       MINT *secret;
-       MINT *common;
+       int error;
+       BIGNUM *public, *secret, *common;
+       BN_CTX *ctx;
        char zero[8];
 
        xsecret = fetchsecretkey(uid);
@@ -175,23 +179,36 @@ pk_crypt(uid_t uid, char *remote_name, netobj *remote_key, des_block *key,
        }
 
        if (!readcache(xpublic, xsecret, &deskey)) {
-               public = xtom(xpublic);
-               secret = xtom(xsecret);
-               /* Sanity Check on public and private keys */
-               if ((public == NULL) || (secret == NULL))
+               if ((ctx = BN_CTX_new()) == NULL)
                        return (KEY_SYSTEMERR);
+               if (BN_hex2bn(&public, xpublic) == NULL) {
+                       BN_CTX_free(ctx);
+                       return (KEY_SYSTEMERR);
+               }
+               if (BN_hex2bn(&secret, xsecret) == NULL) {
+                       BN_free(public);
+                       BN_CTX_free(ctx);
+                       return (KEY_SYSTEMERR);
+               }
 
-               common = itom(0);
-               pow(public, secret, MODULUS, common);
+               if ((common = BN_new()) == NULL) {
+                       BN_free(secret);
+                       BN_free(public);
+                       BN_CTX_free(ctx);
+                       return (KEY_SYSTEMERR);
+               }
+               BN_zero(common);
+               BN_mod_exp(common, public, secret, modulus, ctx);
                extractdeskey(common, &deskey);
                writecache(xpublic, xsecret, &deskey);
-               mfree(secret);
-               mfree(public);
-               mfree(common);
+               BN_free(secret);
+               BN_free(public);
+               BN_free(common);
+               BN_CTX_free(ctx);
        }
-       err = ecb_crypt((char *)&deskey, (char *)key, sizeof (des_block),
+       error = ecb_crypt((char *)&deskey, (char *)key, sizeof (des_block),
                DES_HW | mode);
-       if (DES_FAILED(err)) {
+       if (DES_FAILED(error)) {
                return (KEY_SYSTEMERR);
        }
        return (KEY_SUCCESS);
@@ -202,9 +219,8 @@ pk_get_conv_key(uid_t uid, keybuf xpublic, cryptkeyres *result)
 {
        char *xsecret;
        char xsecret_hold[1024];
-       MINT *public;
-       MINT *secret;
-       MINT *common;
+       BIGNUM *public, *secret, *common;
+       BN_CTX *ctx;
        char zero[8];
 
 
@@ -222,19 +238,33 @@ pk_get_conv_key(uid_t uid, keybuf xpublic, cryptkeyres *result)
        }
 
        if (!readcache(xpublic, xsecret, &result->cryptkeyres_u.deskey)) {
-               public = xtom(xpublic);
-               secret = xtom(xsecret);
-               /* Sanity Check on public and private keys */
-               if ((public == NULL) || (secret == NULL))
+               if ((ctx = BN_CTX_new()) == NULL)
+                       return (KEY_SYSTEMERR);
+               if (BN_hex2bn(&public, xpublic) == NULL) {
+                       BN_CTX_free(ctx);
                        return (KEY_SYSTEMERR);
+               }
+               if (BN_hex2bn(&secret, xsecret) == NULL) {
+                       BN_free(public);
+                       BN_CTX_free(ctx);
+                       return (KEY_SYSTEMERR);
+               }
+
+               if ((common = BN_new()) == NULL) {
+                       BN_free(secret);
+                       BN_free(public);
+                       BN_CTX_free(ctx);
+                       return (KEY_SYSTEMERR);
+               }
+               BN_zero(common);
+               BN_mod_exp(common, public, secret, modulus, ctx);
 
-               common = itom(0);
-               pow(public, secret, MODULUS, common);
                extractdeskey(common, &result->cryptkeyres_u.deskey);
                writecache(xpublic, xsecret, &result->cryptkeyres_u.deskey);
-               mfree(secret);
-               mfree(public);
-               mfree(common);
+               BN_free(secret);
+               BN_free(public);
+               BN_free(common);
+               BN_CTX_free(ctx);
        }
 
        return (KEY_SUCCESS);
@@ -245,29 +275,25 @@ pk_get_conv_key(uid_t uid, keybuf xpublic, cryptkeyres *result)
  * overwriting the lower order bits by setting parity.
  */
 static void
-extractdeskey(MINT *ck, des_block *deskey)
+extractdeskey(BIGNUM *ck, des_block *deskey)
 {
-       MINT *a;
-       short r;
+       BIGNUM *a;
        int i;
-       short base = (1 << 8);
+       BN_ULONG r, base = (1 << 8);
        char *k;
 
-       a = itom(0);
-#ifdef SOLARIS_MP
-       _mp_move(ck, a);
-#else
-       move(ck, a);
-#endif
+       if ((a = BN_dup(ck)) == NULL)
+               errx(1, "could not copy BIGNUM");
+
        for (i = 0; i < ((KEYSIZE - 64) / 2) / 8; i++) {
-               sdiv(a, base, a, &r);
+               r = BN_div_word(a, base);
        }
        k = deskey->c;
        for (i = 0; i < 8; i++) {
-               sdiv(a, base, a, &r);
+               r = BN_div_word(a, base);
                *k++ = r;
        }
-       mfree(a);
+       BN_free(a);
        des_setparity((char *)deskey);
 }