rustyrussell · Aug 15, 2014 · Aug 15, 2014 · Aug 15, 2014
Showing with 71 additions and 15 deletions.

+37 −10 base58.c

+1 −0 base58.h

+28 −0 test/run-01-base16.c

+5 −5 test/run-01-base58.c
diff --git a/base58.c b/base58.c
@@ -12,16 +12,17 @@
 #include <openssl/sha.h>
 #include <string.h>
 
-static const char enc[] =
+static const char enc_16[] = "0123456789abcdef";
+static const char enc_58[] =
 	"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
-static char encode_char(unsigned long val)
+static char encode_char(unsigned long val, const char *enc)
 {
 	assert(val < strlen(enc));
 	return enc[val];
 }
 
-static int decode_char(char c)
+static int decode_char(char c, const char *enc)
 {
 	const char *pos = strchr(enc, c);
 	if (!pos)
@@ -58,7 +59,7 @@ static char *encode_base58(char *buf, size_t buflen,
 			p = NULL;
 			goto out;
 		}
-		*p = encode_char(rem);
+		*p = encode_char(rem, enc_58);
 	}
 
 	/* Now, this is really weird.  We pad with zeroes, but not at
@@ -69,7 +70,7 @@ static char *encode_base58(char *buf, size_t buflen,
 			p = NULL;
 			goto out;
 		}
-		*p = encode_char(0);
+		*p = encode_char(0, enc_58);
 		data_len--;
 		data++;
 	}
@@ -80,20 +81,35 @@ static char *encode_base58(char *buf, size_t buflen,
 }
 
 /*
- * Decode a base58-encoded string into a byte sequence.
+ * Decode a base_n-encoded string into a byte sequence.
  */
