Struct sp_core::ecdsa::Signature

pub struct Signature(pub [u8; 65]);

A signature (a 512-bit value, plus 8 bits for recovery ID).

Tuple Fields

0: [u8; 65]

Implementations

impl Signature

pub fn from_raw(data: [u8; 65]) -> Signature

A new instance from the given 65-byte data.

NOTE: No checking goes on to ensure this is a real signature. Only use it if you are certain that the array actually is a signature. GIGO!

pub fn from_slice(data: &[u8]) -> Option<Self>

A new instance from the given slice that should be 65 bytes long.

NOTE: No checking goes on to ensure this is a real signature. Only use it if you are certain that the array actually is a signature. GIGO!

Examples found in repository

src/ecdsa.rs (line 486)

	fn verify_weak<P: AsRef<[u8]>, M: AsRef<[u8]>>(sig: &[u8], message: M, pubkey: P) -> bool {
		match Signature::from_slice(sig).and_then(|sig| sig.recover(message)) {
			Some(actual) => actual.as_ref() == pubkey.as_ref(),
			None => false,
		}
	}

pub fn recover<M: AsRef<[u8]>>(&self, message: M) -> Option<Public>

Recover the public key from this signature and a message.

Examples found in repository

src/ecdsa.rs (line 475)

	fn verify<M: AsRef<[u8]>>(sig: &Self::Signature, message: M, pubkey: &Self::Public) -> bool {
		match sig.recover(message) {
			Some(actual) => actual == *pubkey,
			None => false,
		}
	}

	/// Verify a signature on a message. Returns true if the signature is good.
	///
	/// This doesn't use the type system to ensure that `sig` and `pubkey` are the correct
	/// size. Use it only if you're coming from byte buffers and need the speed.
	fn verify_weak<P: AsRef<[u8]>, M: AsRef<[u8]>>(sig: &[u8], message: M, pubkey: P) -> bool {
		match Signature::from_slice(sig).and_then(|sig| sig.recover(message)) {
			Some(actual) => actual.as_ref() == pubkey.as_ref(),
			None => false,
		}
	}

pub fn recover_prehashed(&self, message: &[u8; 32]) -> Option<Public>

Recover the public key from this signature and a pre-hashed message.

Examples found in repository

src/ecdsa.rs (line 330)

	pub fn recover<M: AsRef<[u8]>>(&self, message: M) -> Option<Public> {
		self.recover_prehashed(&blake2_256(message.as_ref()))
	}

	/// Recover the public key from this signature and a pre-hashed message.
	#[cfg(feature = "full_crypto")]
	pub fn recover_prehashed(&self, message: &[u8; 32]) -> Option<Public> {
		let rid = RecoveryId::from_i32(self.0[64] as i32).ok()?;
		let sig = RecoverableSignature::from_compact(&self.0[..64], rid).ok()?;
		let message = Message::from_slice(message).expect("Message is 32 bytes; qed");

		#[cfg(feature = "std")]
		let context = SECP256K1;
		#[cfg(not(feature = "std"))]
		let context = Secp256k1::verification_only();

		context
			.recover_ecdsa(&message, &sig)
			.ok()
			.map(|pubkey| Public(pubkey.serialize()))
	}
}

#[cfg(feature = "full_crypto")]
impl From<RecoverableSignature> for Signature {
	fn from(recsig: RecoverableSignature) -> Signature {
		let mut r = Self::default();
		let (recid, sig) = recsig.serialize_compact();
		r.0[..64].copy_from_slice(&sig);
		// This is safe due to the limited range of possible valid ids.
		r.0[64] = recid.to_i32() as u8;
		r
	}
}

/// Derive a single hard junction.
#[cfg(feature = "full_crypto")]
fn derive_hard_junction(secret_seed: &Seed, cc: &[u8; 32]) -> Seed {
	("Secp256k1HDKD", secret_seed, cc).using_encoded(sp_core_hashing::blake2_256)
}

