Introduce sign_with method in keystore

client/authority-discovery/src/error.rs

@@ -46,4 +46,6 @@ pub enum Error {
 	EncodingDecodingScale(codec::Error),
 	/// Failed to parse a libp2p multi address.
 	ParsingMultiaddress(libp2p::core::multiaddr::Error),
+	/// Failed to map signature to public key
+	PublicKeyToSignatureMaping,
 }

client/authority-discovery/src/lib.rs

@@ -63,7 +63,8 @@ use sc_client_api::blockchain::HeaderBackend;
 use sc_network::specialization::NetworkSpecialization;
 use sc_network::{DhtEvent, ExHashT, NetworkStateInfo};
 use sp_authority_discovery::{AuthorityDiscoveryApi, AuthorityId, AuthoritySignature, AuthorityPair};
-use sp_core::crypto::{key_types, Pair};
+use sp_core::sr25519;
+use sp_core::crypto::{key_types, CryptoTypePublicPair, Pair, Public};
 use sp_core::traits::BareCryptoStorePtr;
 use sp_runtime::{traits::Block as BlockT, generic::BlockId};
 use sp_api::ProvideRuntimeApi;
@@ -211,10 +212,23 @@ where
 			.encode(&mut serialized_addresses)
 			.map_err(Error::EncodingProto)?;
 
