Remove toplevel 'signature' re-exports; add encoding::Error

This removes many of the types previously re-exported from the toplevel of the `signatory` crate. This includes all of the types that come from the `signature` crate. Additionally this splits out a `signatory::encoding::Error` which is unique from `signatory::signature::Error` and used to handle encoding/decoding strings as well as reading/writing from files, in which case it's nice to provide some additional debugging information like the filename.
crypto-com · Aug 11, 2019 · 2fc2cb0 · 2fc2cb0
1 parent 104817e
commit 2fc2cb0
Show file tree

Hide file tree

Showing 36 changed files with 377 additions and 205 deletions.
diff --git a/signatory-dalek/benches/ed25519.rs b/signatory-dalek/benches/ed25519.rs
@@ -7,7 +7,11 @@
 extern crate criterion;
 
 use criterion::Criterion;
-use signatory::{ed25519, test_vector::TestVector, Signature, Signer, Verifier};
+use signatory::{
+    ed25519,
+    signature::{Signature, Signer, Verifier},
+    test_vector::TestVector,
+};
 use signatory_dalek::{Ed25519Signer, Ed25519Verifier};
 
 /// Test vector to use for benchmarking

diff --git a/signatory-dalek/src/lib.rs b/signatory-dalek/src/lib.rs
@@ -25,8 +25,10 @@
 extern crate signatory;
 
 use signatory::{
-    digest::Digest, ed25519, generic_array::typenum::U64, DigestSigner, DigestVerifier, Error,
-    PublicKeyed, Signature, Signer, Verifier,
+    ed25519,
+    generic_array::typenum::U64,
+    public_key::PublicKeyed,
+    signature::{digest::Digest, DigestSigner, DigestVerifier, Error, Signature, Signer, Verifier},
 };
 
 /// Ed25519 signature provider for ed25519-dalek
@@ -48,7 +50,7 @@ impl PublicKeyed<ed25519::PublicKey> for Ed25519Signer {
 impl Signer<ed25519::Signature> for Ed25519Signer {
     fn try_sign(&self, msg: &[u8]) -> Result<ed25519::Signature, Error> {
         let signature = self.0.sign(msg).to_bytes();
-        Ok(Signature::from_bytes(&signature[..]).unwrap())
+        Ok(ed25519::Signature::from_bytes(&signature[..]).unwrap())
     }
 }
 
@@ -62,7 +64,8 @@ where
         let context: Option<&'static [u8]> = None;
 
         let signature =
-            Signature::from_bytes(&self.0.sign_prehashed(digest, context).to_bytes()[..]).unwrap();
+            ed25519::Signature::from_bytes(&self.0.sign_prehashed(digest, context).to_bytes()[..])
+                .unwrap();
 
         Ok(signature)
     }

diff --git a/signatory-ledger-tm/Cargo.toml b/signatory-ledger-tm/Cargo.toml
@@ -17,7 +17,6 @@ circle-ci = { repository = "tendermint/signatory" }
 [dependencies]
 lazy_static = "1"
 ledger-tendermint = "0.4"
-libc = "0.2"
 
 [dependencies.signatory]
 version = "0.12"

diff --git a/signatory-ledger-tm/benches/ed25519.rs b/signatory-ledger-tm/benches/ed25519.rs
@@ -8,7 +8,11 @@ extern crate criterion;
 use signatory;
 
 use criterion::Criterion;
