Merge pull request #3223 from ProvableHQ/chore/update-bech32

[Chore] Update `bech32` and `sha2`

Author: vicsn

Cargo.lock

@@ -534,7 +534,7 @@ version = "1.0"
 version = "2.0"
 
 [workspace.dependencies.sha2]
-version = "0.10"
+version = "0.11"
 default-features = false
 
 [workspace.dependencies.smallvec]

Cargo.toml

@@ -40,16 +40,16 @@ impl<N: Network> FromStr for Signature<N> {
     /// Reads in the signature string.
     fn from_str(signature: &str) -> Result<Self, Self::Err> {
         // Decode the signature string from bech32m.
-        let (hrp, data, variant) = bech32::decode(signature)?;
-        if hrp != SIGNATURE_PREFIX {
+        let checked = bech32::primitives::decode::CheckedHrpstring::new::<LongBech32m>(signature)?;
+        let hrp = checked.hrp();
+        let data: Vec<u8> = checked.byte_iter().collect();
+        if hrp.as_str() != SIGNATURE_PREFIX {
             bail!("Failed to decode signature: '{hrp}' is an invalid prefix")
         } else if data.is_empty() {
             bail!("Failed to decode signature: data field is empty")
-        } else if variant != bech32::Variant::Bech32m {
-            bail!("Found an signature that is not bech32m encoded: {signature}");
         }
-        // Decode the signature data from u5 to u8, and into the signature.
-        Ok(Self::read_le(&Vec::from_base32(&data)?[..])?)
+        // Decode the signature data into the signature.
+        Ok(Self::read_le(&data[..])?)
     }
 }
 
@@ -65,8 +65,8 @@ impl<N: Network> Display for Signature<N> {
         // Convert the signature to bytes.
         let bytes = self.to_bytes_le().map_err(|_| fmt::Error)?;
         // Encode the bytes into bech32m.
-        let string =
-            bech32::encode(SIGNATURE_PREFIX, bytes.to_base32(), bech32::Variant::Bech32m).map_err(|_| fmt::Error)?;
+        let string = bech32::encode::<LongBech32m>(bech32::Hrp::parse_unchecked(SIGNATURE_PREFIX), &bytes)
+            .map_err(|_| fmt::Error)?;
         // Output the string.
         Display::fmt(&string, f)
     }

console/account/src/signature/parse.rs

@@ -21,7 +21,7 @@ workspace = true
 workspace = true
 
 [dependencies.bech32]
-version = "0.9"
+version = "0.11"
 
 [dependencies.itertools]
 workspace = true

console/network/environment/Cargo.toml

@@ -21,3 +21,21 @@ pub use sanitizer::Sanitizer;
 
 pub mod variable_length;
 pub use variable_length::{read_variable_length_integer, variable_length_integer};
+
+/// A bech32m checksum with no hard length limit.
+///
+/// bech32 0.11 caps [`bech32::Bech32m`] at 1023 characters, but Aleo types such as
+/// ciphertexts, state paths, and snark keys can legitimately exceed this. This type
+/// uses identical generator coefficients and target residue as `Bech32m`, so encoded
+/// strings are valid bech32m and round-trip correctly with any standard decoder that
+/// does not enforce a maximum length.
+pub enum LongBech32m {}
+
+impl bech32::primitives::checksum::Checksum for LongBech32m {
+    type MidstateRepr = u32;
+
+    const CHECKSUM_LENGTH: usize = 6;
+    const CODE_LENGTH: usize = usize::MAX;
+    const GENERATOR_SH: [u32; 5] = [0x3b6a_57b2, 0x2650_8e6d, 0x1ea1_19fa, 0x3d42_33dd, 0x2a14_62b3];
+    const TARGET_RESIDUE: u32 = 0x2bc830a3;
+}

console/network/environment/src/helpers/mod.rs

@@ -134,7 +134,7 @@ pub mod prelude {
     };
 
     pub use anyhow::{Error, Result, anyhow, bail, ensure};
-    pub use bech32::{self, FromBase32, ToBase32};
+    pub use bech32;
     pub use itertools::Itertools;
     pub use nom::{
         Err,

console/network/environment/src/lib.rs

@@ -16,7 +16,6 @@
 use crate::prelude::*;
 
 use anyhow::Result;
-use bech32::{self, FromBase32, ToBase32};
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 use std::borrow::Borrow;
 
@@ -127,30 +126,28 @@ impl<F: FieldTrait, const PREFIX: u16> FromStr for AleoID<F, PREFIX> {
             bail!("Invalid byte size for a bech32m hash: {} bytes", string.len())
         }
 
-        let (hrp, data, variant) = bech32::decode(string)?;
+        let checked = bech32::primitives::decode::CheckedHrpstring::new::<LongBech32m>(string)?;
+        let hrp = checked.hrp();
+        let data: Vec<u8> = checked.byte_iter().collect();
         if hrp.as_bytes() != PREFIX.to_le_bytes() {
             bail!("Invalid prefix for a bech32m hash: {hrp}")
         };
         if data.is_empty() {
             bail!("Bech32m hash data is empty")
         }
-        if variant != bech32::Variant::Bech32m {
-            bail!("Hash is not a bech32m hash")
-        }
-        Ok(Self::read_le(&*Vec::from_base32(&data)?)?)
+        Ok(Self::read_le(&*data)?)
     }
 }
 
 impl<F: FieldTrait, const PREFIX: u16> Display for AleoID<F, PREFIX> {
     #[inline]
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        bech32::encode_to_fmt(
+        bech32::encode_to_fmt::<LongBech32m, _>(
             f,
-            &Self::prefix(),
-            self.0.to_bytes_le().expect("Failed to write data as bytes").to_base32(),
-            bech32::Variant::Bech32m,
+            bech32::Hrp::parse_unchecked(&Self::prefix()),
+            &self.0.to_bytes_le().expect("Failed to write data as bytes"),
         )
-        .expect("Failed to encode in bech32m")
+        .map_err(|_| fmt::Error)
     }
 }
 