/// An error when deriving a key.
#[cfg(feature = "full_crypto")]
pub enum DeriveError {
	/// A soft key was found in the path (and is unsupported).
	SoftKeyInPath,
}

/// A key pair.
#[cfg(feature = "full_crypto")]
#[derive(Clone)]
pub struct Pair {
	public: Public,
	secret: SecretKey,
}

#[cfg(feature = "full_crypto")]
impl TraitPair for Pair {
	type Public = Public;
	type Seed = Seed;
	type Signature = Signature;
	type DeriveError = DeriveError;

	/// Generate new secure (random) key pair and provide the recovery phrase.
	///
	/// You can recover the same key later with `from_phrase`.
	#[cfg(feature = "std")]
	fn generate_with_phrase(password: Option<&str>) -> (Pair, String, Seed) {
		let mnemonic = Mnemonic::new(MnemonicType::Words12, Language::English);
		let phrase = mnemonic.phrase();
		let (pair, seed) = Self::from_phrase(phrase, password)
			.expect("All phrases generated by Mnemonic are valid; qed");
		(pair, phrase.to_owned(), seed)
	}

	/// Generate key pair from given recovery phrase and password.
	#[cfg(feature = "std")]
	fn from_phrase(
		phrase: &str,
		password: Option<&str>,
	) -> Result<(Pair, Seed), SecretStringError> {
		let big_seed = substrate_bip39::seed_from_entropy(
			Mnemonic::from_phrase(phrase, Language::English)
				.map_err(|_| SecretStringError::InvalidPhrase)?
				.entropy(),
			password.unwrap_or(""),
		)
		.map_err(|_| SecretStringError::InvalidSeed)?;
		let mut seed = Seed::default();
		seed.copy_from_slice(&big_seed[0..32]);
		Self::from_seed_slice(&big_seed[0..32]).map(|x| (x, seed))
	}

	/// Make a new key pair from secret seed material.
	///
	/// You should never need to use this; generate(), generate_with_phrase
	fn from_seed(seed: &Seed) -> Pair {
		Self::from_seed_slice(&seed[..]).expect("seed has valid length; qed")
	}

	/// Make a new key pair from secret seed material. The slice must be 32 bytes long or it
	/// will return `None`.
	///
	/// You should never need to use this; generate(), generate_with_phrase
	fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError> {
		let secret =
			SecretKey::from_slice(seed_slice).map_err(|_| SecretStringError::InvalidSeedLength)?;

		#[cfg(feature = "std")]
		let context = SECP256K1;
		#[cfg(not(feature = "std"))]
		let context = Secp256k1::signing_only();

		let public = PublicKey::from_secret_key(&context, &secret);
		let public = Public(public.serialize());
		Ok(Pair { public, secret })
	}

	/// Derive a child key from a series of given junctions.
	fn derive<Iter: Iterator<Item = DeriveJunction>>(
		&self,
		path: Iter,
		_seed: Option<Seed>,
	) -> Result<(Pair, Option<Seed>), DeriveError> {
		let mut acc = self.seed();
		for j in path {
			match j {
				DeriveJunction::Soft(_cc) => return Err(DeriveError::SoftKeyInPath),
				DeriveJunction::Hard(cc) => acc = derive_hard_junction(&acc, &cc),
			}
		}
		Ok((Self::from_seed(&acc), Some(acc)))
	}

	/// Get the public key.
	fn public(&self) -> Public {
		self.public
	}

	/// Sign a message.
	fn sign(&self, message: &[u8]) -> Signature {
		self.sign_prehashed(&blake2_256(message))
	}

	/// Verify a signature on a message. Returns true if the signature is good.
	fn verify<M: AsRef<[u8]>>(sig: &Self::Signature, message: M, pubkey: &Self::Public) -> bool {
		match sig.recover(message) {
			Some(actual) => actual == *pubkey,
			None => false,
		}
	}

