X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=rsa.c;h=57ea2424f6273eb1c4003be191fcda18ea5bd73e;hb=5ab085cead58ae5eebb9bc8743439782444833bd;hp=81754a7370adb21623099bb89a9dac345dbce0c6;hpb=13b8fbf4548f3457b02afd36e9284d39839d6f85;p=secnet.git

diff --git a/rsa.c b/rsa.c
index 81754a7..57ea242 100644
--- a/rsa.c
+++ b/rsa.c
@@ -42,7 +42,6 @@
 #define mpp(s,n) do { char *p = mpz_get_str(NULL,16,n); printf("%s 0x%sL\n", s, p); free(p); } while (0)
 
 struct rsacommon {
-    struct hash_if *hashi;
     uint8_t *hashbuf;
 };
 
@@ -74,27 +73,22 @@ struct rsapub {
 
 static const char *hexchars="0123456789abcdef";
 
-static void rsa_sethash(struct rsacommon *c, struct hash_if *hash)
+static void rsa_sethash(struct rsacommon *c, struct hash_if *hash,
+			const struct hash_if **in_ops)
 {
     free(c->hashbuf);
-    c->hashbuf=safe_malloc(hash->len, "generate_msg");
-    c->hashi=hash;
+    c->hashbuf=safe_malloc(hash->hlen, "generate_msg");
+    *in_ops=hash;
 }
 static void rsa_pub_sethash(void *sst, struct hash_if *hash)
 {
     struct rsapub *st=sst;
-    rsa_sethash(&st->common, hash);
+    rsa_sethash(&st->common, hash, &st->ops.hash);
 }
 static void rsa_priv_sethash(void *sst, struct hash_if *hash)
 {
     struct rsapriv *st=sst;
-    rsa_sethash(&st->common, hash);
-}
-static void rsa_hash(struct rsacommon *c, const uint8_t *buf, int32_t len)
-{
-    void *hst=c->hashi->init();
-    c->hashi->update(hst,buf,len);
-    c->hashi->final(hst,c->hashbuf);
+    rsa_sethash(&st->common, hash, &st->ops.hash);
 }
 
 static void emsa_pkcs1(MP_INT *n, MP_INT *m,
@@ -124,7 +118,7 @@ static void emsa_pkcs1(MP_INT *n, MP_INT *m,
     msize=mpz_sizeinbase(n, 16);
 
     if (datalen*2+6>=msize) {
-	fatal("rsa_sign: message too big");
+	fatal("rsa: message too big");
     }
 
     strcpy(buff,"0001");
@@ -156,9 +150,9 @@ static bool_t rsa_sign(void *sst, uint8_t *data, int32_t datalen,
     mpz_init(&a);
     mpz_init(&b);
 
-    rsa_hash(&st->common,data,datalen);
+    hash_hash(st->ops.hash,data,datalen,st->common.hashbuf);
     /* Construct the message representative. */
-    emsa_pkcs1(&st->n, &a, st->common.hashbuf, st->common.hashi->len);
+    emsa_pkcs1(&st->n, &a, st->common.hashbuf, st->ops.hash->hlen);
 
     /*
      * Produce an RSA signature (a^d mod n) using the Chinese
@@ -219,9 +213,9 @@ static bool_t rsa_sig_unpick(void *sst, struct buffer_if *msg,
 {
     uint8_t *lp = buf_unprepend(msg, 2);
     if (!lp) return False;
-    sig->siglen = get_uint16(lp);
-    sig->sigstart = buf_unprepend(msg, sig->siglen);
-    if (!sig->sigstart) return False;
+    sig->len = get_uint16(lp);
+    sig->start = buf_unprepend(msg, sig->len);
+    if (!sig->start) return False;
 
     /* In `rsa_sig_check' below, we assume that we can write a nul
      * terminator following the signature.  Make sure there's enough space.
@@ -244,14 +238,14 @@ static bool_t rsa_sig_check(void *sst, uint8_t *data, int32_t datalen,
     mpz_init(&b);
     mpz_init(&c);
 
-    rsa_hash(&st->common,data,datalen);
-    emsa_pkcs1(&st->n, &a, st->common.hashbuf, st->common.hashi->len);
+    hash_hash(st->ops.hash,data,datalen,st->common.hashbuf);
+    emsa_pkcs1(&st->n, &a, st->common.hashbuf, st->ops.hash->hlen);
 
     /* Terminate signature with a '0' - already checked that this will fit */
-    int save = sig->sigstart[sig->siglen];
-    sig->sigstart[sig->siglen] = 0;
-    mpz_set_str(&b, sig->sigstart, 16);
-    sig->sigstart[sig->siglen] = save;
+    int save = sig->start[sig->len];
+    sig->start[sig->len] = 0;
+    mpz_set_str(&b, sig->start, 16);
+    sig->start[sig->len] = save;
 
     mpz_powm(&c, &b, &st->e, &st->n);
 
@@ -281,6 +275,8 @@ static list_t *rsapub_apply(closure_t *self, struct cloc loc, dict_t *context,
     st->common.hashbuf=NULL;
     st->ops.unpick=rsa_sig_unpick;
     st->ops.check=rsa_sig_check;
+    st->ops.hash=0;
+    st->ops.dispose=0; /* xxx */
     st->loc=loc;
 
     i=list_elem(args,0);
@@ -339,6 +335,12 @@ static uint16_t keyfile_get_short(struct cloc loc, FILE *f)
     return r;
 }
 
+#define LDFATAL(...)      cfgfatal(loc,__VA_ARGS__)
+#define LDUNSUP(...)      cfgfatal(loc,__VA_ARGS__)
+#define LDFATAL_FILE(...) cfgfatal_maybefile(f,loc,__VA_ARGS__)
+#define LDUNSUP_FILE(...) cfgfatal_maybefile(f,loc,__VA_ARGS__)
+#define FREE(b)           free(b)
+
 static list_t *rsapriv_apply(closure_t *self, struct cloc loc, dict_t *context,
 			     list_t *args)
 {
@@ -361,6 +363,8 @@ static list_t *rsapriv_apply(closure_t *self, struct cloc loc, dict_t *context,
     st->ops.sethash=rsa_priv_sethash;
     st->common.hashbuf=NULL;
     st->ops.sign=rsa_sign;
+    st->ops.hash=0;
+    st->ops.dispose=0; /* xxx */
     st->loc=loc;
 
     /* Argument is filename pointing to SSH1 private key file */
@@ -392,52 +396,52 @@ static list_t *rsapriv_apply(closure_t *self, struct cloc loc, dict_t *context,
     length=strlen(AUTHFILE_ID_STRING)+1;
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1 || memcmp(b,AUTHFILE_ID_STRING,length)!=0) {
-	cfgfatal_maybefile(f,loc,"rsa-private","failed to read magic ID"
+	LDUNSUP_FILE("rsa-private","failed to read magic ID"
 			   " string from SSH1 private keyfile \"%s\"\n",
 			   filename);
     }
-    free(b);
+    FREE(b);
 
     cipher_type=fgetc(f);
     keyfile_get_int(loc,f); /* "Reserved data" */
     if (cipher_type != 0) {
-	cfgfatal(loc,"rsa-private","we don't support encrypted keyfiles\n");
+	LDUNSUP("rsa-private","we don't support encrypted keyfiles\n");
     }
 
     /* Read the public key */
     keyfile_get_int(loc,f); /* Not sure what this is */
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausible length %ld for modulus\n",
+	LDFATAL("rsa-private","implausible length %ld for modulus\n",
 		 length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f) != 1) {
-	cfgfatal_maybefile(f,loc,"rsa-private","error reading modulus\n");
+	LDFATAL_FILE("rsa-private","error reading modulus\n");
     }
     mpz_init(&st->n);
     read_mpbin(&st->n,b,length);
-    free(b);
+    FREE(b);
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausible length %ld for e\n",length);
+	LDFATAL("rsa-private","implausible length %ld for e\n",length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private","error reading e\n");
+	LDFATAL_FILE("rsa-private","error reading e\n");
     }
     mpz_init(&e);
     read_mpbin(&e,b,length);
-    free(b);
+    FREE(b);
     
     length=keyfile_get_int(loc,f);
     if (length>1024) {
-	cfgfatal(loc,"rsa-private","implausibly long (%ld) key comment\n",
+	LDFATAL("rsa-private","implausibly long (%ld) key comment\n",
 		 length);
     }
     c=safe_malloc(length+1,"rsapriv_apply");
     if (fread(c,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private","error reading key comment\n");
+	LDFATAL_FILE("rsa-private","error reading key comment\n");
     }
     c[length]=0;
 
@@ -445,65 +449,65 @@ static list_t *rsapriv_apply(closure_t *self, struct cloc loc, dict_t *context,
        keyfile is not encrypted, so they should be */
 
     if (keyfile_get_short(loc,f) != keyfile_get_short(loc,f)) {
-	cfgfatal(loc,"rsa-private","corrupt keyfile\n");
+	LDFATAL("rsa-private","corrupt keyfile\n");
     }
 
     /* Read d */
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausibly long (%ld) decryption key\n",
+	LDFATAL("rsa-private","implausibly long (%ld) decryption key\n",
 		 length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private",
+	LDFATAL_FILE("rsa-private",
 			   "error reading decryption key\n");
     }
     mpz_init(&d);
     read_mpbin(&d,b,length);
-    free(b);
+    FREE(b);
     /* Read iqmp (inverse of q mod p) */
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausibly long (%ld)"
+	LDFATAL("rsa-private","implausibly long (%ld)"
 		 " iqmp auxiliary value\n", length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private",
+	LDFATAL_FILE("rsa-private",
 			   "error reading decryption key\n");
     }
     mpz_init(&iqmp);
     read_mpbin(&iqmp,b,length);
-    free(b);
+    FREE(b);
     /* Read q (the smaller of the two primes) */
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausibly long (%ld) q value\n",
+	LDFATAL("rsa-private","implausibly long (%ld) q value\n",
 		 length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private",
+	LDFATAL_FILE("rsa-private",
 			   "error reading q value\n");
     }
     mpz_init(&st->q);
     read_mpbin(&st->q,b,length);
-    free(b);
+    FREE(b);
     /* Read p (the larger of the two primes) */
     length=(keyfile_get_short(loc,f)+7)/8;
     if (length>RSA_MAX_MODBYTES) {
-	cfgfatal(loc,"rsa-private","implausibly long (%ld) p value\n",
+	LDFATAL("rsa-private","implausibly long (%ld) p value\n",
 		 length);
     }
     b=safe_malloc(length,"rsapriv_apply");
     if (fread(b,length,1,f)!=1) {
-	cfgfatal_maybefile(f,loc,"rsa-private",
+	LDFATAL_FILE("rsa-private",
 			   "error reading p value\n");
     }
     mpz_init(&st->p);
     read_mpbin(&st->p,b,length);
-    free(b);
+    FREE(b);
     
     if (fclose(f)!=0) {
 	fatal_perror("rsa-private (%s:%d): fclose",loc.file,loc.line);
@@ -572,14 +576,14 @@ static list_t *rsapriv_apply(closure_t *self, struct cloc loc, dict_t *context,
     
 done_checks:
     if (!valid) {
-	cfgfatal(loc,"rsa-private","file \"%s\" does not contain a "
+	LDFATAL("rsa-private","file \"%s\" does not contain a "
 		 "valid RSA key!\n",filename);
     }
     mpz_clear(&tmp);
     mpz_clear(&tmp2);
     mpz_clear(&tmp3);
 
-    free(c);
+    FREE(c);
     mpz_clear(&e);
     mpz_clear(&d);
     mpz_clear(&iqmp);