Move zbase32 implementation to base32 file

Author: jbesraa

fuzz/src/zbase32.rs

@@ -7,18 +7,19 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-use lightning::util::zbase32;
+use lightning::util::base32;
 
 use crate::utils::test_logger;
 
 #[inline]
 pub fn do_test(data: &[u8]) {
-	let res = zbase32::encode(data);
-	assert_eq!(&zbase32::decode(&res).unwrap()[..], data);
+	let res = base32::Alphabet::ZBase32.encode(data);
+	assert_eq!(&base32::Alphabet::ZBase32.decode(&res).unwrap()[..], data);
 
 	if let Ok(s) = std::str::from_utf8(data) {
-		if let Ok(decoded) = zbase32::decode(s) {
-			assert_eq!(&zbase32::encode(&decoded), &s.to_ascii_lowercase());
+		let res = base32::Alphabet::ZBase32.decode(s);
+		if let Ok(decoded) = res {
+			assert_eq!(&base32::Alphabet::ZBase32.encode(&decoded), &s.to_ascii_lowercase());
 		}
 	}
 }

lightning/src/util/base32.rs

@@ -12,20 +12,31 @@ use crate::prelude::*;
 /// RFC4648 encoding table
 const RFC4648_ALPHABET: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 
+/// Zbase encoding alphabet
+const ZBASE_ALPHABET: &'static [u8] = b"ybndrfg8ejkmcpqxot1uwisza345h769";
+
 /// RFC4648 decoding table
 const RFC4648_INV_ALPHABET: [i8; 43] = [
 	-1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
 	9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
 ];
 
+/// Zbase decoding table
+const ZBASE_INV_ALPHABET: [i8; 43] = [
+	-1, 18, -1, 25, 26, 27, 30, 29, 7, 31, -1, -1, -1, -1, -1, -1, -1, 24, 1, 12, 3, 8, 5, 6, 28,
+	21, 9, 10, -1, 11, 2, 16, 13, 14, 4, 22, 17, 19, -1, 20, 15, 0, 23,
+];
+
 /// Alphabet used for encoding and decoding.
 #[derive(Copy, Clone)]
 pub enum Alphabet {
 	/// RFC4648 encoding.
 	RFC4648 {
 		/// Whether to use padding.
 		padding: bool
-	}
+	},
+	/// Zbase32 encoding.
+	ZBase32
 }
 
 impl Alphabet {
@@ -46,7 +57,10 @@ impl Alphabet {
 					return String::from_utf8(ret).expect("Invalid UTF-8");
 				}
 				ret
-			}
+			},
+			Self::ZBase32 => {
+				Self::encode_data(data, ZBASE_ALPHABET)
+			},
 		};
 		ret.truncate(output_length);
 
@@ -71,6 +85,9 @@ impl Alphabet {
 					});
 				}
 				(&data[..unpadded_data_length], RFC4648_INV_ALPHABET)
+			},
+			Self::ZBase32 => {
+				(data, ZBASE_INV_ALPHABET)
 			}
 		};
 		// If the string has more characters than are required to alphabet_encode the number of bytes
@@ -151,6 +168,44 @@ impl Alphabet {
 mod tests {
 	use super::*;
 
+	const ZBASE32_TEST_DATA: &[(&str, &[u8])] = &[
+		("", &[]),
+		("yy", &[0x00]),
+		("oy", &[0x80]),
+		("tqrey", &[0x8b, 0x88, 0x80]),
+		("6n9hq", &[0xf0, 0xbf, 0xc7]),
+		("4t7ye", &[0xd4, 0x7a, 0x04]),
+		("6im5sdy", &[0xf5, 0x57, 0xbb, 0x0c]),
+		("ybndrfg8ejkmcpqxot1uwisza345h769", &[0x00, 0x44, 0x32, 0x14, 0xc7, 0x42, 0x54, 0xb6,
+		0x35, 0xcf, 0x84, 0x65, 0x3a, 0x56, 0xd7, 0xc6,
+		0x75, 0xbe, 0x77, 0xdf])
+	];
+
+	#[test]
+	fn test_zbase32_encode() {
+		for &(zbase32, data) in ZBASE32_TEST_DATA {
+			assert_eq!(Alphabet::ZBase32.encode(data), zbase32);
+		}
+	}
+
+	#[test]
+	fn test_zbase32_decode() {
+		for &(zbase32, data) in ZBASE32_TEST_DATA {
+			assert_eq!(Alphabet::ZBase32.decode(zbase32).unwrap(), data);
+		}
+	}
+
+	#[test]
+	fn test_decode_wrong() {
+		const WRONG_DATA: &[&str] = &["00", "l1", "?", "="];
+		for &data in WRONG_DATA {
+			match Alphabet::ZBase32.decode(data) {
+				Ok(_) => assert!(false, "Data shouldn't be decodable"),
+				Err(_) => assert!(true),
+			}
+		}
+	}
+
 	const RFC4648_NON_PADDED_TEST_VECTORS: &[(&[u8], &[u8])] = &[
 		(&[0xF8, 0x3E, 0x7F, 0x83, 0xE7], b"7A7H7A7H"),
 		(&[0x77, 0xC1, 0xF7, 0x7C, 0x1F], b"O7A7O7A7"),

lightning/src/util/message_signing.rs

@@ -21,7 +21,7 @@
 //! <https://api.lightning.community/#signmessage>
 
 use crate::prelude::*;
-use crate::util::zbase32;
+use crate::util::base32;
 use bitcoin::hashes::{sha256d, Hash};
 use bitcoin::secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 use bitcoin::secp256k1::{Error, Message, PublicKey, Secp256k1, SecretKey};
@@ -58,15 +58,15 @@ pub fn sign(msg: &[u8], sk: &SecretKey) -> Result<String, Error> {
     let msg_hash = sha256d::Hash::hash(&[LN_MESSAGE_PREFIX, msg].concat());
 
     let sig = secp_ctx.sign_ecdsa_recoverable(&Message::from_slice(&msg_hash)?, sk);
-    Ok(zbase32::encode(&sigrec_encode(sig)))
+    Ok(base32::Alphabet::ZBase32.encode(&sigrec_encode(sig)))
 }
 
 /// Recovers the PublicKey of the signer of the message given the message and the signature.
 pub fn recover_pk(msg: &[u8], sig: &str) ->  Result<PublicKey, Error> {
     let secp_ctx = Secp256k1::verification_only();
     let msg_hash = sha256d::Hash::hash(&[LN_MESSAGE_PREFIX, msg].concat());
 
-    match zbase32::decode(&sig) {
+    match base32::Alphabet::ZBase32.decode(&sig) {
         Ok(sig_rec) => {
             match sigrec_decode(sig_rec) {
                 Ok(sig) => secp_ctx.recover_ecdsa(&Message::from_slice(&msg_hash)?, &sig),
@@ -143,4 +143,4 @@ mod test {
             assert!(verify(c[1].as_bytes(), c[2], &PublicKey::from_str(c[3]).unwrap()))
         }
     }
-}
+}

lightning/src/util/mod.rs

@@ -30,10 +30,6 @@ pub(crate) mod base32;
 pub(crate) mod atomic_counter;
 pub(crate) mod byte_utils;
 pub(crate) mod chacha20;
-#[cfg(fuzzing)]
-pub mod zbase32;
-#[cfg(not(fuzzing))]
-pub(crate) mod zbase32;
 #[cfg(not(fuzzing))]
 pub(crate) mod poly1305;
 pub(crate) mod chacha20poly1305rfc;