Rust implementation #38

tarcieri · 2017-11-24T20:52:28Z

I think ideally this would be replaced with a procedural macro, possibly even leveraging serde visitors

-Original file line number
+Diff line change
@@ Expand Up / @@ -16,3 +16,8 @@ matrix: @@
         - cd ruby
         - bundle
         - bundle exec rake
+      - language: rust
+        rust: stable
+        script:
+        - cd rust
+        - cargo test

-Original file line number
+Diff line change
@@ -0,0 +1,35 @@
+    ## 0.4.1 (2017-01-16)
+    * Clippy fixups
+    ## 0.4.0 (2017-01-16)
+    * Rename `objecthash_struct_member!` to `objecthash_member!`
+    * Do not automatically create references from objecthash macro args
+    * Remove associated digest type from ObjectHasher trait. Always use
+      objecthash::Digest instead
+    ## 0.3.0 (2016-08-21)
+    * `objecthash_struct_member!` macro
+    ## 0.2.2 (2016-08-21)
+    * Coerce `objecthash_struct!` key names to Strings
+    ## 0.2.1 (2016-08-21)
+    * Bugfix for `objecthash_struct!` macro
+    ## 0.2.0 (2016-08-21)
+    * Add `objecthash_struct!` and `objecthash_dict_entry!` macros
+    ## 0.1.1 (2016-08-15)
+    * Add the newly released *ring* crate as an optional dependency
+    ## 0.1.0 (2016-08-08)
+    * Initial release

-Original file line number
+Diff line change
@@ -0,0 +1,25 @@
+    [package]
+    name        = "objecthash"
+    version     = "0.4.1"
+    description = "A content hashing algorithm which works across multiple encodings (JSON, Protobufs, etc)"
+    homepage    = "https://github.com/cryptosphere/rust-objecthash"
+    repository  = "https://github.com/cryptosphere/rust-objecthash"
+    readme      = "README.md"
+    keywords    = ["hash", "digest", "signatures", "Merkle", "blockchain"]
+    license     = "Apache-2.0"
+    authors     = ["Tony Arcieri <bascule@gmail.com>"]
+    [dependencies.unicode-normalization]
+    version = ">= 0.1.2"
+    [dependencies.ring]
+    optional = true
+    version = ">= 0.2"
+    [dev-dependencies.rustc-serialize]
+    version = ">= 0.3.19"
+    [features]
+    default = ["objecthash-ring"]
+    objecthash-ring = ["ring"]
+    octet-strings = []