-bool raw_decode_base58(BIGNUM *bn, const char *src, size_t len)
+bool raw_decode_base_n(BIGNUM *bn, const char *src, size_t len, int base)
 {
-	BN_init(bn);
+	const char *enc;
+
 	BN_zero(bn);
 
+	assert(base == 16 || base == 58);
+	switch (base) {
+	case 16:
+		enc = enc_16;
+		break;
+	case 58:
+		enc = enc_58;
+		break;
+	}
+
 	while (len) {
-		int val = decode_char(*src);
+		char current = *src;
+
+		if (base == 16)
+			current = tolower(current);	/* TODO: Not in ccan. */
+		int val = decode_char(current, enc);
 		if (val < 0) {
 			BN_free(bn);
 			return false;
 		}
-		BN_mul_word(bn, 58);
+		BN_mul_word(bn, base);
 		BN_add_word(bn, val);
 		src++;
 		len--;
@@ -102,6 +118,14 @@ bool raw_decode_base58(BIGNUM *bn, const char *src, size_t len)
 	return true;
 }
 
+/*
+ * Decode a base58-encoded string into a byte sequence.
+ */
+bool raw_decode_base58(BIGNUM *bn, const char *src, size_t len)
+{
+	return raw_decode_base_n(bn, src, len, 58);
+}
+
 void base58_get_checksum(u8 csum[4], const u8 buf[], size_t buflen)
 {
 	SHA256_CTX sha256;
@@ -163,6 +187,7 @@ bool pettycoin_from_base58(bool *test_net,
 		base58_len -= 2;
 	}
 
+	BN_init(&bn);
 	if (!raw_decode_base58(&bn, base58, base58_len))
 		return false;
 
@@ -224,6 +249,7 @@ bool ripemd_from_base58(u8 *version, u8 ripemd160[RIPEMD160_DIGEST_LENGTH],
 	if (strlen(base58) > BASE58_ADDR_MAX_LEN - 1)
 		return false;
 
+	BN_init(&bn);
 	/* Fails if it contains invalid characters. */
 	if (!raw_decode_base58(&bn, base58, strlen(base58)))
 		return false;
@@ -329,6 +355,7 @@ EC_KEY *key_from_base58(const char *base58, size_t base58_len,
 	} else
 		is_bitcoin = false;
 
+	BN_init(&bn);
 	if (!raw_decode_base58(&bn, base58, base58_len))
 		return NULL;
 

diff --git a/base58.h b/base58.h
@@ -42,6 +42,7 @@ char *key_to_base58(const tal_t *ctx, bool test_net, EC_KEY *key,
 EC_KEY *key_from_base58(const char *base58, size_t base58_len,
 			bool *test_net, struct protocol_pubkey *key);
 
+bool raw_decode_base_n(BIGNUM *bn, const char *src, size_t len, int base);
 bool raw_decode_base58(BIGNUM *bn, const char *src, size_t len);
 void base58_get_checksum(u8 csum[4], const u8 buf[], size_t buflen);
 

diff --git a/test/run-01-base16.c b/test/run-01-base16.c
@@ -0,0 +1,28 @@
+#include "../base58.c"
+
+int main(void)
+{
+	/* Address: 1PtcjakvZBeggokcAGb1KbVvMRi3NT6LMk. */
+	const char priv_b16[] =
+		"4e111544df178877C7e8483e92b7ef1b40cE7dc4e944261f4f32e2ed13340c0A";
+	const char priv_b10[] =
+		"35310585383039988783548932038956396952442822145226977502125905800903068486666";
+
+	BIGNUM *bn_priv;
+	BIGNUM *bn_priv_from_dec = NULL;
+	BIGNUM *bn_priv_from_hex = NULL;
+
+	bn_priv = BN_new();
+	assert(raw_decode_base_n(bn_priv, priv_b16, strlen(priv_b16), 16));
+	assert(BN_dec2bn(&bn_priv_from_dec, priv_b10) == strlen(priv_b10));
+	assert(BN_hex2bn(&bn_priv_from_hex, priv_b16) == strlen(priv_b16));
+
+	assert(BN_cmp(bn_priv, bn_priv_from_dec) == 0);
+	assert(BN_cmp(bn_priv, bn_priv_from_hex) == 0);
+
+	BN_free(bn_priv_from_hex);
+	BN_free(bn_priv_from_dec);
+	BN_free(bn_priv);
+
+	return 0;
+}
diff --git a/test/run-01-base58.c b/test/run-01-base58.c
@@ -18,7 +18,7 @@ int main(void)
 	assert(tal_parent(p) == ctx);
 	assert(p[0] == 'P');
 	assert(strlen(p) < BASE58_ADDR_MAX_LEN);
-	assert(strspn(p, enc) == strlen(p));
+	assert(strspn(p, enc_58) == strlen(p));
 	memset(&addr2, 0, sizeof(addr2));
 	assert(pettycoin_from_base58(&test_net, &addr2, p, strlen(p)));
 	assert(test_net == false);
@@ -29,7 +29,7 @@ int main(void)
 	assert(tal_parent(p) == ctx);
 	assert(p[0] == 'q');
 	assert(strlen(p) < BASE58_ADDR_MAX_LEN);
-	assert(strspn(p, enc) == strlen(p));
+	assert(strspn(p, enc_58) == strlen(p));
 	memset(&addr2, 0, sizeof(addr2));
 	assert(pettycoin_from_base58(&test_net, &addr2, p, strlen(p)));
 	assert(test_net == true);
@@ -40,7 +40,7 @@ int main(void)
 	assert(tal_parent(p) == ctx);
 	assert(strstarts(p, "P-1"));
 	assert(strlen(p) < BASE58_ADDR_MAX_LEN + 2);
-	assert(strspn(p+2, enc) == strlen(p+2));
+	assert(strspn(p+2, enc_58) == strlen(p+2));
 	memset(&addr2, 0, sizeof(addr2));
 	assert(pettycoin_from_base58(&test_net, &addr2, p, strlen(p)));
 	assert(test_net == false);
@@ -51,7 +51,7 @@ int main(void)
 	assert(tal_parent(p) == ctx);
 	assert(strstarts(p, "P-m") || strstarts(p, "P-n"));
 	assert(strlen(p) < BASE58_ADDR_MAX_LEN + 2);
-	assert(strspn(p+2, enc) == strlen(p+2));
+	assert(strspn(p+2, enc_58) == strlen(p+2));
 	memset(&addr2, 0, sizeof(addr2));
 	assert(pettycoin_from_base58(&test_net, &addr2, p, strlen(p)));
 	assert(test_net == true);
@@ -75,7 +75,7 @@ int main(void)
 
 	/* Now, turn it into pettcoin-style key. */
 	p = key_to_base58(ctx, true, key, false);
-	assert(strspn(p, enc) == strlen(p));
+	assert(strspn(p, enc_58) == strlen(p));
 
 	/* Convert back, check it is OK. */
 	EC_KEY_free(key);