Merge branch 'release/0.21.0'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "curve25519-dalek"
-version = "0.20.0"
+version = "0.21.0"
 authors = ["Isis Lovecruft <isis@patternsinthevoid.net>",
            "Henry de Valence <hdevalence@hdevalence.ca>"]
 readme = "README.md"
@@ -27,7 +27,7 @@ travis-ci = { repository = "dalek-cryptography/curve25519-dalek", branch = "mast
 
 [dev-dependencies]
 sha2 = "0.7"
-serde_cbor = "0.6"
+bincode = "1"
 criterion = "0.2"
 
 [[bench]]

README.md

@@ -45,7 +45,7 @@ make doc-internal
 To import `curve25519-dalek`, add the following to the dependencies section of
 your project's `Cargo.toml`:
 ```toml
-curve25519-dalek = "0.20"
+curve25519-dalek = "0.21"
 ```
 Then import the crate as:
 ```rust,no_run

src/edwards.rs

@@ -205,6 +205,15 @@ impl Serialize for EdwardsPoint {
     }
 }
 
+#[cfg(feature = "serde")]
+impl Serialize for CompressedEdwardsY {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        serializer.serialize_bytes(self.as_bytes())
+    }
+}
+
 #[cfg(feature = "serde")]
 impl<'de> Deserialize<'de> for EdwardsPoint {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -238,6 +247,37 @@ impl<'de> Deserialize<'de> for EdwardsPoint {
     }
 }
 
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for CompressedEdwardsY {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct CompressedEdwardsYVisitor;
+
+        impl<'de> Visitor<'de> for CompressedEdwardsYVisitor {
+            type Value = CompressedEdwardsY;
+
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                formatter.write_str("32 bytes of data")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<CompressedEdwardsY, E>
+                where E: serde::de::Error
+            {
+                if v.len() == 32 {
+                    let mut arr32 = [0u8; 32];
+                    arr32[0..32].copy_from_slice(v);
+                    Ok(CompressedEdwardsY(arr32))
+                } else {
+                    Err(serde::de::Error::invalid_length(v.len(), &self))
+                }
+            }
+        }
+
+        deserializer.deserialize_bytes(CompressedEdwardsYVisitor)
+    }
+}
+
 // ------------------------------------------------------------------------
 // Internal point representations
 // ------------------------------------------------------------------------
@@ -271,6 +311,21 @@ impl Default for CompressedEdwardsY {
     }
 }
 
+impl CompressedEdwardsY {
+    /// Construct a `CompressedEdwardsY` from a slice of bytes.
+    ///
+    /// # Panics
+    ///
+    /// If the input `bytes` slice does not have a length of 32.
+    pub fn from_slice(bytes: &[u8]) -> CompressedEdwardsY {
+        let mut tmp = [0u8; 32];
+
+        tmp.copy_from_slice(bytes);
+
+        CompressedEdwardsY(tmp)
+    }
+}
+
 impl Identity for EdwardsPoint {
     fn identity() -> EdwardsPoint {
         EdwardsPoint{ X: FieldElement::zero(),
@@ -1193,25 +1248,19 @@ mod test {
         }
     }
 
-    #[cfg(feature = "serde")]
-    use serde_cbor;
-
     #[test]
     #[cfg(feature = "serde")]
-    fn serde_cbor_basepoint_roundtrip() {
-        let output = serde_cbor::to_vec(&constants::ED25519_BASEPOINT_POINT).unwrap();
-        let parsed: EdwardsPoint = serde_cbor::from_slice(&output).unwrap();
-        assert_eq!(parsed.compress(), constants::ED25519_BASEPOINT_COMPRESSED);
-    }
+    fn serde_bincode_basepoint_roundtrip() {
+        use bincode;
 
-    #[test]
-    #[cfg(feature = "serde")]
-    fn serde_cbor_decode_invalid_fails() {
-        let mut output = serde_cbor::to_vec(&constants::ED25519_BASEPOINT_POINT).unwrap();
-        // CBOR apparently has two bytes of overhead for a 32-byte string.
-        // Set the low byte of the compressed point to 1 to make it invalid.
-        output[2] = 1;
-        let parsed: Result<EdwardsPoint, _> = serde_cbor::from_slice(&output);
-        assert!(parsed.is_err());
+        let encoded = bincode::serialize(&constants::ED25519_BASEPOINT_POINT).unwrap();
+        let enc_compressed = bincode::serialize(&constants::ED25519_BASEPOINT_COMPRESSED).unwrap();
+        assert_eq!(encoded, enc_compressed);
+
+        let dec_uncompressed: EdwardsPoint = bincode::deserialize(&encoded).unwrap();
+        let dec_compressed: CompressedEdwardsY = bincode::deserialize(&encoded).unwrap();
+
+        assert_eq!(dec_uncompressed, constants::ED25519_BASEPOINT_POINT);
+        assert_eq!(dec_compressed, constants::ED25519_BASEPOINT_COMPRESSED);
     }
 }

src/lib.rs

@@ -57,7 +57,7 @@ extern crate subtle;
 #[cfg(feature = "serde")]
 extern crate serde;
 #[cfg(all(test, feature = "serde"))]
-extern crate serde_cbor;
+extern crate bincode;
 
 // Internal macros. Must come first!
 #[macro_use]

src/ristretto.rs

@@ -213,6 +213,19 @@ impl CompressedRistretto {
         &self.0
     }
 
+    /// Construct a `CompressedRistretto` from a slice of bytes.
+    ///
+    /// # Panics
+    ///
+    /// If the input `bytes` slice does not have a length of 32.
+    pub fn from_slice(bytes: &[u8]) -> CompressedRistretto {
+        let mut tmp = [0u8; 32];
+
+        tmp.copy_from_slice(bytes);
+
+        CompressedRistretto(tmp)
+    }
+
     /// Attempt to decompress to an `RistrettoPoint`.
     ///
     /// # Return
@@ -310,6 +323,15 @@ impl Serialize for RistrettoPoint {
     }
 }
 
+#[cfg(feature = "serde")]
+impl Serialize for CompressedRistretto {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        serializer.serialize_bytes(self.as_bytes())
+    }
+}
+
 #[cfg(feature = "serde")]
 impl<'de> Deserialize<'de> for RistrettoPoint {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -343,6 +365,37 @@ impl<'de> Deserialize<'de> for RistrettoPoint {
     }
 }
 
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for CompressedRistretto {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        struct CompressedRistrettoVisitor;
+
+        impl<'de> Visitor<'de> for CompressedRistrettoVisitor {
+            type Value = CompressedRistretto;
+
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                formatter.write_str("32 bytes of data")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<CompressedRistretto, E>
+                where E: serde::de::Error
+            {
+                if v.len() == 32 {
+                    let mut arr32 = [0u8; 32];
+                    arr32[0..32].copy_from_slice(v);
+                    Ok(CompressedRistretto(arr32))
+                } else {
+                    Err(serde::de::Error::invalid_length(v.len(), &self))
+                }
+            }
+        }
+
+        deserializer.deserialize_bytes(CompressedRistrettoVisitor)
+    }
+}
+
 // ------------------------------------------------------------------------
 // Internal point representations
 // ------------------------------------------------------------------------
@@ -980,15 +1033,20 @@ mod test {
     use traits::{Identity, ValidityCheck};
     use super::*;
 
-    #[cfg(feature = "serde")]
-    use serde_cbor;
-
     #[test]
     #[cfg(feature = "serde")]
-    fn serde_cbor_basepoint_roundtrip() {
-        let output = serde_cbor::to_vec(&constants::RISTRETTO_BASEPOINT_POINT).unwrap();
-        let parsed: RistrettoPoint = serde_cbor::from_slice(&output).unwrap();
-        assert_eq!(parsed, constants::RISTRETTO_BASEPOINT_POINT);
+    fn serde_bincode_basepoint_roundtrip() {
+        use bincode;
+
+        let encoded = bincode::serialize(&constants::RISTRETTO_BASEPOINT_POINT).unwrap();
+        let enc_compressed = bincode::serialize(&constants::RISTRETTO_BASEPOINT_COMPRESSED).unwrap();
+        assert_eq!(encoded, enc_compressed);
+
+        let dec_uncompressed: RistrettoPoint = bincode::deserialize(&encoded).unwrap();
+        let dec_compressed: CompressedRistretto = bincode::deserialize(&encoded).unwrap();
+
+        assert_eq!(dec_uncompressed, constants::RISTRETTO_BASEPOINT_POINT);
+        assert_eq!(dec_compressed, constants::RISTRETTO_BASEPOINT_COMPRESSED);
     }
 
     #[test]

src/scalar.rs

@@ -1399,11 +1399,10 @@ mod test {
 
     #[test]
     #[cfg(feature = "serde")]
-    fn serde_cbor_scalar_roundtrip() {
-        // XXX remove serde_cbor
-        use serde_cbor;
-        let output = serde_cbor::to_vec(&X).unwrap();
-        let parsed: Scalar = serde_cbor::from_slice(&output).unwrap();
+    fn serde_bincode_scalar_roundtrip() {
+        use bincode;
+        let output = bincode::serialize(&X).unwrap();
+        let parsed: Scalar = bincode::deserialize(&output).unwrap();
         assert_eq!(parsed, X);
     }