console/network/src/helpers/id.rs

@@ -16,7 +16,6 @@
 use crate::prelude::*;
 
 use anyhow::Result;
-use bech32::{self, FromBase32, ToBase32};
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 use std::borrow::Borrow;
 
@@ -97,17 +96,16 @@ impl<T: Clone + Debug + ToBytes + FromBytes + PartialEq + Eq + Sync + Send, cons
     /// Reads in a bech32m string.
     #[inline]
     fn from_str(string: &str) -> Result<Self, Self::Err> {
-        let (hrp, data, variant) = bech32::decode(string)?;
+        let checked = bech32::primitives::decode::CheckedHrpstring::new::<LongBech32m>(string)?;
+        let hrp = checked.hrp();
+        let data: Vec<u8> = checked.byte_iter().collect();
         if hrp.as_bytes() != PREFIX.to_le_bytes() {
             bail!("Invalid prefix for a bech32m hash: {hrp}")
         };
         if data.is_empty() {
             bail!("Bech32m hash data is empty")
         }
-        if variant != bech32::Variant::Bech32m {
-            bail!("Hash is not a bech32m hash")
-        }
-        Ok(Self::read_le(&*Vec::from_base32(&data)?)?)
+        Ok(Self::read_le(&*data)?)
     }
 }
 
@@ -116,13 +114,12 @@ impl<T: Clone + Debug + ToBytes + FromBytes + PartialEq + Eq + Sync + Send, cons
 {
     #[inline]
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        bech32::encode_to_fmt(
+        bech32::encode_to_fmt::<LongBech32m, _>(
             f,
-            &Self::prefix(),
-            self.0.to_bytes_le().expect("Failed to write data as bytes").to_base32(),
-            bech32::Variant::Bech32m,
+            bech32::Hrp::parse_unchecked(&Self::prefix()),
+            &self.0.to_bytes_le().expect("Failed to write data as bytes"),
         )
-        .expect("Failed to encode in bech32m")
+        .map_err(|_| fmt::Error)
     }
 }
 

console/network/src/helpers/object.rs

