Upgrade curv interface

.travis.yml

@@ -1,13 +1,25 @@
 language: rust
 cache: cargo
-rust:
-  - stable
+rust: stable
+virt: lxd
 
-before_script:
-  - rustup component add rustfmt-preview clippy
-  - cargo fmt --all -- --check
-  - cargo clippy -- -D clippy::all
+env:
+  - BIGINT_BACKEND=rust-gmp-kzen
+  - BIGINT_BACKEND=num-bigint
+
+before_install:
+  - rustup component add rustfmt clippy
 
 script:
-  - cargo build --verbose
-  - cargo test --verbose
+  - cargo build --verbose --no-default-features --features $BIGINT_BACKEND
+  - cargo test --verbose --no-default-features --features $BIGINT_BACKEND
+  - if [[ "$BIGINT_BACKEND" = "rust-gmp-kzen" ]]; then cargo fmt --all -- --check; fi
+  - if [[ "$BIGINT_BACKEND" = "rust-gmp-kzen" ]]; then cargo clippy -- -D clippy::all; fi
+
+deploy:
+  provider: cargo
+  token:
+    secure: "FE6A1XRyJtTK92rV3y5e0go+FDKn1HpJbYkHOacDqabTkUluXrCTw3ERFcQQ13QZdc9xkxoAs7roKp8ivl0Xg1IJCzI+yLb0ZR6YcYebKEqd06YFbBmejjvMsyyZHKPTQmroe+tBwcA1IqLLcAY8vmY5EGhJTsGUhovIomw1RvqM6gu9yUwII/sF0a5gqY761cJd4QoLlWTb1Er7DqZxoU9drhWAJQP7sLsspjLu6dOyWzb0A2mTmnek+iuVnt9mGPtjGk4FcNPGbEmNu3UPOVuXcyibFPIALEWrH0ouZB7E9k312g45LucSeKSimgQYQBNAzdsnkKyBwyTpGuaosGnMbI7mhoi3visV21RTbw61N05dmZTYb4VAMcx+93TslKMDv5nmIlUmKxULNRBSTPPtrg0/X7KuKaoHVstrxx0ohd8GFwGYQBB64mQaOxFBhoy//prpHjhFl+1cti4JHyaHFSV/PfaryvUfRg4q2Dlq1HP+ey5cPRPbwfpSO1RmXlIDWe21ncRnKSpgMHTPBzYNtil+gZyzHl5X4ZLvLCaHsZwZQPMFB+otlabFaS1caqkk1F1fHMrj8NMak/snb2IyUJqXgQivqzEn38G3k9/QHeQXhNVwyGDtdWV51P9XfXFpxrEuuWlXF56ABiWcF7bY7Y3DeCbnFNLkVkGZYvY="
+  on:
+    tags: true
+    condition: '"$TRAVIS_TAG" =~ ^v[0-9.]+$ && "$BIGINT_BACKEND" = "rust-gmp-kzen"'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "curv"
-version = "0.7.0"
+version = "0.7.1"
 edition = "2018"
 authors = ["Omer Shlomovits"]
 license = "MIT"
@@ -19,10 +19,11 @@ digest = "0.8.1"
 ff-zeroize = "0.6.3"
 funty = "=1.1.0"
 generic-array = "0.14"
-hex = "0.4"
+hex = { version = "0.4", features = ["serde"] }
 hmac = "0.7.1"
+thiserror = "1"
 merkle-sha3 = "^0.1"
-lazy_static = "1.4.0"
+lazy_static = "1.4"
 num-traits = "0.2"
 num-integer = "0.1"
 pairing-plus = "0.19"

src/arithmetic/big_gmp.rs

