Add serde feature and serde for Signatures

Author: jonasnick

Cargo.lock

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+if [ -z "$1" ]; then
+  echo This test script runs the workspace tests and the -sys tests with the
+  echo serde feature enabled. This is necessary because you can not test
+  echo features on the workspace level. The script also checks if the files are
+  echo rustfmt\'d.
+  echo
+  echo "ERROR: \$1 parameter must be the workspace directory"
+  exit 1
+fi
+DIR=$1
+
+shopt -s globstar
+
+(
+    cd "$DIR"
+    set -e
+    cargo test
+    (
+        cd secp256k1-zkp-sys
+        cargo test --features serde
+    )
+    rustfmt --check -- **/*.rs
+)
+
+if [ $? -ne 0 ]; then
+    echo ERROR: $0 failed
+    exit 1
+fi
+

contrib/test.sh

@@ -11,11 +11,16 @@ keywords = [ "crypto", "ECDSA", "Schnorr", "secp256k1", "libsecp256k1", "secp256
 readme = "README.md"
 build = "build.rs"
 
+[package.metadata.docs.rs]
+features = [ "serde" ]
+all-features = true
+
 [build-dependencies]
 cc = ">= 1.0.28, <= 1.0.35"
 
 [dev-dependencies]
 rand = "0.6"
+serde_test = "1.0"
 
 [dev-dependencies.secp256k1-zkp-dev]
 version = "0.1"
@@ -25,3 +30,8 @@ path = "../secp256k1-zkp-dev/"
 version = "0.12"
 # TODO
 path = "../../rust-secp256k1/"
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+default-features = false

secp256k1-zkp-sys/Cargo.toml

@@ -32,6 +32,11 @@
 #[cfg(any(test))]
 pub extern crate rand;
 
+#[cfg(feature = "serde")]
+pub extern crate serde;
+#[cfg(all(feature = "serde", test))]
+pub extern crate serde_test;
+
 #[cfg(test)]
 extern crate core;
 #[cfg(test)]
@@ -74,6 +79,33 @@ impl Drop for ScratchSpace {
     }
 }
 
+/// Utility function used to parse hex into a target u8 buffer. Returns
+/// the number of bytes converted or an error if it encounters an invalid
+/// character or unexpected end of string.
+fn from_hex(hex: &str, target: &mut [u8]) -> Result<usize, ()> {
+    if hex.len() % 2 == 1 || hex.len() > target.len() * 2 {
+        return Err(());
+    }
+
+    let mut b = 0;
+    let mut idx = 0;
+    for c in hex.bytes() {
+        b <<= 4;
+        match c {
+            b'A'...b'F' => b |= c - b'A' + 10,
+            b'a'...b'f' => b |= c - b'a' + 10,
+            b'0'...b'9' => b |= c - b'0',
+            _ => return Err(()),
+        }
+        if (idx & 1) == 1 {
+            target[idx / 2] = b;
+            b = 0;
+        }
+        idx += 1;
+    }
+    Ok(idx / 2)
+}
+
 #[cfg(test)]
 mod tests {
     use super::ScratchSpace;

secp256k1-zkp-sys/src/lib.rs

@@ -18,12 +18,12 @@
 
 mod ffi;
 
-use core::{fmt, ptr};
+use core::{fmt, ptr, str};
 
 use secp256k1::key::{PublicKey, SecretKey};
 use secp256k1::{self, Message, Secp256k1, Signing, Verification};
 
-use super::ScratchSpace;
+use super::{from_hex, ScratchSpace};
 
 /// A Schnorrsig error. This does not implement `std:error::Error` because it's not available with
 /// `no_std`.
@@ -61,7 +61,7 @@ impl fmt::Display for Error {
 }
 
 /// A Schnorr signature
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct Signature(ffi::SchnorrSignature);
 impl Signature {
     #[inline]
@@ -113,6 +113,53 @@ impl From<ffi::SchnorrSignature> for Signature {
     }
 }
 
+impl fmt::Debug for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let v = self.serialize();
+        for ch in &v[..] {
+            write!(f, "{:02x}", *ch)?;
+        }
+        Ok(())
+    }
+}
+
+impl str::FromStr for Signature {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Signature, Error> {
+        let mut res = [0; 64];
+        if s.len() != 64 * 2 {
+            return Err(Error::InvalidSignature);
+        }
+        match from_hex(s, &mut res) {
+            Ok(x) => Signature::parse(&res[0..x]),
+            _ => Err(Error::InvalidSignature),
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl ::serde::Serialize for Signature {
+    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.serialize_bytes(&self.serialize())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> ::serde::Deserialize<'de> for Signature {
+    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Signature, D::Error> {
+        use serde::de::Error;
+
+        let sl: &[u8] = ::serde::Deserialize::deserialize(d)?;
+        Signature::parse(sl).map_err(D::Error::custom)
+    }
+}
+
 /// Schnorrsig signing trait
 pub trait Sign {
     /// Creates a Schnorr signature as defined by BIP-schnorr from a message and a secret key.
@@ -221,6 +268,7 @@ impl<C: Verification> Verify for Secp256k1<C> {
 #[cfg(test)]
 mod tests {
     use super::{Error, ScratchSpace, Sign, Signature, Verify};
+    use core::str::FromStr;
     use rand::{thread_rng, RngCore};
     use secp256k1::{Message, Secp256k1};
     use secp256k1_zkp_dev::GenerateKeypair;
@@ -247,7 +295,35 @@ mod tests {
             0xA1, 0xA6, 0x4D, 0xC5, 0x9F, 0x70, 0x13, 0xFD,
         ];
         // Shouldn't return error right now
-        Signature::parse(&ser_sig).unwrap();
+        let sig = Signature::parse(&ser_sig).unwrap();
+
+        let hex_sig = format!("{}", sig);
+        assert_eq!(sig, Signature::from_str(&hex_sig).unwrap());
+        let hex_sig = "";
+        assert_eq!(Signature::from_str(&hex_sig), Err(Error::InvalidSignature));
+        let hex_sig = "x";
+        assert_eq!(Signature::from_str(&hex_sig), Err(Error::InvalidSignature));
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_signature_serde() {
+        use secp256k1::SecretKey;
+        use serde_test::{assert_tokens, Token};
+
+        let s = Secp256k1::new();
+
+        let msg = Message::from_slice(&[1; 32]).unwrap();
+        let sk = SecretKey::from_slice(&[2; 32]).unwrap();
+        let sig = s.schnorrsig_sign(&msg, &sk);
+        static SIG_BYTES: [u8; 64] = [
+            0x9D, 0x0B, 0xAD, 0x57, 0x67, 0x19, 0xD3, 0x2A, 0xE7, 0x6B, 0xED, 0xB3, 0x4C, 0x77,
+            0x48, 0x66, 0x67, 0x3C, 0xBD, 0xE3, 0xF4, 0xE1, 0x29, 0x51, 0x55, 0x5C, 0x94, 0x08,
+            0xE6, 0xCE, 0x77, 0x4B, 0xA2, 0x9B, 0x2E, 0x41, 0x74, 0x30, 0x82, 0x17, 0x1E, 0x35,
+            0xD5, 0x63, 0xC9, 0x9D, 0x0F, 0xCE, 0xB6, 0xC4, 0x0B, 0x9A, 0xC2, 0x80, 0x77, 0x33,
+            0x59, 0xE7, 0xB5, 0x6C, 0x09, 0x41, 0x8D, 0x6D,
+        ];
+        assert_tokens(&sig, &[Token::BorrowedBytes(&SIG_BYTES[..])]);
     }
 
     #[test]

secp256k1-zkp-sys/src/schnorrsig/mod.rs

@@ -10,6 +10,9 @@ description = "Rust bindings for the Elements Project's `libsecp256k1-zkp` libra
 keywords = [ "crypto", "ECDSA", "Schnorr", "secp256k1", "libsecp256k1", "secp256k1-zkp", "libsecp256k1-zkp", "bitcoin" ]
 readme = "README.md"
 
+[features]
+serde = ["secp256k1-zkp-sys/serde"]
+
 [dev-dependencies]
 rand = "0.6"