-		for key in self.get_priv_keys_within_authority_set()?.into_iter() {
-			let signature = key.sign(&serialized_addresses);
+		let keys: Vec<CryptoTypePublicPair> = self.get_own_public_keys_within_authority_set()?
+			.into_iter()
+			.map(|k| (sr25519::SR25519_CRYPTO_ID, k.to_raw_vec()))
+			.collect();
+
+		let signatures = self.key_store
+							 .read()
+							 .sign_with_all(
+								 key_types::AUTHORITY_DISCOVERY,
+								 keys.clone(),
+								 serialized_addresses.as_slice()
+							 );
 
+		for (index, signature) in signatures.iter().enumerate() {
 			let mut signed_addresses = vec![];
+			let key = keys.get(index).ok_or(Error::PublicKeyToSignatureMaping)?;
+
 			schema::SignedAuthorityAddresses {
 				addresses: serialized_addresses.clone(),
 				signature: signature.encode(),
@@ -223,7 +237,7 @@ where
 				.map_err(Error::EncodingProto)?;
 
 			self.network.put_value(
-				hash_authority_id(key.public().as_ref())?,
+				hash_authority_id(key.1.as_ref())?,
 				signed_addresses,
 			);
 		}
@@ -347,21 +361,6 @@ where
 		Ok(())
 	}
 
-	/// Retrieve all local authority discovery private keys that are within the current authority
-	/// set.
-	fn get_priv_keys_within_authority_set(&mut self) -> Result<Vec<AuthorityPair>> {
-		let keys = self.get_own_public_keys_within_authority_set()?
-			.into_iter()
-			.map(std::convert::Into::into)
-			.filter_map(|pub_key| {
-				self.key_store.read().sr25519_key_pair(key_types::AUTHORITY_DISCOVERY, &pub_key)
-			})
-			.map(std::convert::Into::into)
-			.collect();
-
-		Ok(keys)
-	}
-
 	/// Retrieve our public keys within the current authority set.
 	//
 	// A node might have multiple authority discovery keys within its keystore, e.g. an old one and

client/keystore/src/lib.rs

@@ -21,7 +21,8 @@
 use std::{collections::HashMap, path::PathBuf, fs::{self, File}, io::{self, Write}, sync::Arc};
 
 use sp_core::{
-	crypto::{KeyTypeId, Pair as PairT, Public, IsWrappedBy, Protected}, traits::BareCryptoStore,
+	crypto::{IsWrappedBy, CryptoTypePublicPair, KeyTypeId, Pair as PairT, Protected, Public},
+	traits::BareCryptoStore,
 };
 
 use sp_application_crypto::{AppKey, AppPublic, AppPair, ed25519, sr25519};
@@ -276,11 +277,87 @@ impl Store {
 		buf.push(key_type + key.as_str());
 		Some(buf)
 	}
+
+	/// Signs a message with the private key that matches
+	/// the public key passed.
+	fn _sign_with(
+		&self,
+		id: KeyTypeId,
+		key: &CryptoTypePublicPair,
+		msg: &[u8],
+	) -> std::result::Result<Vec<u8>, String> {
+		match key.0 {
+			ed25519::ED25519_CRYPTO_ID => {
+				let pub_key = ed25519::Public::from_slice(key.1.as_slice());
+				let key_pair: ed25519::Pair = self
+					.key_pair_by_type::<ed25519::Pair>(&pub_key, id)
+					.map(Into::into)
+					.map_err(|e| e.to_string())?;
+				return Ok(<[u8; 64]>::from(key_pair.sign(msg)).to_vec());
+			}
+			sr25519::SR25519_CRYPTO_ID => {
+				let pub_key = sr25519::Public::from_slice(key.1.as_slice());
+				let key_pair: sr25519::Pair = self
+					.key_pair_by_type::<sr25519::Pair>(&pub_key, id)
+					.map(Into::into)
+					.map_err(|e| e.to_string())?;
+				return Ok(<[u8; 64]>::from(key_pair.sign(msg)).to_vec());
+			}
+			_ => Err(String::from("Key kind invalid"))
+		}
+	}
 }
 
 impl BareCryptoStore for Store {
+	fn get_supported_keys(&self, id: KeyTypeId, keys: Vec<CryptoTypePublicPair>) -> std::result::Result<Vec<CryptoTypePublicPair>, String> {
+		let ed25519_existing_keys: Vec<Vec<u8>> = self.public_keys_by_type::<ed25519::Public>(id)
+								.map(|keys| keys.iter().map(|k| k.to_raw_vec()).collect())
+								.map_err(|e| e.to_string())?;
+		let sr25519_existing_keys: Vec<Vec<u8>> = self.public_keys_by_type::<sr25519::Public>(id)
+								.map(|keys| keys.iter().map(|k| k.to_raw_vec()).collect())
+								.map_err(|e| e.to_string())?;
+
+		Ok(keys.iter().filter_map(|k| {
+			match k.0 {
+				sr25519::SR25519_CRYPTO_ID if sr25519_existing_keys.contains(&k.1.to_vec()) => Some(k),
+				ed25519::ED25519_CRYPTO_ID if ed25519_existing_keys.contains(&k.1.to_vec()) => Some(k),
+				_ => None
+			}
+		}).cloned().collect::<Vec<_>>())
+	}
+
+	fn get_keys(&self, id: KeyTypeId) -> std::result::Result<Vec<CryptoTypePublicPair>, String> {
+		let ed25519_existing_keys: Vec<Vec<u8>> = self.public_keys_by_type::<ed25519::Public>(id)
+								.map(|keys| keys.iter().map(|k| k.to_raw_vec()).collect())
+								.map_err(|e| e.to_string())?;
+		let sr25519_existing_keys: Vec<Vec<u8>> = self.public_keys_by_type::<sr25519::Public>(id)
+								.map(|keys| keys.iter().map(|k| k.to_raw_vec()).collect())
+								.map_err(|e| e.to_string())?;
+
+		let mut keys: Vec<CryptoTypePublicPair> = vec![];
+		keys.extend(sr25519_existing_keys.iter()
+					.cloned()
+    				.map(|k| (sr25519::SR25519_CRYPTO_ID, k)));
+		keys.extend(ed25519_existing_keys.iter()
+    				.cloned()
+					.map(|k| (ed25519::ED25519_CRYPTO_ID, k))
+					.collect::<Vec<_>>());
+		Ok(keys)
+
+	}
+
+	fn sign_with(
+		&self,
+		id: KeyTypeId,
+		key: &CryptoTypePublicPair,
+		msg: &[u8],
+	) -> std::result::Result<Vec<u8>, String> {
+		self._sign_with(id, key, msg)
+	}
+
 	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
-		self.public_keys_by_type::<sr25519::Public>(key_type).unwrap_or_default()
+		self.public_keys_by_type::<sr25519::Public>(key_type)
+			.unwrap_or_default()
 	}
 
 	fn sr25519_generate_new(
@@ -296,10 +373,6 @@ impl BareCryptoStore for Store {
 		Ok(pair.public())
 	}
 
-	fn sr25519_key_pair(&self, id: KeyTypeId, pub_key: &sr25519::Public) -> Option<sr25519::Pair> {
-		self.key_pair_by_type::<sr25519::Pair>(pub_key, id).ok()
-	}
-
 	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
 		self.public_keys_by_type::<ed25519::Public>(key_type).unwrap_or_default()
 	}
