Merge pull request #67 from becominginsane/bugfix/issue66

Use `serde_bytes`

Cargo.toml

@@ -63,11 +63,21 @@ version = "0.3"
 default-features = false
 optional = true
 
-[dependencies.serde]
+[dependencies.serde_crate]
 version = "1.0.123"
+package = "serde"
 default-features = false
 optional = true
 
+[dependencies.serde_bytes]
+version = "0.11.5"
+default-features = false
+optional = true
+
+[dependencies.cfg-if]
+version = "1.0.0"
+optional = true
+
 [dependencies.sha2]
 version = "0.9.3"
 default-features = false
@@ -91,6 +101,7 @@ sha2 = "0.9.3"
 sha3 = "0.9.1"
 bincode = "1.3.2"
 criterion = "0.3.4"
+serde_json = "1.0.64"
 
 [[bench]]
 name = "schnorr_benchmarks"
@@ -100,13 +111,13 @@ harness = false
 default = ["std", "u64_backend", "getrandom"] # "rand"
 preaudit_deprecated = []
 nightly = ["curve25519-dalek/nightly", "rand/nightly"] # "zeroize/nightly"
-alloc = ["curve25519-dalek/alloc", "rand_core/alloc"]
-std = ["getrandom", "curve25519-dalek/std"] # "failure/std"
+alloc = ["curve25519-dalek/alloc", "rand_core/alloc", "serde_bytes/alloc"]
+std = ["getrandom", "curve25519-dalek/std", "serde_bytes/std"] # "failure/std"
 asm = ["sha2/asm"]
 u64_backend = ["curve25519-dalek/u64_backend"]
 u32_backend = ["curve25519-dalek/u32_backend"]
 avx2_backend = ["curve25519-dalek/avx2_backend"]
-
+serde = ["serde_crate", "serde_bytes", "cfg-if"]
 # We cannot make getrandom a direct dependency because rand_core makes
 # getrandom a feature name, which requires forwarding.
 getrandom = ["rand_core/getrandom"]

src/errors.rs

@@ -160,7 +160,7 @@ impl ::failure::Fail for SignatureError {}
 /// `impl From<SignatureError> for E where E: ::serde::de::Error`.
 #[cfg(feature = "serde")]
 pub fn serde_error_from_signature_error<E>(err: SignatureError) -> E
-where E: ::serde::de::Error
+where E: ::serde_crate::de::Error
 {
  use self::SignatureError::*;
  match err {

src/serdey.rs

@@ -19,31 +19,29 @@
 // #[cfg(feature = "serde")]
 // use serde::de::Visitor;
 
-
 #[cfg(feature = "serde")]
 macro_rules! serde_boilerplate { ($t:ty) => {
-impl ::serde::Serialize for $t {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: ::serde::Serializer {
- serializer.serialize_bytes(&self.to_bytes()[..])
+impl ::serde_crate::Serialize for $t {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: ::serde_crate::Serializer {
+ let bytes = &self.to_bytes()[..];
+ ::serde_bytes::Bytes::new(bytes).serialize(serializer)
  }
 }
 
-impl<'d> ::serde::Deserialize<'d> for $t {
- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: ::serde::Deserializer<'d> {
- struct MyVisitor;
-
- impl<'d> ::serde::de::Visitor<'d> for MyVisitor {
- type Value = $t;
-
- fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
- formatter.write_str(Self::Value::DESCRIPTION)
- }
-
- fn visit_bytes<E>(self, bytes: &[u8]) -> Result<$t, E> where E: ::serde::de::Error {
- Self::Value::from_bytes(bytes).map_err(crate::errors::serde_error_from_signature_error)
+impl<'d> ::serde_crate::Deserialize<'d> for $t {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: ::serde_crate::Deserializer<'d> {
+ cfg_if::cfg_if!{
+ if #[cfg(feature = "std")] {
+ let bytes = <std::borrow::Cow<'_, [u8]>>::deserialize(deserializer)?;
+ } else if #[cfg(feature = "alloc")] {
+ let bytes = <alloc::borrow::Cow<'_, [u8]>>::deserialize(deserializer)?;
+ } else {
+ let bytes = <&::serde_bytes::Bytes>::deserialize(deserializer)?;
  }
  }
- deserializer.deserialize_bytes(MyVisitor)
+
+ Self::from_bytes(bytes.as_ref())
+ .map_err(crate::errors::serde_error_from_signature_error)
  }
 }
 } } // macro_rules! serde_boilerplate
@@ -56,6 +54,7 @@ mod test {
  use std::vec::Vec;
 
  use bincode::{serialize, serialized_size, deserialize};
+ use serde_json::{to_value, from_value, to_string, from_str};
 
  use curve25519_dalek::ristretto::{CompressedRistretto};
 
@@ -102,6 +101,21 @@ mod test {
  assert_eq!(signature, decoded_signature);
  }
 
+ #[test]
+ fn serialize_deserialize_signature_json() {
+ let signature: Signature = Signature::from_bytes(&SIGNATURE_BYTES).unwrap();
+
+ let encoded_signature = to_value(&signature).unwrap();
+ let decoded_signature: Signature = from_value(encoded_signature).unwrap();
+
+ assert_eq!(signature, decoded_signature);
+
+ let encoded_signature = to_string(&signature).unwrap();
+ let decoded_signature: Signature = from_str(&encoded_signature).unwrap();
+
+ assert_eq!(signature, decoded_signature);
+ }
+
  #[test]
  fn serialize_deserialize_public_key() {
  let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();
@@ -111,6 +125,20 @@ mod test {
  assert_eq!(public_key, decoded_public_key);
  }
 
+ #[test]
+ fn serialize_deserialize_public_key_json() {
+ let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();
+ let encoded_public_key = to_value(&public_key).unwrap();
+ let decoded_public_key: PublicKey = from_value(encoded_public_key).unwrap();
+
+ assert_eq!(public_key, decoded_public_key);
+
+ let encoded_public_key = to_string(&public_key).unwrap();
+ let decoded_public_key: PublicKey = from_str(&encoded_public_key).unwrap();
+
+ assert_eq!(public_key, decoded_public_key);
+ }
+
  /*
  TODO: Actually test serde on real secret key, not just mini one.
  fn serialize_deserialize_secret_key() {
@@ -133,6 +161,23 @@ mod test {
  }
  }
 
+ #[test]
+ fn serialize_deserialize_mini_secret_key_json() {
+ let encoded_secret_key = to_value(&ED25519_SECRET_KEY).unwrap();
+ let decoded_secret_key: MiniSecretKey = from_value(encoded_secret_key).unwrap();
+
+ for i in 0..32 {
+ assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
+ }
+
+ let encoded_secret_key = to_string(&ED25519_SECRET_KEY).unwrap();
+ let decoded_secret_key: MiniSecretKey = from_str(&encoded_secret_key).unwrap();
+
+ for i in 0..32 {
+ assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
+ }
+ }
+
  #[test]
  fn serialize_public_key_size() {
  let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();