@@ -389,6 +389,12 @@ impl ring_algorithm::RingNormalize for BigInt {
 
 crate::__bigint_impl_from! { u32, i32, u64 }
 
+impl From<u16> for BigInt {
+    fn from(n: u16) -> Self {
+        BigInt::from(u64::from(n))
+    }
+}
+
 /// Internal helper trait. Creates short-hand for wrapping Mpz into BigInt.
 trait Wrap {
     fn wrap(self) -> BigInt;

src/arithmetic/big_native.rs

@@ -99,6 +99,12 @@ impl num_traits::Num for BigInt {
 
 crate::__bigint_impl_from! { u32, i32, u64 }
 
+impl From<u16> for BigInt {
+    fn from(n: u16) -> Self {
+        BigInt::from(u64::from(n))
+    }
+}
+
 impl BasicOps for BigInt {
     fn pow(&self, exponent: u32) -> Self {
         self.num.pow(exponent).wrap()

src/arithmetic/mod.rs

@@ -356,7 +356,7 @@ mod test {
         // Conversion traits
         for<'a> u64: std::convert::TryFrom<&'a BigInt>,
         for<'a> i64: std::convert::TryFrom<&'a BigInt>,
-        BigInt: From<u32> + From<i32> + From<u64>,
+        BigInt: From<u16> + From<u32> + From<i32> + From<u64>,
         // STD Operators
         BigInt: Add<Output = BigInt>
             + Sub<Output = BigInt>

src/cryptographic_primitives/hashing/blake2b512.rs

@@ -5,7 +5,7 @@
     License MIT: https://github.com/KZen-networks/curv/blob/master/LICENSE
 */
 use crate::arithmetic::traits::*;
-use crate::elliptic::curves::traits::{ECPoint, ECScalar};
+use crate::elliptic::curves::{Curve, Point, PointZ, ScalarZ};
 use crate::BigInt;
 use blake2b_simd::Params;
 
@@ -14,32 +14,46 @@ pub struct Blake;
 impl Blake {
     pub fn create_hash(big_ints: &[&BigInt], persona: &[u8]) -> BigInt {
         let mut digest = Params::new().hash_length(64).personal(persona).to_state();
-        // let mut digest = Blake2b::with_params(64, &[], &[], persona);
         for value in big_ints {
             digest.update(&BigInt::to_bytes(value));
         }
 
         BigInt::from_bytes(digest.finalize().as_ref())
     }
 
-    pub fn create_hash_from_ge<P: ECPoint>(ge_vec: &[&P], persona: &[u8]) -> P::Scalar {
+    pub fn create_hash_from_ge<E: Curve>(ge_vec: &[&Point<E>], persona: &[u8]) -> ScalarZ<E> {
         let mut digest = Params::new().hash_length(64).personal(persona).to_state();
         //  let mut digest = Blake2b::with_params(64, &[], &[], persona);
 
         for value in ge_vec {
-            digest.update(&value.pk_to_key_slice());
+            digest.update(&value.to_bytes(false));
         }
 
         let result = BigInt::from_bytes(digest.finalize().as_ref());
-        ECScalar::from(&result)
+        ScalarZ::from(&result)
+    }
+
+    pub fn create_hash_from_ge_z<E: Curve>(ge_vec: &[&PointZ<E>], persona: &[u8]) -> ScalarZ<E> {
+        let mut digest = Params::new().hash_length(64).personal(persona).to_state();
+        //  let mut digest = Blake2b::with_params(64, &[], &[], persona);
+
+        for value in ge_vec {
+            match value.to_bytes(false) {
+                Some(serialized) => digest.update(&serialized),
+                None => digest.update(b"infinity point"),
+            };
+        }
+
+        let result = BigInt::from_bytes(digest.finalize().as_ref());
+        ScalarZ::from(&result)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::Blake;
     use crate::arithmetic::traits::*;
-    use crate::elliptic::curves::traits::{ECPoint, ECScalar};
+    use crate::elliptic::curves::{Curve, Point};
     use crate::BigInt;
 
     #[test]
@@ -51,17 +65,15 @@ mod tests {
 
     crate::test_for_all_curves!(create_hash_from_ge_test);
 
-    fn create_hash_from_ge_test<P>()
-    where
-        P: ECPoint,
-        P::Scalar: PartialEq + std::fmt::Debug,
-    {
-        let point = P::base_point2();
-        let result1 = Blake::create_hash_from_ge(&[&point, &P::generator()], b"Zcash_RedJubjubH");
-        assert!(result1.to_big_int().bit_length() > 240);
-        let result2 = Blake::create_hash_from_ge(&[&P::generator(), &point], b"Zcash_RedJubjubH");
+    fn create_hash_from_ge_test<E: Curve>() {
+        let base_point2 = Point::base_point2().to_point_owned();
+        let generator = Point::generator().to_point_owned();
+        let result1 =
+            Blake::create_hash_from_ge::<E>(&[&base_point2, &generator], b"Zcash_RedJubjubH");
+        assert!(result1.to_bigint().bit_length() > 240);
+        let result2 = Blake::create_hash_from_ge(&[&generator, &base_point2], b"Zcash_RedJubjubH");
         assert_ne!(result1, result2);
-        let result3 = Blake::create_hash_from_ge(&[&P::generator(), &point], b"Zcash_RedJubjubH");
+        let result3 = Blake::create_hash_from_ge(&[&generator, &base_point2], b"Zcash_RedJubjubH");
         assert_eq!(result2, result3);
     }
 }

src/cryptographic_primitives/hashing/hash_sha256.rs

@@ -7,12 +7,13 @@
 
 use super::traits::Hash;
 use crate::arithmetic::traits::*;
-use crate::elliptic::curves::traits::{ECPoint, ECScalar};
+use crate::elliptic::curves::{Curve, Point, PointZ, ScalarZ};
 
 use digest::Digest;
 use sha2::Sha256;
 
 use crate::BigInt;
+
 pub struct HSha256;
 
 impl Hash for HSha256 {
@@ -27,15 +28,29 @@ impl Hash for HSha256 {
         BigInt::from_bytes(&result_hex[..])
     }
 
-    fn create_hash_from_ge<P: ECPoint>(ge_vec: &[&P]) -> P::Scalar {
+    fn create_hash_from_ge<E: Curve>(ge_vec: &[&Point<E>]) -> ScalarZ<E> {
+        let mut hasher = Sha256::new();
+        for value in ge_vec {
+            hasher.input(&value.to_bytes(false));
+        }
+
+        let result_hex = hasher.result();
+        let result = BigInt::from_bytes(&result_hex[..]);
+        ScalarZ::from(&result)
+    }
+
+    fn create_hash_from_ge_z<E: Curve>(ge_vec: &[&PointZ<E>]) -> ScalarZ<E> {
         let mut hasher = Sha256::new();
         for value in ge_vec {
-            hasher.input(&value.pk_to_key_slice());
+            match value.to_bytes(false) {
+                Some(serialized) => hasher.input(&serialized),
+                None => hasher.input(b"infinity"),
+            }
         }
 
         let result_hex = hasher.result();
         let result = BigInt::from_bytes(&result_hex[..]);
-        ECScalar::from(&result)
+        ScalarZ::from(&result)
     }
 
     fn create_hash_from_slice(byte_slice: &[u8]) -> BigInt {
@@ -51,8 +66,7 @@ mod tests {
     use super::HSha256;
     use super::Hash;
     use crate::arithmetic::traits::*;
-    use crate::elliptic::curves::traits::ECPoint;
-    use crate::elliptic::curves::traits::ECScalar;
+    use crate::elliptic::curves::{Curve, Point};
     use crate::BigInt;
     use sha2::Digest;
     use sha2::Sha256;
@@ -111,17 +125,14 @@ mod tests {
 
     crate::test_for_all_curves!(create_sha256_from_ge_test);
 
-    fn create_sha256_from_ge_test<P>()
-    where
-        P: ECPoint,
-        P::Scalar: PartialEq + std::fmt::Debug,
-    {
-        let point = P::base_point2();
-        let result1 = HSha256::create_hash_from_ge(&[&point, &P::generator()]);
-        assert!(result1.to_big_int().bit_length() > 240);
-        let result2 = HSha256::create_hash_from_ge(&[&P::generator(), &point]);
+    fn create_sha256_from_ge_test<E: Curve>() {
+        let generator = Point::generator().to_point_owned();
+        let base_point2 = Point::base_point2().to_point_owned();
+        let result1 = HSha256::create_hash_from_ge::<E>(&[&base_point2, &generator]);
+        assert!(result1.to_bigint().bit_length() > 240);
+        let result2 = HSha256::create_hash_from_ge(&[&generator, &base_point2]);
         assert_ne!(result1, result2);
-        let result3 = HSha256::create_hash_from_ge(&[&P::generator(), &point]);
+        let result3 = HSha256::create_hash_from_ge(&[&generator, &base_point2]);
         assert_eq!(result2, result3);
     }
 }

src/cryptographic_primitives/hashing/hash_sha512.rs

@@ -7,7 +7,7 @@
 
 use super::traits::Hash;
 use crate::arithmetic::traits::*;
-use crate::elliptic::curves::traits::{ECPoint, ECScalar};
+use crate::elliptic::curves::{Curve, Point, PointZ, ScalarZ};
 
 use digest::Digest;
 use sha2::Sha512;
@@ -28,15 +28,29 @@ impl Hash for HSha512 {
         BigInt::from_bytes(&result_hex[..])
     }
 
-    fn create_hash_from_ge<P: ECPoint>(ge_vec: &[&P]) -> P::Scalar {
+    fn create_hash_from_ge<E: Curve>(ge_vec: &[&Point<E>]) -> ScalarZ<E> {
         let mut hasher = Sha512::new();
         for value in ge_vec {
-            hasher.input(&value.pk_to_key_slice());
+            hasher.input(&value.to_bytes(false));
         }
 
         let result_hex = hasher.result();
         let result = BigInt::from_bytes(&result_hex[..]);
-        ECScalar::from(&result)
+        ScalarZ::from(&result)
+    }
+
+    fn create_hash_from_ge_z<E: Curve>(ge_vec: &[&PointZ<E>]) -> ScalarZ<E> {
+        let mut hasher = Sha512::new();
+        for value in ge_vec {
+            match value.to_bytes(false) {
+                Some(serialized) => hasher.input(&serialized),
+                None => hasher.input(b"infinity"),
+            }
+        }
+
+        let result_hex = hasher.result();
+        let result = BigInt::from_bytes(&result_hex[..]);
+        ScalarZ::from(&result)
     }
 
     fn create_hash_from_slice(byte_slice: &[u8]) -> BigInt {
@@ -49,11 +63,11 @@ impl Hash for HSha512 {
 
 #[cfg(test)]
 mod tests {
+    use crate::arithmetic::*;
+    use crate::elliptic::curves::{Curve, Point};
+
     use super::HSha512;
     use super::Hash;
-    use crate::arithmetic::traits::*;
-    use crate::elliptic::curves::traits::{ECPoint, ECScalar};
-    use crate::BigInt;
 
     #[test]
     // Test Vectors taken from:
@@ -99,17 +113,14 @@ mod tests {
 
     crate::test_for_all_curves!(create_sha512_from_ge_test);
 
-    fn create_sha512_from_ge_test<P>()
-    where
-        P: ECPoint,
-        P::Scalar: PartialEq + std::fmt::Debug,
-    {
-        let point = P::base_point2();
-        let result1 = HSha512::create_hash_from_ge(&[&point, &P::generator()]);
-        assert!(result1.to_big_int().bit_length() > 240);
-        let result2 = HSha512::create_hash_from_ge(&[&P::generator(), &point]);
+    fn create_sha512_from_ge_test<E: Curve>() {
+        let generator = Point::generator().to_point_owned();
+        let base_point2 = Point::base_point2().to_point_owned();
+        let result1 = HSha512::create_hash_from_ge::<E>(&[&base_point2, &generator]);
+        assert!(result1.to_bigint().bit_length() > 240);
+        let result2 = HSha512::create_hash_from_ge(&[&generator, &base_point2]);
         assert_ne!(result1, result2);
-        let result3 = HSha512::create_hash_from_ge(&[&P::generator(), &point]);
+        let result3 = HSha512::create_hash_from_ge(&[&generator, &base_point2]);
         assert_eq!(result2, result3);
     }
 }