From 7c32271346caad0b1bfd8dca78eb8c66b4669751 Mon Sep 17 00:00:00 2001 From: Henry de Valence Date: Sat, 13 May 2017 22:40:51 -0700 Subject: [PATCH 1/5] Initial work on Serde support --- Cargo.toml | 9 +++++++ src/curve.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/decaf.rs | 65 ++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 5 ++++ 4 files changed, 155 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 1e06fd9..eab9733 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,6 +18,15 @@ exclude = [ [badges] travis-ci = { repository = "isislovecruft/curve25519-dalek", branch = "master"} +[dependencies.serde] +version = "1.0" + +[dependencies.serde_json] +version = "1.0" + +[dependencies.serde_cbor] +version = "0.6" + [dependencies.arrayref] version = "0.3.3" diff --git a/src/curve.rs b/src/curve.rs index 552e736..b516321 100644 --- a/src/curve.rs +++ b/src/curve.rs @@ -278,6 +278,59 @@ impl CompressedMontgomeryU { } } +// ------------------------------------------------------------------------ +// Serde support +// ------------------------------------------------------------------------ +// Serializes to and from `ExtendedPoint` directly, doing compression +// and decompression internally. This means that users can create +// structs containing `ExtendedPoint`s and use Serde's derived +// serializers to serialize those structures. + +use serde::{Serialize, Deserialize}; +use serde::{Serializer, Deserializer}; +use serde::de::Visitor; +use serde; + +impl Serialize for ExtendedPoint { + fn serialize(&self, serializer: S) -> Result + where S: Serializer + { + serializer.serialize_bytes(self.compress_edwards().as_bytes()) + } +} + +impl<'de> Deserialize<'de> for ExtendedPoint { + fn deserialize(deserializer: D) -> Result + where D: Deserializer<'de> + { + struct ExtendedPointVisitor; + + impl<'de> Visitor<'de> for ExtendedPointVisitor { + type Value = ExtendedPoint; + + fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + formatter.write_str("a valid point in Edwards y + sign format") + } + + fn visit_bytes(self, v: &[u8]) -> Result + where E: serde::de::Error + { + println!("VISIT_BYTES"); + if v.len() == 32 { + let arr32 = array_ref!(v,0,32); // &[u8;32] from &[u8] + CompressedEdwardsY(*arr32).decompress() + .ok_or(serde::de::Error::custom("decompression failed")) + } else { + Err(serde::de::Error::invalid_length(v.len(), &self)) + } + } + } + + println!("DESERIALIZE"); + deserializer.deserialize_bytes(ExtendedPointVisitor) + } +} + // ------------------------------------------------------------------------ // Internal point representations // ------------------------------------------------------------------------ @@ -1576,6 +1629,29 @@ mod test { assert_eq!(result.compress_edwards(), DOUBLE_SCALAR_MULT_RESULT); } } + + use serde_cbor; + + #[test] + fn serde_cbor_basepoint_roundtrip() { + let output = serde_cbor::to_vec(&constants::ED25519_BASEPOINT).unwrap(); + let parsed: ExtendedPoint = serde_cbor::from_slice(&output).unwrap(); + assert_eq!(parsed.compress_edwards(), constants::BASE_CMPRSSD); + } + + /* + use serde_json; + + #[test] + fn serde_json_basepoint_roundtrip() { + let output = serde_json::to_string(&constants::ED25519_BASEPOINT).unwrap(); + println!("{:?}", output); + println!("{:?}", constants::BASE_CMPRSSD); + let parsed: ExtendedPoint = serde_json::from_str(&output).unwrap(); + println!("{:?}", parsed); + panic!(); + } + */ } // ------------------------------------------------------------------------ diff --git a/src/decaf.rs b/src/decaf.rs index 9d36c10..95eb65c 100644 --- a/src/decaf.rs +++ b/src/decaf.rs @@ -108,6 +108,61 @@ impl Identity for CompressedDecaf { } } +// ------------------------------------------------------------------------ +// Serde support +// ------------------------------------------------------------------------ +// Serializes to and from `DecafPoint` directly, doing compression +// and decompression internally. This means that users can create +// structs containing `DecafPoint`s and use Serde's derived +// serializers to serialize those structures. + +use serde::{Serialize, Deserialize}; +use serde::{Serializer, Deserializer}; +use serde::de::Visitor; +use serde; + +impl Serialize for DecafPoint { + fn serialize(&self, serializer: S) -> Result + where S: Serializer + { + serializer.serialize_bytes(self.compress().as_bytes()) + } +} + +impl<'de> Deserialize<'de> for DecafPoint { + fn deserialize(deserializer: D) -> Result + where D: Deserializer<'de> + { + struct DecafPointVisitor; + + impl<'de> Visitor<'de> for DecafPointVisitor { + type Value = DecafPoint; + + fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + formatter.write_str("a valid point in Decaf format") + } + + fn visit_bytes(self, v: &[u8]) -> Result + where E: serde::de::Error + { + if v.len() == 32 { + let arr32 = array_ref!(v,0,32); // &[u8;32] from &[u8] + CompressedDecaf(*arr32).decompress() + .ok_or(serde::de::Error::custom("decompression failed")) + } else { + Err(serde::de::Error::invalid_length(v.len(), &self)) + } + } + } + + deserializer.deserialize_bytes(DecafPointVisitor) + } +} + +// ------------------------------------------------------------------------ +// Internal point representations +// ------------------------------------------------------------------------ + /// A point in a prime-order group. /// /// XXX think about how this API should work @@ -381,6 +436,16 @@ mod test { use curve::Identity; use super::*; + use serde_cbor; + + #[test] + fn serde_cbor_basepoint_roundtrip() { + let output = serde_cbor::to_vec(&constants::DECAF_ED25519_BASEPOINT).unwrap(); + let parsed: DecafPoint = serde_cbor::from_slice(&output).unwrap(); + assert_eq!(parsed, constants::DECAF_ED25519_BASEPOINT); + } + + #[test] fn decaf_decompress_negative_s_fails() { // constants::d is neg, so decompression should fail as |d| != d. diff --git a/src/lib.rs b/src/lib.rs index 40efe8b..91491d5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -47,6 +47,11 @@ extern crate arrayref; extern crate generic_array; extern crate digest; +//#[cfg(feature = "serde")] +extern crate serde; +extern crate serde_cbor; +extern crate serde_json; + #[cfg(feature = "std")] extern crate core; From 69fd268aa484888ad704b7f433570524ac9046c9 Mon Sep 17 00:00:00 2001 From: Henry de Valence Date: Sun, 14 May 2017 18:06:59 -0700 Subject: [PATCH 2/5] Make serde an optional feature --- .travis.yml | 1 + Cargo.toml | 10 ++++------ src/curve.rs | 12 ++++++++---- src/decaf.rs | 10 +++++++--- src/lib.rs | 4 ++-- 5 files changed, 22 insertions(+), 15 deletions(-) diff --git a/.travis.yml b/.travis.yml index 709f428..f9f46f3 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,6 +7,7 @@ rust: env: - TEST_COMMAND=test FEATURES=--features="yolocrypto" + - TEST_COMMAND=test FEATURES=--features="yolocrypto serde" - TEST_COMMAND=test FEATURES=--features="yolocrypto nightly" - TEST_COMMAND=bench FEATURES=--features="yolocrypto bench" - TEST_COMMAND=bench FEATURES=--features="yolocrypto nightly bench" diff --git a/Cargo.toml b/Cargo.toml index eab9733..5bdd3bc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,12 +20,7 @@ travis-ci = { repository = "isislovecruft/curve25519-dalek", branch = "master"} [dependencies.serde] version = "1.0" - -[dependencies.serde_json] -version = "1.0" - -[dependencies.serde_cbor] -version = "0.6" +optional = true [dependencies.arrayref] version = "0.3.3" @@ -44,6 +39,9 @@ version = "^0.6" [dev-dependencies.sha2] version = "0.4" +[dev-dependencies.serde_cbor] +version = "0.6" + [features] nightly = ["radix_51"] default = ["std"] diff --git a/src/curve.rs b/src/curve.rs index b516321..d191a0f 100644 --- a/src/curve.rs +++ b/src/curve.rs @@ -286,11 +286,12 @@ impl CompressedMontgomeryU { // structs containing `ExtendedPoint`s and use Serde's derived // serializers to serialize those structures. -use serde::{Serialize, Deserialize}; -use serde::{Serializer, Deserializer}; +#[cfg(feature = "serde")] +use serde::{self, Serialize, Deserialize, Serializer, Deserializer}; +#[cfg(feature = "serde")] use serde::de::Visitor; -use serde; +#[cfg(feature = "serde")] impl Serialize for ExtendedPoint { fn serialize(&self, serializer: S) -> Result where S: Serializer @@ -299,6 +300,7 @@ impl Serialize for ExtendedPoint { } } +#[cfg(feature = "serde")] impl<'de> Deserialize<'de> for ExtendedPoint { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> @@ -1610,7 +1612,7 @@ mod test { mod vartime { use super::super::*; use super::{A_SCALAR, B_SCALAR, A_TIMES_BASEPOINT, DOUBLE_SCALAR_MULT_RESULT}; - + /// Test double_scalar_mult_vartime vs ed25519.py #[test] fn double_scalar_mult_basepoint_vs_ed25519py() { @@ -1630,9 +1632,11 @@ 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).unwrap(); let parsed: ExtendedPoint = serde_cbor::from_slice(&output).unwrap(); diff --git a/src/decaf.rs b/src/decaf.rs index 95eb65c..fa259e5 100644 --- a/src/decaf.rs +++ b/src/decaf.rs @@ -116,11 +116,12 @@ impl Identity for CompressedDecaf { // structs containing `DecafPoint`s and use Serde's derived // serializers to serialize those structures. -use serde::{Serialize, Deserialize}; -use serde::{Serializer, Deserializer}; +#[cfg(feature = "serde")] +use serde::{self, Serialize, Deserialize, Serializer, Deserializer}; +#[cfg(feature = "serde")] use serde::de::Visitor; -use serde; +#[cfg(feature = "serde")] impl Serialize for DecafPoint { fn serialize(&self, serializer: S) -> Result where S: Serializer @@ -129,6 +130,7 @@ impl Serialize for DecafPoint { } } +#[cfg(feature = "serde")] impl<'de> Deserialize<'de> for DecafPoint { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de> @@ -436,9 +438,11 @@ mod test { use curve::Identity; use super::*; + #[cfg(feature = "serde")] use serde_cbor; #[test] + #[cfg(feature = "serde")] fn serde_cbor_basepoint_roundtrip() { let output = serde_cbor::to_vec(&constants::DECAF_ED25519_BASEPOINT).unwrap(); let parsed: DecafPoint = serde_cbor::from_slice(&output).unwrap(); diff --git a/src/lib.rs b/src/lib.rs index 91491d5..408d7ff 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -47,10 +47,10 @@ extern crate arrayref; extern crate generic_array; extern crate digest; -//#[cfg(feature = "serde")] +#[cfg(feature = "serde")] extern crate serde; +#[cfg(all(test, feature = "serde"))] extern crate serde_cbor; -extern crate serde_json; #[cfg(feature = "std")] extern crate core; From d3515e8cbf82039076ec89e89eeba2c4afc87d4a Mon Sep 17 00:00:00 2001 From: Henry de Valence Date: Sun, 14 May 2017 21:56:19 -0700 Subject: [PATCH 3/5] Add test that decompressing an invalid point with serde fails --- src/curve.rs | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/curve.rs b/src/curve.rs index d191a0f..67f569f 100644 --- a/src/curve.rs +++ b/src/curve.rs @@ -1643,19 +1643,16 @@ mod test { assert_eq!(parsed.compress_edwards(), constants::BASE_CMPRSSD); } - /* - use serde_json; - #[test] - fn serde_json_basepoint_roundtrip() { - let output = serde_json::to_string(&constants::ED25519_BASEPOINT).unwrap(); - println!("{:?}", output); - println!("{:?}", constants::BASE_CMPRSSD); - let parsed: ExtendedPoint = serde_json::from_str(&output).unwrap(); - println!("{:?}", parsed); - panic!(); + #[cfg(feature = "serde")] + fn serde_cbor_decode_invalid_fails() { + let mut output = serde_cbor::to_vec(&constants::ED25519_BASEPOINT).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 = serde_cbor::from_slice(&output); + assert!(parsed.is_err()); } - */ } // ------------------------------------------------------------------------ From 69c62a8a170e25ccbecd8aa1d68b84dd7b036b46 Mon Sep 17 00:00:00 2001 From: Henry de Valence Date: Mon, 15 May 2017 02:54:40 -0700 Subject: [PATCH 4/5] Serde Scalar support --- src/scalar.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/src/scalar.rs b/src/scalar.rs index 34a45ba..7f90624 100644 --- a/src/scalar.rs +++ b/src/scalar.rs @@ -185,6 +185,50 @@ impl CTAssignable for Scalar { } } +#[cfg(feature = "serde")] +use serde::{self, Serialize, Deserialize, Serializer, Deserializer}; +#[cfg(feature = "serde")] +use serde::de::Visitor; + +#[cfg(feature = "serde")] +impl Serialize for Scalar { + fn serialize(&self, serializer: S) -> Result + where S: Serializer + { + serializer.serialize_bytes(self.as_bytes()) + } +} + +#[cfg(feature = "serde")] +impl<'de> Deserialize<'de> for Scalar { + fn deserialize(deserializer: D) -> Result + where D: Deserializer<'de> + { + struct ScalarVisitor; + + impl<'de> Visitor<'de> for ScalarVisitor { + type Value = Scalar; + + fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + formatter.write_str("a 32-byte scalar value") + } + + fn visit_bytes(self, v: &[u8]) -> Result + where E: serde::de::Error + { + if v.len() == 32 { + // array_ref turns &[u8] into &[u8;32] + Ok(Scalar(*array_ref!(v,0,32))) + } else { + Err(serde::de::Error::invalid_length(v.len(), &self)) + } + } + } + + deserializer.deserialize_bytes(ScalarVisitor) + } +} + impl Scalar { /// Return a `Scalar` chosen uniformly at random using a user-provided RNG. /// @@ -827,6 +871,17 @@ mod test { assert_eq!(should_be_X, X); } + + #[cfg(feature = "serde")] + use serde_cbor; + + #[test] + #[cfg(feature = "serde")] + fn serde_cbor_scalar_roundtrip() { + let output = serde_cbor::to_vec(&X).unwrap(); + let parsed: Scalar = serde_cbor::from_slice(&output).unwrap(); + assert_eq!(parsed, X); + } } #[cfg(all(test, feature = "bench"))] From aea15e8612e186bf5e88be867e770338c379bf2c Mon Sep 17 00:00:00 2001 From: Henry de Valence Date: Mon, 15 May 2017 17:53:36 -0700 Subject: [PATCH 5/5] remove debugging println!s --- src/curve.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/curve.rs b/src/curve.rs index 67f569f..f8a6edd 100644 --- a/src/curve.rs +++ b/src/curve.rs @@ -317,7 +317,6 @@ impl<'de> Deserialize<'de> for ExtendedPoint { fn visit_bytes(self, v: &[u8]) -> Result where E: serde::de::Error { - println!("VISIT_BYTES"); if v.len() == 32 { let arr32 = array_ref!(v,0,32); // &[u8;32] from &[u8] CompressedEdwardsY(*arr32).decompress() @@ -328,7 +327,6 @@ impl<'de> Deserialize<'de> for ExtendedPoint { } } - println!("DESERIALIZE"); deserializer.deserialize_bytes(ExtendedPointVisitor) } }