Struct diem_sdk::crypto::ed25519::Ed25519Signature

pub struct Ed25519Signature(_);

An Ed25519 signature

Implementations

impl Ed25519Signature

pub const LENGTH: usize = 64usize

The length of the Ed25519Signature

pub fn to_bytes(&self) -> [u8; 64]

Serialize an Ed25519Signature.

pub fn dummy_signature() -> Ed25519Signature

return an all-zero signature (for test only)

pub fn check_malleability(bytes: &[u8]) -> Result<(), CryptoMaterialError>

Check for correct size and third-party based signature malleability issues. This method is required to ensure that given a valid signature for some message under some key, an attacker cannot produce another valid signature for the same message and key.

According to RFC8032, signatures comprise elements {R, S} and we should enforce that S is of canonical form (smaller than L, where L is the order of edwards25519 curve group) to prevent signature malleability. Without this check, one could add a multiple of L into S and still pass signature verification, resulting in a distinct yet valid signature.

This method does not check the R component of the signature, because R is hashed during signing and verification to compute h = H(ENC(R) || ENC(A) || M), which means that a third-party cannot modify R without being detected.

Note: It’s true that malicious signers can already produce varying signatures by choosing a different nonce, so this method protects against malleability attacks performed by a non-signer.

Trait Implementations

impl Clone for Ed25519Signature

fn clone(&self) -> Ed25519Signature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ed25519Signature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ed25519Signature

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

Deserialize this value from the given Serde deserializer.

impl Display for Ed25519Signature

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

Formats the value using the given formatter.

impl From<Ed25519Signature> for MultiEd25519Signature

fn from(ed_signature: Ed25519Signature) -> MultiEd25519Signature

Converts to this type from the input type.

impl Hash for Ed25519Signature

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

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 Length for Ed25519Signature

fn length(&self) -> usize

The serialized length of the data

impl PartialEq<Ed25519Signature> for Ed25519Signature

fn eq(&self, other: &Ed25519Signature) -> 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 Serialize for Ed25519Signature

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

Serialize this value into the given Serde serializer.

impl Signature for Ed25519Signature

fn verify<T>( &self, message: &T, public_key: &Ed25519PublicKey ) -> Result<(), Error>where T: CryptoHash + Serialize,

Verifies that the provided signature is valid for the provided message, according to the RFC8032 algorithm. This strict verification performs the recommended check of 5.1.7 §3, on top of the required RFC8032 verifications.

fn verify_arbitrary_msg( &self, message: &[u8], public_key: &Ed25519PublicKey ) -> Result<(), Error>

Checks that self is valid for an arbitrary &u8 message using public_key. Outside of this crate, this particular function should only be used for native signature verification in move

type VerifyingKeyMaterial = Ed25519PublicKey

The associated verifying key type for this signature.

type SigningKeyMaterial = Ed25519PrivateKey

The associated signing key type for this signature

fn to_bytes(&self) -> Vec<u8, Global>

Convert the signature into a byte representation.

fn batch_verify<T>( message: &T, keys_and_signatures: Vec<(Self::VerifyingKeyMaterial, Self), Global> ) -> Result<(), Error>where T: CryptoHash + Serialize,

The implementer can override a batch verification implementation that by default iterates over each signature. More efficient implementations exist and should be implemented for many schemes.

impl TryFrom<&[u8]> for Ed25519Signature

type Error = CryptoMaterialError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Ed25519Signature, CryptoMaterialError>

Performs the conversion.

impl ValidCryptoMaterial for Ed25519Signature

fn to_bytes(&self) -> Vec<u8, Global>

Convert the valid crypto material to bytes.

impl Eq for Ed25519Signature