Merge pull request #51 from rust-bitcoin/2019-06-hex-fix

fix hex iterator

Author: apoelstra

CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.5.0 - 2019-06-28
+
+* Fix panic when parsing hashes that contain multibyte characters
+* Add `FromStr` to all hashes which hex-parses them
+
 # 0.4.0 - 2019-06-23
 
 * [Add `from_inner` method](https://github.com/rust-bitcoin/bitcoin_hashes/pull/20) to all hashes

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin_hashes"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Andrew Poelstra <[email protected]>"]
 license = "CC0-1.0"
 description = "Hash functions used by rust-bitcoin which support rustc 1.14.0"

src/error.rs

@@ -21,7 +21,7 @@ use std::{error, fmt};
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Error {
     /// non-hexadecimal character
-    InvalidChar(char),
+    InvalidChar(u8),
     /// purported hex string had odd length
     OddLengthString(usize),
     /// tried to parse fixed-length hash from a string with the wrong type (expected, got)

src/hash160.rs

@@ -19,6 +19,8 @@
 
 //! # HASH160 (SHA256 then RIPEMD160)
 
+use std::str;
+
 use sha256;
 use ripemd160;
 use Hash as HashTrait;
@@ -35,6 +37,13 @@ index_impl!(Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash, [u8; 20]);
 
+impl str::FromStr for Hash {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        ::hex::FromHex::from_hex(s)
+    }
+}
+
 impl HashTrait for Hash {
     type Engine = sha256::HashEngine;
     type Inner = [u8; 20];

src/hex.rs

@@ -16,7 +16,7 @@
 //!
 
 use std::fmt;
-use std::str::Chars;
+use std::str;
 use {Error, Hash};
 
 /// Trait for objects that can be serialized as hex strings
@@ -64,9 +64,9 @@ impl<T: Hash> FromHex for T {
 
 /// Iterator over a hex-encoded string slice which decodes hex and yields bytes.
 pub struct HexIterator<'a> {
-    /// The `Chars` iterator whose first two characters will be decoded to yield
+    /// The `Bytes` iterator whose next two bytes will be decoded to yield
     /// the next byte.
-    chars: Chars<'a>,
+    iter: str::Bytes<'a>,
 }
 
 impl<'a> HexIterator<'a> {
@@ -76,18 +76,18 @@ impl<'a> HexIterator<'a> {
         if s.len() % 2 != 0 {
             Err(Error::OddLengthString(s.len()))
         } else {
-            Ok(HexIterator {
-                chars: s.chars()
-            })
+            Ok(HexIterator { iter: s.bytes() })
         }
     }
 }
 
-fn chars_to_hex(hi: char, lo: char) -> Result<u8, Error> {
-    let hih = hi.to_digit(16)
-                .ok_or(Error::InvalidChar(hi))?;
-    let loh = lo.to_digit(16)
-                .ok_or(Error::InvalidChar(lo))?;
+fn chars_to_hex(hi: u8, lo: u8) -> Result<u8, Error> {
+    let hih = (hi as char)
+        .to_digit(16)
+        .ok_or(Error::InvalidChar(hi))?;
+    let loh = (lo as char)
+        .to_digit(16)
+        .ok_or(Error::InvalidChar(lo))?;
 
     let ret = (hih << 4) + loh;
     Ok(ret as u8)
@@ -97,21 +97,21 @@ impl<'a> Iterator for HexIterator<'a> {
     type Item = Result<u8, Error>;
 
     fn next(&mut self) -> Option<Result<u8, Error>> {
-        let hi = self.chars.next()?;
-        let lo = self.chars.next().unwrap();
+        let hi = self.iter.next()?;
+        let lo = self.iter.next().unwrap();
         Some(chars_to_hex(hi, lo))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.chars.as_str().len() / 2;
-        (len, Some(len))
+        let (min, max) = self.iter.size_hint();
+        (min / 2, max.map(|x| x /2))
     }
 }
 
 impl<'a> DoubleEndedIterator for HexIterator<'a> {
     fn next_back(&mut self) -> Option<Result<u8, Error>> {
-        let lo = self.chars.next_back()?;
-        let hi = self.chars.next_back().unwrap();
+        let lo = self.iter.next_back()?;
+        let hi = self.iter.next_back().unwrap();
         Some(chars_to_hex(hi, lo))
     }
 }
@@ -330,15 +330,15 @@ mod tests {
         );
         assert_eq!(
             Vec::<u8>::from_hex(badchar1),
-            Err(Error::InvalidChar('Z'))
+            Err(Error::InvalidChar(b'Z'))
         );
         assert_eq!(
             Vec::<u8>::from_hex(badchar2),
-            Err(Error::InvalidChar('Y'))
+            Err(Error::InvalidChar(b'Y'))
         );
         assert_eq!(
             Vec::<u8>::from_hex(badchar3),
-            Err(Error::InvalidChar('«'))
+            Err(Error::InvalidChar(194))
         );
     }
 }

src/hmac.rs

@@ -19,7 +19,7 @@
 
 //! # HMAC support
 
-use std::{borrow, fmt, io, ops};
+use std::{borrow, fmt, io, ops, str};
 #[cfg(feature="serde")]
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 
@@ -29,6 +29,13 @@ use {Error, Hash, HashEngine};
 #[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
 pub struct Hmac<T: Hash>(T);
 
+impl<T: Hash + str::FromStr> str::FromStr for Hmac<T> {
+    type Err = <T as str::FromStr>::Err;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Hmac(str::FromStr::from_str(s)?))
+    }
+}
+
 /// Pair of underlying hash midstates which represent the current state
 /// of an `HmacEngine`
 pub struct HmacMidState<T: Hash> {

src/ripemd160.rs

@@ -20,6 +20,7 @@
 //! # RIPEMD160
 
 use byteorder::{ByteOrder, LittleEndian};
+use std::str;
 
 use HashEngine as EngineTrait;
 use Hash as HashTrait;
@@ -77,6 +78,13 @@ index_impl!(Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash, [u8; 20]);
 
+impl str::FromStr for Hash {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        ::hex::FromHex::from_hex(s)
+    }
+}
+
 impl HashTrait for Hash {
     type Engine = HashEngine;
     type Inner = [u8; 20];

src/sha1.rs

@@ -15,6 +15,7 @@
 //! # SHA1
 
 use byteorder::{ByteOrder, BigEndian};
+use std::str;
 
 use HashEngine as EngineTrait;
 use Hash as HashTrait;
@@ -64,6 +65,13 @@ index_impl!(Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash, [u8; 20]);
 
+impl str::FromStr for Hash {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        ::hex::FromHex::from_hex(s)
+    }
+}
+
 impl HashTrait for Hash {
     type Engine = HashEngine;
     type Inner = [u8; 20];

src/sha256.rs

@@ -15,6 +15,7 @@
 //! # SHA256
 
 use byteorder::{ByteOrder, BigEndian};
+use std::str;
 
 use hex;
 use HashEngine as EngineTrait;
@@ -66,6 +67,13 @@ impl EngineTrait for HashEngine {
 #[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
 pub struct Hash([u8; 32]);
 
+impl str::FromStr for Hash {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        ::hex::FromHex::from_hex(s)
+    }
+}
+
 hex_fmt_impl!(Debug, Hash);
 hex_fmt_impl!(Display, Hash);
 hex_fmt_impl!(LowerHex, Hash);

src/sha256d.rs

@@ -14,6 +14,8 @@
 
 //! # SHA256d
 
+use std::str;
+
 use sha256;
 use Hash as HashTrait;
 use Error;
@@ -29,6 +31,13 @@ index_impl!(Hash);
 serde_impl!(Hash, 32);
 borrow_slice_impl!(Hash, [u8; 32]);
 
+impl str::FromStr for Hash {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Error> {
+        ::hex::FromHex::from_hex(s)
+    }
+}
+
 impl HashTrait for Hash {
     type Engine = sha256::HashEngine;
     type Inner = [u8; 32];