-Original file line number
+Diff line change
@@ -0,0 +1,119 @@
+    # ObjectHash for Rust [![Latest Version][crate-image]][crate-link] [![Build Status][build-image]][build-link] [![Apache 2 licensed][license-image]][license-link]
+    [crate-image]: https://img.shields.io/crates/v/objecthash.svg
+    [crate-link]: https://crates.io/crates/objecthash
+    [build-image]: https://travis-ci.org/cryptosphere/objecthash-rs.svg?branch=master
+    [build-link]: https://travis-ci.org/cryptosphere/objecthash-rs
+    [license-image]: https://img.shields.io/badge/license-Apache2-blue.svg
+    [license-link]: https://github.com/cryptosphere/objecthash-rs/blob/master/LICENSE
+    A content hash algorithm which works across multiple encodings (JSON, Protobufs, etc).
+    This crate provides a Rust implementation of an algorithm originally created by Ben Laurie:
+    https://github.com/benlaurie/objecthash
+    ### Is it any good?
+    [Yes.](http://news.ycombinator.com/item?id=3067434)
+    ### Is it "Production Ready™"?
+    ![DANGER: EXPERIMENTAL](https://raw.github.com/cryptosphere/cryptosphere/master/images/experimental.png)
+    **No!** ObjectHash is an *experimental* algorithm, and is subject to change. Please do not depend on it yet.
+    Additionally, this is a project of a cryptographic nature and has not received any expert review.
+    Use at your own risk.
+    ## Installation
+    You will need to select a supported cryptography library to use as ObjectHash's backend. The following backend libraries
+    are supported:
+    * [ring]: A safe, fast, small Rust crypto library based on BoringSSL's cryptography primitives
+    [ring]: https://github.com/briansmith/ring
+    Please make sure to add a crypto backend crate or the `objecthash` crate will not work!
+    ## Usage
+    ObjectHashes can be used to compute a content hash of a deeply nested structure. The intended use is to first
+    deserialize data into a nested structure, then perform an ObjectHash digest of its contents. This way, the same
+    content hash to be computed regardless of how the data is serialized, which allows the data to be transcoded between
+    formats without having to recompute the content hash.
+    This crate defines a trait called ObjectHash:
+    ```rust
+    pub trait ObjectHash {
+        fn objecthash<H: ObjectHasher>(&self, hasher: &mut H);
+    }
+    ```
+    There are built-in implementations of the `ObjectHash` trait for the
+    following types:
+    * `Vec<T: ObjectHash>`
+    * `HashMap<K: ObjectHash, V: ObjectHash>`
+    * `str`
+    * `String`
+    * **Integers:**
+      * `i8`
+      * `i16`
+      * `i32`
+      * `i64`
+      * `u8`
+      * `u16`
+      * `u32`
+      * `u64`
+      * `isize`
+      * `usize`
+    To calculate the ObjectHash digest of some data, call the following:
+    ```rust
+    let digest: Vec<u8> = objecthash::digest(42);
+    ```
+    This will compute a digest (using the SHA-256 algorithm) of the given value, provided the type of the value given
+    implements the ObjectHash trait.
+    ## Macros
+    The `objecthash_struct!` macro is designed to simplify implementing the ObjectHash trait on structs, producing
+    a dict-type hash across their keys and values:
+    ```rust
+    impl ObjectHash for MyStruct {
+        #[inline]
+        fn objecthash<H: ObjectHasher>(&self, hasher: &mut H) {
+            objecthash_struct!(
+                hasher,
+                "foo" => self.foo,
+                "bar" => self.bar,
+                "baz" => self.baz
+            )
+        }
+    }
+    ```
+    ## TODO
+    * More types
+    * More test vectors
+    * Redaction support
+    ## Contributing
+    * Fork this repository on Github
+    * Make your changes and send a pull request
+    * If your changes look good, we'll merge them
+    ## Copyright
+    Copyright (c) 2016-2017 Tony Arcieri. Distributed under the Apache 2.0 License.
+    See LICENSE file for further details.

-Original file line number
+Diff line change
@@ -0,0 +1,8 @@
+    #[cfg(feature = "objecthash-ring")]
+    pub mod ring;
+    // TODO: Use std::hash::BuildHasherDefault or our own similar version
+    #[cfg(feature = "objecthash-ring")]
+    pub fn default() -> ring::Hasher {
+        ring::Hasher::default()
+    }

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Rust implementation #38

Uh oh!

Diff view

Diff view

There are no files selected for viewing

tarcieri Nov 24, 2017

Uh oh!

Uh oh!

-Original file line number
+Diff line change
@@ -0,0 +1,65 @@
+    extern crate ring;
+    use Digest;
+    use ObjectHasher;
+    pub struct Hasher {
+        ctx: ring::digest::Context,
+    }
+    impl Hasher {
+        pub fn new(alg: &'static ring::digest::Algorithm) -> Hasher {
+            Hasher { ctx: ring::digest::Context::new(alg) }
+        }
+    }
+    impl Default for Hasher {
+        fn default() -> Self {
+            Self::new(&ring::digest::SHA256)
+        }
+    }
+    impl ObjectHasher for Hasher {
+        #[inline]
+        fn output_len(&self) -> usize {
+            self.ctx.algorithm.output_len
+        }
+        #[inline]
+        fn update(&mut self, bytes: &[u8]) {
+            self.ctx.update(bytes);
+        }
+        #[inline]
+        fn update_nested<F>(&mut self, nested: F)
+            where F: Fn(&mut Self)
+        {
+            let mut nested_hasher = Hasher::new(self.ctx.algorithm);
+            nested(&mut nested_hasher);
+            self.update(nested_hasher.finish().as_ref());
+        }
+        #[inline]
+        fn finish(self) -> Digest {
+            Digest::new(self.ctx.finish().as_ref()).unwrap()
+        }
+    }
+    #[cfg(test)]
+    mod tests {
+        use super::Hasher;
+        use ObjectHasher;
+        use rustc_serialize::hex::ToHex;
+        // From Project NESSIE
+        // https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/Sha-2-256.unverified.test-vectors
+        const SHA256_VECTOR_STRING: &'static str = "abcdefghijklmnopqrstuvwxyz";
+        const SHA256_VECTOR_DIGEST: &'static str = "71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73";
+        #[test]
+        fn sha256() {
+            let mut hasher = Hasher::default();
+            hasher.update(SHA256_VECTOR_STRING.as_bytes());
+            assert_eq!(hasher.finish().as_ref().to_hex(), SHA256_VECTOR_DIGEST);
+        }
+    }

-Original file line number
+Diff line change
@@ -0,0 +1,72 @@
+    extern crate unicode_normalization;
+    #[cfg(test)]
+    extern crate rustc_serialize;
+    #[macro_use]
+    pub mod macros;
+    pub mod hasher;
+    pub mod types;
+    const MAX_OUTPUT_LEN: usize = 32;
+    pub struct Digest {
+        output_len: usize,
+        value: [u8; MAX_OUTPUT_LEN],
+    }
+    impl Digest {
+        pub fn new(bytes: &[u8]) -> Result<Digest, ()> {
+            if bytes.len() > MAX_OUTPUT_LEN {
+                return Err(());
+            }
+            let mut digest_bytes = [0u8; MAX_OUTPUT_LEN];
+            digest_bytes.copy_from_slice(bytes);
+            Ok(Digest {
+                output_len: bytes.len(),
+                value: digest_bytes,
+            })
+        }
+    }
+    impl AsRef<[u8]> for Digest {
+        #[inline]
+        fn as_ref(&self) -> &[u8] {
+            &self.value[..self.output_len]
+        }
+    }
+    #[cfg(feature = "objecthash-ring")]
+    pub fn digest<T: ObjectHash + ?Sized>(msg: &T) -> Digest {
+        let mut hasher = hasher::default();
+        msg.objecthash(&mut hasher);
+        hasher.finish()
+    }
+    pub trait ObjectHasher {
+        fn output_len(&self) -> usize;
+        fn update(&mut self, bytes: &[u8]);
+        fn update_nested<F>(&mut self, nested: F) where F: Fn(&mut Self);
+        fn finish(self) -> Digest;
+    }
+    pub trait ObjectHash {
+        fn objecthash<H: ObjectHasher>(&self, hasher: &mut H);
+    }
+    #[cfg(test)]
+    #[cfg(feature = "objecthash-ring")]
+    mod tests {
+        use digest;
+        use rustc_serialize::hex::ToHex;
+        #[test]
+        fn digest_test() {
+            let result = digest(&1000);
+            assert_eq!(result.as_ref().to_hex(),
+                       "a3346d18105ef801c3598fec426dcc5d4be9d0374da5343f6c8dcbdf24cb8e0b");
+        }
+    }

-Original file line number
+Diff line change
@@ -0,0 +1,53 @@
+    #[macro_export]
+    macro_rules! objecthash_member {
+        ($key:expr => $value:expr) => {
+            {
+                let key_digest = $crate::digest($key);
+                let value_digest = $crate::digest($value);
+                let mut result = Vec::with_capacity(key_digest.as_ref().len() + value_digest.as_ref().len());
+                result.extend_from_slice(key_digest.as_ref());
+                result.extend_from_slice(value_digest.as_ref());
+                result
+            }
+        }
+    }
+    #[macro_export]
+    macro_rules! objecthash_struct(
+        { $hasher:expr, $($key:expr => $value:expr),+ } => {
+            {
+                let mut digests: Vec<Vec<u8>> = Vec::new();
+                $(
+                    digests.push(objecthash_member!($key => $value));
+                )+
+                digests.sort();
+                $hasher.update($crate::types::DICT_TAG);
+                for value in &digests {
+                    $hasher.update(&value);
+                }
+            }
+         };
+    );
+    #[cfg(test)]
+    #[cfg(feature = "objecthash-ring")]
+    mod tests {
+        use {hasher, ObjectHasher};
+        use rustc_serialize::hex::ToHex;
+        #[test]
+        fn objecthash_struct_test() {
+            let mut h = hasher::default();
+            objecthash_struct!(h, "foo" => &1);
+            assert_eq!(
+                h.finish().as_ref().to_hex(),
+                "bf4c58f5e308e31e2cd64bdbf7a01b9b595a13602438be5e912c7d94f6d8177a"
+            );
+        }
+    }

Rust implementation #38

Are you sure you want to change the base?

Uh oh!

Rust implementation #38

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

tarcieri Nov 24, 2017

Choose a reason for hiding this comment

Uh oh!

Uh oh!