@@ -317,10 +390,6 @@ impl BareCryptoStore for Store {
 		Ok(pair.public())
 	}
 
-	fn ed25519_key_pair(&self, id: KeyTypeId, pub_key: &ed25519::Public) -> Option<ed25519::Pair> {
-		self.key_pair_by_type::<ed25519::Pair>(pub_key, id).ok()
-	}
-
 	fn insert_unknown(&mut self, key_type: KeyTypeId, suri: &str, public: &[u8])
 		-> std::result::Result<(), ()>
 	{

primitives/application-crypto/src/lib.rs

@@ -25,7 +25,7 @@ pub use sp_core::{self, crypto::{CryptoType, Public, Derive, IsWrappedBy, Wraps}
 #[doc(hidden)]
 #[cfg(feature = "full_crypto")]
 pub use sp_core::crypto::{SecretStringError, DeriveJunction, Ss58Codec, Pair};
-pub use sp_core::{crypto::{KeyTypeId, key_types}};
+pub use sp_core::crypto::{CryptoTypeId, KeyTypeId, key_types};
 
 #[doc(hidden)]
 pub use codec;
@@ -271,6 +271,8 @@ macro_rules! app_crypto_public_common {
 		}
 
 		impl $crate::Public for Public {
+			const CRYPTO_TYPE_ID: $crate::CryptoTypeId = $crate::CryptoTypeId(stringify!($key_type));
+
 			fn from_slice(x: &[u8]) -> Self { Self(<$public>::from_slice(x)) }
 		}
 

primitives/core/src/crypto.rs

@@ -515,7 +515,12 @@ impl<T: Sized + AsMut<[u8]> + AsRef<[u8]> + Default + Derive> Ss58Codec for T {
 }
 
 /// Trait suitable for typical cryptographic PKI key public type.
-pub trait Public: AsRef<[u8]> + AsMut<[u8]> + Default + Derive + CryptoType + PartialEq + Eq + Clone + Send + Sync {
+pub trait Public:
+	AsRef<[u8]> + AsMut<[u8]> + Default + Derive + CryptoType + PartialEq + Eq + Clone + Send + Sync
+{
+	/// Each implementation of Public should define its Kind identifier
+	const CRYPTO_TYPE_ID: CryptoTypeId;
+
 	/// A new instance from the given slice.
 	///
 	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
@@ -657,6 +662,8 @@ mod dummy {
 	impl Derive for Dummy {}
 
 	impl Public for Dummy {
+		const CRYPTO_TYPE_ID: CryptoTypeId = CryptoTypeId("dummy");
+
 		fn from_slice(_: &[u8]) -> Self { Self }
 		#[cfg(feature = "std")]
 		fn to_raw_vec(&self) -> Vec<u8> { vec![] }
@@ -882,7 +889,7 @@ pub trait CryptoType {
 
 /// An identifier for a type of cryptographic key.
 ///
-/// To avoid clashes with other modules when distributing your module publically, register your
+/// To avoid clashes with other modules when distributing your module publicly, register your
 /// `KeyTypeId` on the list here by making a PR.
 ///
 /// Values whose first character is `_` are reserved for private use and won't conflict with any
@@ -918,6 +925,13 @@ impl<'a> TryFrom<&'a str> for KeyTypeId {
 	}
 }
 
+/// An identifier for a specific cryptographic algorithm used by a key pair
+#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct CryptoTypeId(pub &'static str);
+
+/// A type alias of CryptoTypeId & a public key
+pub type CryptoTypePublicPair = (CryptoTypeId, Vec<u8>);
+
 /// Known key types; this also functions as a global registry of key types for projects wishing to
 /// avoid collisions with each other.
 ///

primitives/core/src/ecdsa.rs

@@ -36,10 +36,15 @@ use crate::{hashing::blake2_256, crypto::{Pair as TraitPair, DeriveJunction, Sec
 use crate::crypto::Ss58Codec;
 #[cfg(feature = "std")]
 use serde::{de, Serializer, Serialize, Deserializer, Deserialize};
-use crate::crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive};
+use crate::crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive, CryptoTypeId};
 #[cfg(feature = "full_crypto")]
 use secp256k1::{PublicKey, SecretKey};
 
+/// A value which is passed along with the public key
+/// to define which cryptographic algorithm that key
+/// belongs to.
+pub const ECDSA_CRYPTO_ID: CryptoTypeId = CryptoTypeId("ecdsa");
+
 /// A secret seed (which is bytewise essentially equivalent to a SecretKey).
 ///
 /// We need it as a different type because `Seed` is expected to be AsRef<[u8]>.
@@ -95,6 +100,7 @@ impl Public {
 }
 
 impl TraitPublic for Public {
+	const CRYPTO_TYPE_ID: CryptoTypeId = ECDSA_CRYPTO_ID;
 	/// A new instance from the given slice that should be 33 bytes long.
 	///
 	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if

primitives/core/src/ed25519.rs

@@ -38,10 +38,15 @@ use crate::crypto::{Pair as TraitPair, DeriveJunction, SecretStringError};
 use crate::crypto::Ss58Codec;
 #[cfg(feature = "std")]
 use serde::{de, Serializer, Serialize, Deserializer, Deserialize};
-use crate::{crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive}};
+use crate::crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive, CryptoTypeId};
 use sp_runtime_interface::pass_by::PassByInner;
 use sp_std::ops::Deref;
 
+/// A value which is passed along with the public key
+/// to define which cryptographic algorithm that key
+/// belongs to.
+pub const ED25519_CRYPTO_ID: CryptoTypeId = CryptoTypeId("ed25519");
+
 /// A secret seed. It's not called a "secret key" because ring doesn't expose the secret keys
 /// of the key pair (yeah, dumb); as such we're forced to remember the seed manually if we
 /// will need it later (such as for HDKD).
@@ -365,6 +370,8 @@ impl Public {
 }
 
 impl TraitPublic for Public {
+	const CRYPTO_TYPE_ID: CryptoTypeId = ED25519_CRYPTO_ID;
+
 	/// A new instance from the given slice that should be 32 bytes long.
 	///
 	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if

primitives/core/src/sr25519.rs

@@ -39,7 +39,7 @@ use crate::crypto::{
 #[cfg(feature = "std")]
 use crate::crypto::Ss58Codec;
 
-use crate::{crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive}};
+use crate::crypto::{Public as TraitPublic, UncheckedFrom, CryptoType, Derive, CryptoTypeId};
 use crate::hash::{H256, H512};
 use codec::{Encode, Decode};
 use sp_std::ops::Deref;
@@ -54,6 +54,11 @@ use sp_runtime_interface::pass_by::PassByInner;
 #[cfg(feature = "full_crypto")]
 const SIGNING_CTX: &[u8] = b"substrate";
 
+/// A value which is passed along with the public key
+/// to define which cryptographic algorithm that key
+/// belongs to.
+pub const SR25519_CRYPTO_ID: CryptoTypeId = CryptoTypeId("sr25519");
+
 /// An Schnorrkel/Ristretto x25519 ("sr25519") public key.
 #[cfg_attr(feature = "full_crypto", derive(Hash))]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Encode, Decode, Default, PassByInner)]
@@ -379,6 +384,8 @@ impl Public {
 }
 
 impl TraitPublic for Public {
+	const CRYPTO_TYPE_ID: CryptoTypeId = SR25519_CRYPTO_ID;
+
 	/// A new instance from the given slice that should be 32 bytes long.
 	///
 	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if