	/// Verify a signature on a message. Returns true if the signature is good.
	///
	/// This doesn't use the type system to ensure that `sig` and `pubkey` are the correct
	/// size. Use it only if you're coming from byte buffers and need the speed.
	fn verify_weak<P: AsRef<[u8]>, M: AsRef<[u8]>>(sig: &[u8], message: M, pubkey: P) -> bool {
		match Signature::from_slice(sig).and_then(|sig| sig.recover(message)) {
			Some(actual) => actual.as_ref() == pubkey.as_ref(),
			None => false,
		}
	}

	/// Return a vec filled with raw data.
	fn to_raw_vec(&self) -> Vec<u8> {
		self.seed().to_vec()
	}
}

#[cfg(feature = "full_crypto")]
impl Pair {
	/// Get the seed for this key.
	pub fn seed(&self) -> Seed {
		self.secret.secret_bytes()
	}

	/// Exactly as `from_string` except that if no matches are found then, the the first 32
	/// characters are taken (padded with spaces as necessary) and used as the MiniSecretKey.
	#[cfg(feature = "std")]
	pub fn from_legacy_string(s: &str, password_override: Option<&str>) -> Pair {
		Self::from_string(s, password_override).unwrap_or_else(|_| {
			let mut padded_seed: Seed = [b' '; 32];
			let len = s.len().min(32);
			padded_seed[..len].copy_from_slice(&s.as_bytes()[..len]);
			Self::from_seed(&padded_seed)
		})
	}

	/// Sign a pre-hashed message
	pub fn sign_prehashed(&self, message: &[u8; 32]) -> Signature {
		let message = Message::from_slice(message).expect("Message is 32 bytes; qed");

		#[cfg(feature = "std")]
		let context = SECP256K1;
		#[cfg(not(feature = "std"))]
		let context = Secp256k1::signing_only();

		context.sign_ecdsa_recoverable(&message, &self.secret).into()
	}

	/// Verify a signature on a pre-hashed message. Return `true` if the signature is valid
	/// and thus matches the given `public` key.
	pub fn verify_prehashed(sig: &Signature, message: &[u8; 32], public: &Public) -> bool {
		match sig.recover_prehashed(message) {
			Some(actual) => actual == *public,
			None => false,
		}
	}

Trait Implementations

impl AsMut<[u8]> for Signature

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u8; 65]> for Signature

fn as_ref(&self) -> &[u8; 65]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8]> for Signature

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Signature

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CryptoType for Signature

type Pair = Pair

The pair key type of this crypto.

impl Debug for Signature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for Signature

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for Signature

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Signature

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Signature

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R

Convert self to a slice and then invoke the given closure with it.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<RecoverableSignature> for Signature

fn from(recsig: RecoverableSignature) -> Signature

Converts to this type from the input type.

impl From<Signature> for [u8; 65]

fn from(v: Signature) -> [u8; 65]

Converts to this type from the input type.

impl Hash for Signature

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl MaxEncodedLen for Signature

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl PartialEq<Signature> for Signature

fn eq(&self, other: &Signature) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PassBy for Signature

type PassBy = Inner<Signature, [u8; 65]>

The strategy that should be used to pass the type.

impl PassByInner for Signature

type Inner = [u8; 65]

The inner type that is wrapped by Self.

fn into_inner(self) -> Self::Inner

Consumes self and returns the inner type.

fn inner(&self) -> &Self::Inner

Returns the reference to the inner type.

fn from_inner(inner: Self::Inner) -> Self

Construct Self from the given inner.

impl Serialize for Signature

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&[u8]> for Signature

type Error = ()

The type returned in the event of a conversion error.

fn try_from(data: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TypeInfo for Signature

type Identity = Signature

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl UncheckedFrom<[u8; 65]> for Signature

fn unchecked_from(data: [u8; 65]) -> Signature

Convert from an instance of T to Self. This is not guaranteed to be whatever counts as a valid instance of T and it’s up to the caller to ensure that it makes sense.

impl EncodeLike<Signature> for Signature

impl Eq for Signature

impl StructuralEq for Signature

impl StructuralPartialEq for Signature