@@ -40,16 +40,16 @@ impl<N: Network> FromStr for Ciphertext<N> {
     /// Reads in the ciphertext string.
     fn from_str(ciphertext: &str) -> Result<Self, Self::Err> {
         // Decode the ciphertext string from bech32m.
-        let (hrp, data, variant) = bech32::decode(ciphertext)?;
-        if hrp != CIPHERTEXT_PREFIX {
+        let checked = bech32::primitives::decode::CheckedHrpstring::new::<LongBech32m>(ciphertext)?;
+        let hrp = checked.hrp();
+        let data: Vec<u8> = checked.byte_iter().collect();
+        if hrp.as_str() != CIPHERTEXT_PREFIX {
             bail!("Failed to decode ciphertext: '{hrp}' is an invalid prefix")
         } else if data.is_empty() {
             bail!("Failed to decode ciphertext: data field is empty")
-        } else if variant != bech32::Variant::Bech32m {
-            bail!("Found an ciphertext that is not bech32m encoded: {ciphertext}");
         }
-        // Decode the ciphertext data from u5 to u8, and into the ciphertext.
-        Ok(Self::read_le(&Vec::from_base32(&data)?[..])?)
+        // Decode the ciphertext data into the ciphertext.
+        Ok(Self::read_le(&data[..])?)
     }
 }
 
@@ -65,8 +65,8 @@ impl<N: Network> Display for Ciphertext<N> {
         // Convert the ciphertext to bytes.
         let bytes = self.to_bytes_le().map_err(|_| fmt::Error)?;
         // Encode the bytes into bech32m.
-        let string =
-            bech32::encode(CIPHERTEXT_PREFIX, bytes.to_base32(), bech32::Variant::Bech32m).map_err(|_| fmt::Error)?;
+        let string = bech32::encode::<LongBech32m>(bech32::Hrp::parse_unchecked(CIPHERTEXT_PREFIX), &bytes)
+            .map_err(|_| fmt::Error)?;
         // Output the string.
         Display::fmt(&string, f)
     }

console/program/src/data/ciphertext/parse.rs

@@ -40,16 +40,16 @@ impl<N: Network> FromStr for Record<N, Ciphertext<N>> {
     /// Reads in the ciphertext string.
     fn from_str(ciphertext: &str) -> Result<Self, Self::Err> {
         // Decode the ciphertext string from bech32m.
-        let (hrp, data, variant) = bech32::decode(ciphertext)?;
-        if hrp != RECORD_CIPHERTEXT_PREFIX {
+        let checked = bech32::primitives::decode::CheckedHrpstring::new::<LongBech32m>(ciphertext)?;
+        let hrp = checked.hrp();
+        let data: Vec<u8> = checked.byte_iter().collect();
+        if hrp.as_str() != RECORD_CIPHERTEXT_PREFIX {
             bail!("Failed to decode record ciphertext: '{hrp}' is an invalid prefix")
         } else if data.is_empty() {
             bail!("Failed to decode record ciphertext: data field is empty")
-        } else if variant != bech32::Variant::Bech32m {
-            bail!("Found a record ciphertext that is not bech32m encoded: {ciphertext}");
         }
-        // Decode the record ciphertext data from u5 to u8, and into the record ciphertext.
-        Ok(Self::read_le(&Vec::from_base32(&data)?[..])?)
+        // Decode the record ciphertext data into the record ciphertext.
+        Ok(Self::read_le(&data[..])?)
     }
 }
 
@@ -65,7 +65,7 @@ impl<N: Network> Display for Record<N, Ciphertext<N>> {
         // Convert the ciphertext to bytes.
         let bytes = self.to_bytes_le().map_err(|_| fmt::Error)?;
         // Encode the bytes into bech32m.
-        let string = bech32::encode(RECORD_CIPHERTEXT_PREFIX, bytes.to_base32(), bech32::Variant::Bech32m)
+        let string = bech32::encode::<LongBech32m>(bech32::Hrp::parse_unchecked(RECORD_CIPHERTEXT_PREFIX), &bytes)
             .map_err(|_| fmt::Error)?;
         // Output the string.
         Display::fmt(&string, f)