-use signatory::{ed25519, PublicKeyed, Signature, Verifier};
+use signatory::{
+    ed25519,
+    public_key::PublicKeyed,
+    signature::{Signature, Verifier},
+};
 use signatory_ledger_tm::Ed25519LedgerTmAppSigner;
 
 fn pubkey_ed25519(c: &mut Criterion) {

diff --git a/signatory-ledger-tm/src/lib.rs b/signatory-ledger-tm/src/lib.rs
@@ -10,7 +10,8 @@
 use ledger_tendermint::ledgertm::TendermintValidatorApp;
 use signatory::{
     ed25519::{PublicKey, Signature},
-    Error, PublicKeyed, Signer,
+    public_key::PublicKeyed,
+    signature::{Error, Signer},
 };
 use std::sync::{Arc, Mutex};
 
@@ -54,7 +55,7 @@ mod tests {
 
     #[test]
     fn public_key() {
-        use signatory::PublicKeyed;
+        use signatory::public_key::PublicKeyed;
         let signer = Ed25519LedgerTmAppSigner::connect().unwrap();
 
         let _pk = signer.public_key().unwrap();
@@ -64,7 +65,7 @@ mod tests {
     #[test]
     fn sign() {
         use crate::Ed25519LedgerTmAppSigner;
-        use signatory::Signer;
+        use signatory::signature::Signer;
 
         let signer = Ed25519LedgerTmAppSigner::connect().unwrap();
 
@@ -86,7 +87,7 @@ mod tests {
 
     #[test]
     fn sign2() {
-        use signatory::Signer;
+        use signatory::signature::Signer;
 
         let signer = Ed25519LedgerTmAppSigner::connect().unwrap();
 
@@ -123,8 +124,8 @@ mod tests {
 
     #[test]
     fn sign_many() {
-        use signatory::PublicKeyed;
-        use signatory::Signer;
+        use signatory::public_key::PublicKeyed;
+        use signatory::signature::Signer;
         use Ed25519LedgerTmAppSigner;
 
         let signer = Ed25519LedgerTmAppSigner::connect().unwrap();

diff --git a/signatory-ring/benches/ecdsa.rs b/signatory-ring/benches/ecdsa.rs
@@ -14,8 +14,8 @@ use signatory::{
     },
     encoding::FromPkcs8,
     generic_array::GenericArray,
+    signature::{Signature, Signer as _, Verifier as _},
     test_vector::TestVector,
-    Signature, Signer as _, Verifier as _,
 };
 use signatory_ring::ecdsa::p256::{Signer, Verifier};
 

diff --git a/signatory-ring/benches/ed25519.rs b/signatory-ring/benches/ed25519.rs
@@ -7,7 +7,11 @@ extern crate criterion;
 use signatory;
 
 use criterion::Criterion;
-use signatory::{ed25519::TEST_VECTORS, test_vector::TestVector, Signature, Signer, Verifier};
+use signatory::{
+    ed25519::TEST_VECTORS,
+    signature::{Signature, Signer, Verifier},
+    test_vector::TestVector,
+};
 use signatory_ring::ed25519;
 
 /// Test vector to use for benchmarking

diff --git a/signatory-ring/src/ecdsa/p256.rs b/signatory-ring/src/ecdsa/p256.rs
@@ -11,8 +11,12 @@ use ring::{
 };
 use signatory::{
     ecdsa,
-    encoding::pkcs8::{self, FromPkcs8, GeneratePkcs8},
-    Error, PublicKeyed,
+    encoding::{
+        self,
+        pkcs8::{self, FromPkcs8, GeneratePkcs8},
+    },
+    public_key::PublicKeyed,
+    signature,
 };
 use untrusted;
 
@@ -25,7 +29,7 @@ where
 
 impl FromPkcs8 for Signer<Asn1Signature> {
     /// Create a new ECDSA signer which produces fixed-width signatures from a PKCS#8 keypair
-    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, Error> {
+    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, encoding::Error> {
         Ok(Signer(EcdsaSigner::from_pkcs8(
             &ECDSA_P256_SHA256_ASN1_SIGNING,
             secret_key.as_ref(),
@@ -35,7 +39,7 @@ impl FromPkcs8 for Signer<Asn1Signature> {
 
 impl FromPkcs8 for Signer<FixedSignature> {
     /// Create a new ECDSA signer which produces fixed-width signatures from a PKCS#8 keypair
-    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, Error> {
+    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, encoding::Error> {
         Ok(Signer(EcdsaSigner::from_pkcs8(
             &ECDSA_P256_SHA256_FIXED_SIGNING,
             secret_key.as_ref(),
@@ -45,7 +49,7 @@ impl FromPkcs8 for Signer<FixedSignature> {
 
 impl GeneratePkcs8 for Signer<Asn1Signature> {
     /// Randomly generate a P-256 **PKCS#8** keypair
-    fn generate_pkcs8() -> Result<pkcs8::SecretKey, Error> {
+    fn generate_pkcs8() -> Result<pkcs8::SecretKey, encoding::Error> {
         let keypair = ring::signature::EcdsaKeyPair::generate_pkcs8(
             &ECDSA_P256_SHA256_ASN1_SIGNING,
             &SystemRandom::new(),
@@ -58,7 +62,7 @@ impl GeneratePkcs8 for Signer<Asn1Signature> {
 
 impl GeneratePkcs8 for Signer<FixedSignature> {
     /// Randomly generate a P-256 **PKCS#8** keypair
-    fn generate_pkcs8() -> Result<pkcs8::SecretKey, Error> {
+    fn generate_pkcs8() -> Result<pkcs8::SecretKey, encoding::Error> {
         let keypair = ring::signature::EcdsaKeyPair::generate_pkcs8(
             &ECDSA_P256_SHA256_FIXED_SIGNING,
             &SystemRandom::new(),
@@ -73,19 +77,19 @@ impl<S> PublicKeyed<PublicKey> for Signer<S>
 where
     S: ecdsa::Signature + Send + Sync,
 {
-    fn public_key(&self) -> Result<PublicKey, Error> {
-        PublicKey::from_bytes(self.0.public_key()).ok_or_else(Error::new)
+    fn public_key(&self) -> Result<PublicKey, signature::Error> {
+        PublicKey::from_bytes(self.0.public_key()).ok_or_else(signature::Error::new)
     }
 }
 
-impl signatory::Signer<Asn1Signature> for Signer<Asn1Signature> {
-    fn try_sign(&self, msg: &[u8]) -> Result<Asn1Signature, Error> {
+impl signature::Signer<Asn1Signature> for Signer<Asn1Signature> {
+    fn try_sign(&self, msg: &[u8]) -> Result<Asn1Signature, signature::Error> {
         self.0.sign(msg)
     }
 }
 
-impl signatory::Signer<FixedSignature> for Signer<FixedSignature> {
-    fn try_sign(&self, msg: &[u8]) -> Result<FixedSignature, Error> {
+impl signature::Signer<FixedSignature> for Signer<FixedSignature> {
+    fn try_sign(&self, msg: &[u8]) -> Result<FixedSignature, signature::Error> {
         self.0.sign(msg)
     }
 }
@@ -100,27 +104,27 @@ impl<'a> From<&'a PublicKey> for Verifier {
     }
 }
 
-impl signatory::Verifier<Asn1Signature> for Verifier {
-    fn verify(&self, msg: &[u8], signature: &Asn1Signature) -> Result<(), Error> {
+impl signature::Verifier<Asn1Signature> for Verifier {
+    fn verify(&self, msg: &[u8], signature: &Asn1Signature) -> Result<(), signature::Error> {
         ring::signature::verify(
             &ECDSA_P256_SHA256_ASN1,
             untrusted::Input::from(self.0.as_ref()),
             untrusted::Input::from(msg),
             untrusted::Input::from(signature.as_ref()),
         )
-        .map_err(|_| Error::new())
+        .map_err(|_| signature::Error::new())
     }
 }
 
-impl signatory::Verifier<FixedSignature> for Verifier {
-    fn verify(&self, msg: &[u8], signature: &FixedSignature) -> Result<(), Error> {
+impl signature::Verifier<FixedSignature> for Verifier {
+    fn verify(&self, msg: &[u8], signature: &FixedSignature) -> Result<(), signature::Error> {
         ring::signature::verify(
             &ECDSA_P256_SHA256_FIXED,
             untrusted::Input::from(self.0.as_ref()),
             untrusted::Input::from(msg),
             untrusted::Input::from(signature.as_ref()),
         )
-        .map_err(|_| Error::new())
+        .map_err(|_| signature::Error::new())
     }
 }
 
@@ -133,7 +137,8 @@ mod tests {
         },
         encoding::FromPkcs8,
         generic_array::GenericArray,
-        PublicKeyed, Signature, Signer as _, Verifier as _,
+        public_key::PublicKeyed,
+        signature::{Signature as _, Signer as _, Verifier as _},
     };
 
     #[test]

diff --git a/signatory-ring/src/ecdsa/p384.rs b/signatory-ring/src/ecdsa/p384.rs
@@ -11,8 +11,12 @@ use ring::{
 };
 use signatory::{
     ecdsa,
-    encoding::pkcs8::{self, FromPkcs8, GeneratePkcs8},
-    Error, PublicKeyed,
+    encoding::{
+        self,
+        pkcs8::{self, FromPkcs8, GeneratePkcs8},
+    },
+    public_key::PublicKeyed,
+    signature,
 };
 use untrusted;
 
@@ -25,7 +29,7 @@ where
 
 impl FromPkcs8 for Signer<Asn1Signature> {
     /// Create a new ECDSA signer which produces fixed-width signatures from a PKCS#8 keypair
-    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, Error> {
+    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, encoding::Error> {
         Ok(Signer(EcdsaSigner::from_pkcs8(
             &ECDSA_P384_SHA384_ASN1_SIGNING,
             secret_key.as_ref(),
@@ -35,7 +39,7 @@ impl FromPkcs8 for Signer<Asn1Signature> {
 
 impl FromPkcs8 for Signer<FixedSignature> {
     /// Create a new ECDSA signer which produces fixed-width signatures from a PKCS#8 keypair
-    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, Error> {
+    fn from_pkcs8<K: AsRef<[u8]>>(secret_key: K) -> Result<Self, encoding::Error> {
         Ok(Signer(EcdsaSigner::from_pkcs8(
             &ECDSA_P384_SHA384_FIXED_SIGNING,
             secret_key.as_ref(),
@@ -45,7 +49,7 @@ impl FromPkcs8 for Signer<FixedSignature> {
 
 impl GeneratePkcs8 for Signer<Asn1Signature> {
     /// Randomly generate a P-384 **PKCS#8** keypair
-    fn generate_pkcs8() -> Result<pkcs8::SecretKey, Error> {
+    fn generate_pkcs8() -> Result<pkcs8::SecretKey, encoding::Error> {
         let keypair = ring::signature::EcdsaKeyPair::generate_pkcs8(
             &ECDSA_P384_SHA384_ASN1_SIGNING,
             &SystemRandom::new(),
@@ -57,7 +61,7 @@ impl GeneratePkcs8 for Signer<Asn1Signature> {
 
 impl GeneratePkcs8 for Signer<FixedSignature> {
     /// Randomly generate a P-384 **PKCS#8** keypair
-    fn generate_pkcs8() -> Result<pkcs8::SecretKey, Error> {
+    fn generate_pkcs8() -> Result<pkcs8::SecretKey, encoding::Error> {
         let keypair = ring::signature::EcdsaKeyPair::generate_pkcs8(
             &ECDSA_P384_SHA384_FIXED_SIGNING,
             &SystemRandom::new(),
@@ -72,19 +76,19 @@ where
     S: ecdsa::Signature + Send + Sync,
 {
     /// Obtain the public key which identifies this signer
-    fn public_key(&self) -> Result<PublicKey, Error> {
-        PublicKey::from_bytes(self.0.public_key()).ok_or_else(Error::new)
+    fn public_key(&self) -> Result<PublicKey, signature::Error> {
+        PublicKey::from_bytes(self.0.public_key()).ok_or_else(signature::Error::new)
     }
 }
 
-impl signatory::Signer<Asn1Signature> for Signer<Asn1Signature> {
-    fn try_sign(&self, msg: &[u8]) -> Result<Asn1Signature, Error> {
+impl signature::Signer<Asn1Signature> for Signer<Asn1Signature> {
+    fn try_sign(&self, msg: &[u8]) -> Result<Asn1Signature, signature::Error> {
         self.0.sign(msg)
     }
 }
 
-impl signatory::Signer<FixedSignature> for Signer<FixedSignature> {
-    fn try_sign(&self, msg: &[u8]) -> Result<FixedSignature, Error> {
+impl signature::Signer<FixedSignature> for Signer<FixedSignature> {
+    fn try_sign(&self, msg: &[u8]) -> Result<FixedSignature, signature::Error> {
         self.0.sign(msg)
     }
 }
@@ -99,27 +103,27 @@ impl<'a> From<&'a PublicKey> for Verifier {
     }
 }
 
-impl signatory::Verifier<Asn1Signature> for Verifier {
-    fn verify(&self, msg: &[u8], signature: &Asn1Signature) -> Result<(), Error> {
+impl signature::Verifier<Asn1Signature> for Verifier {
+    fn verify(&self, msg: &[u8], signature: &Asn1Signature) -> Result<(), signature::Error> {
         ring::signature::verify(
             &ECDSA_P384_SHA384_ASN1,
             untrusted::Input::from(self.0.as_ref()),
             untrusted::Input::from(msg),
             untrusted::Input::from(signature.as_ref()),
         )
-        .map_err(|_| Error::new())
+        .map_err(|_| signature::Error::new())
     }
 }
 
-impl signatory::Verifier<FixedSignature> for Verifier {
-    fn verify(&self, msg: &[u8], signature: &FixedSignature) -> Result<(), Error> {
+impl signature::Verifier<FixedSignature> for Verifier {
+    fn verify(&self, msg: &[u8], signature: &FixedSignature) -> Result<(), signature::Error> {
         ring::signature::verify(
             &ECDSA_P384_SHA384_FIXED,
             untrusted::Input::from(self.0.as_ref()),
             untrusted::Input::from(msg),
             untrusted::Input::from(signature.as_ref()),
         )
-        .map_err(|_| Error::new())
+        .map_err(|_| signature::Error::new())
     }
 }
 
@@ -132,7 +136,8 @@ mod tests {
         },
         encoding::FromPkcs8,
         generic_array::GenericArray,
-        PublicKeyed, Signature, Signer as _, Verifier as _,
+        public_key::PublicKeyed,
+        signature::{Signature as _, Signer as _, Verifier as _},
     };
 
     #[test]