Struct rubedo::crypto::VerifyingKey
source · pub struct VerifyingKey { /* private fields */ }
Expand description
An ed25519 verifying key which can be used to produce signatures.
This is a wrapper around ed25519_dalek::VerifyingKey
, which provides
additional functionality, including serialisation and deserialisation using
Serde, via the implementation of the
ByteSized
and ByteSizedFull
traits.
§See also
Implementations§
source§impl VerifyingKey
impl VerifyingKey
sourcepub const fn into_inner(self) -> RealVerifyingKey
pub const fn into_inner(self) -> RealVerifyingKey
Consumes the VerifyingKey
and returns the inner
ed25519_dalek::VerifyingKey
.
Methods from Deref<Target = RealVerifyingKey>§
sourcepub fn is_weak(&self) -> bool
pub fn is_weak(&self) -> bool
Returns whether this is a weak public key, i.e., if this public key has low order.
A weak public key can be used to generate a signature that’s valid for almost every
message. Self::verify_strict
denies weak keys, but if you want to check for this
property before verification, then use this method.
sourcepub fn verify_strict(
&self,
message: &[u8],
signature: &Signature
) -> Result<(), Error>
pub fn verify_strict( &self, message: &[u8], signature: &Signature ) -> Result<(), Error>
Strictly verify a signature on a message with this keypair’s public key.
§On The (Multiple) Sources of Malleability in Ed25519 Signatures
This version of verification is technically non-RFC8032 compliant. The following explains why.
- Scalar Malleability
The authors of the RFC explicitly stated that verification of an ed25519
signature must fail if the scalar s
is not properly reduced mod $\ell$:
To verify a signature on a message M using public key A, with F being 0 for Ed25519ctx, 1 for Ed25519ph, and if Ed25519ctx or Ed25519ph is being used, C being the context, first split the signature into two 32-octet halves. Decode the first half as a point R, and the second half as an integer S, in the range 0 <= s < L. Decode the public key A as point A’. If any of the decodings fail (including S being out of range), the signature is invalid.)
All verify_*()
functions within ed25519-dalek perform this check.
- Point malleability
The authors of the RFC added in a malleability check to step #3 in
§5.1.7, for small torsion components in the R
value of the signature,
which is not strictly required, as they state:
Check the group equation [8][S]B = [8]R + [8][k]A’. It’s sufficient, but not required, to instead check [S]B = R + [k]A’.
§History of Malleability Checks
As originally defined (cf. the “Malleability” section in the README of this repo), ed25519 signatures didn’t consider any form of malleability to be an issue. Later the scalar malleability was considered important. Still later, particularly with interests in cryptocurrency design and in unique identities (e.g. for Signal users, Tor onion services, etc.), the group element malleability became a concern.
However, libraries had already been created to conform to the original definition. One well-used library in particular even implemented the group element malleability check, but only for batch verification! Which meant that even using the same library, a single signature could verify fine individually, but suddenly, when verifying it with a bunch of other signatures, the whole batch would fail!
§“Strict” Verification
This method performs both of the above signature malleability checks.
It must be done as a separate method because one doesn’t simply get to change the definition of a cryptographic primitive ten years after-the-fact with zero consideration for backwards compatibility in hardware and protocols which have it already have the older definition baked in.
§Return
Returns Ok(())
if the signature is valid, and Err
otherwise.
sourcepub fn to_montgomery(&self) -> MontgomeryPoint
pub fn to_montgomery(&self) -> MontgomeryPoint
Convert this verifying key into Montgomery form.
This can be used for performing X25519 Diffie-Hellman using Ed25519 keys. The output of
this function is a valid X25519 public key whose secret key is sk.to_scalar_bytes()
,
where sk
is a valid signing key for this VerifyingKey
.
§Note
We do NOT recommend this usage of a signing/verifying key. Signing keys are usually long-term keys, while keys used for key exchange should rather be ephemeral. If you can help it, use a separate key for encryption.
For more information on the security of systems which use the same keys for both signing and Diffie-Hellman, see the paper On using the same key pair for Ed25519 and an X25519 based KEM.
Trait Implementations§
source§impl ByteSized<32> for VerifyingKey
impl ByteSized<32> for VerifyingKey
source§fn from_bytes(bytes: [u8; 32]) -> Self
fn from_bytes(bytes: [u8; 32]) -> Self
Converts a [u8; 32]
to a VerifyingKey
.
Note that this is a direct conversion, and does not check the validity
of the bytes. If the bytes are not a valid verifying key, the key will
be created as empty. To check the validity of the bytes, use
VerifyingKey::from_bytes()
instead.
source§fn to_bytes(&self) -> [u8; 32]
fn to_bytes(&self) -> [u8; 32]
source§fn from_base64(encoded: &str) -> Result<Self, DecodeError>
fn from_base64(encoded: &str) -> Result<Self, DecodeError>
source§impl Clone for VerifyingKey
impl Clone for VerifyingKey
source§fn clone(&self) -> VerifyingKey
fn clone(&self) -> VerifyingKey
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for VerifyingKey
impl Debug for VerifyingKey
source§impl Default for VerifyingKey
impl Default for VerifyingKey
source§impl Deref for VerifyingKey
impl Deref for VerifyingKey
source§impl<'de> Deserialize<'de> for VerifyingKey
impl<'de> Deserialize<'de> for VerifyingKey
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
source§impl Display for VerifyingKey
impl Display for VerifyingKey
source§impl ForceFrom<&[u8]> for VerifyingKey
impl ForceFrom<&[u8]> for VerifyingKey
source§fn force_from(b: &[u8]) -> Self
fn force_from(b: &[u8]) -> Self
Converts a &[u8]
to a VerifyingKey
.
Note that if the incoming [u8]
is too long to fit, it will be
truncated without error or warning. If there is not enough data, it will
be padded with zeroes. If this situation needs checking, use
try_from()
instead.
source§impl<const N: usize> ForceFrom<&[u8; N]> for VerifyingKey
impl<const N: usize> ForceFrom<&[u8; N]> for VerifyingKey
source§fn force_from(b: &[u8; N]) -> Self
fn force_from(b: &[u8; N]) -> Self
Converts a &[u8; N]
to a VerifyingKey
.
Note that if the incoming [u8; N]
is too long to fit, it will be
truncated without error or warning. If there is not enough data, it will
be padded with zeroes. If this situation needs checking, use
try_from()
instead.
source§impl ForceFrom<&Vec<u8>> for VerifyingKey
impl ForceFrom<&Vec<u8>> for VerifyingKey
source§fn force_from(v: &Vec<u8>) -> Self
fn force_from(v: &Vec<u8>) -> Self
Converts a &Vec[u8]
to a VerifyingKey
.
Note that if the incoming Vec<u8>
is too long to fit, it will
be truncated without error or warning. If there is not enough data, it
will be padded with zeroes. If this situation needs checking, use
try_from()
instead.
source§impl ForceFrom<Vec<u8>> for VerifyingKey
impl ForceFrom<Vec<u8>> for VerifyingKey
source§fn force_from(v: Vec<u8>) -> Self
fn force_from(v: Vec<u8>) -> Self
Converts a Vec<u8>
to a VerifyingKey
.
Note that if the incoming Vec<u8>
is too long to fit, it will
be truncated without error or warning. If there is not enough data, it
will be padded with zeroes. If this situation needs checking, use
try_from()
instead.
source§impl From<&VerifyingKey> for VerifyingKey
impl From<&VerifyingKey> for VerifyingKey
source§fn from(key: &RealVerifyingKey) -> Self
fn from(key: &RealVerifyingKey) -> Self
Converts a &ed25519_dalek::VerifyingKey
to a VerifyingKey
.
source§impl From<VerifyingKey> for VerifyingKey
impl From<VerifyingKey> for VerifyingKey
source§fn from(key: RealVerifyingKey) -> Self
fn from(key: RealVerifyingKey) -> Self
Converts a ed25519_dalek::VerifyingKey
to a VerifyingKey
.
source§impl FromStr for VerifyingKey
impl FromStr for VerifyingKey
source§impl Hash for VerifyingKey
impl Hash for VerifyingKey
source§impl PartialEq for VerifyingKey
impl PartialEq for VerifyingKey
source§fn eq(&self, other: &VerifyingKey) -> bool
fn eq(&self, other: &VerifyingKey) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl Serialize for VerifyingKey
impl Serialize for VerifyingKey
source§impl TryFrom<&[u8]> for VerifyingKey
impl TryFrom<&[u8]> for VerifyingKey
source§impl TryFrom<&String> for VerifyingKey
impl TryFrom<&String> for VerifyingKey
source§impl TryFrom<&str> for VerifyingKey
impl TryFrom<&str> for VerifyingKey
source§impl<'a> TryFrom<Cow<'a, str>> for VerifyingKey
impl<'a> TryFrom<Cow<'a, str>> for VerifyingKey
source§fn try_from(s: Cow<'a, str>) -> Result<Self, Self::Error>
fn try_from(s: Cow<'a, str>) -> Result<Self, Self::Error>
Converts a clone-on-write string to a VerifyingKey
.
§type Error = ByteSizedError
type Error = ByteSizedError
source§impl TryFrom<String> for VerifyingKey
impl TryFrom<String> for VerifyingKey
impl ByteSizedFull<32> for VerifyingKey
impl Copy for VerifyingKey
impl Eq for VerifyingKey
impl StructuralPartialEq for VerifyingKey
Auto Trait Implementations§
impl Freeze for VerifyingKey
impl RefUnwindSafe for VerifyingKey
impl Send for VerifyingKey
impl Sync for VerifyingKey
impl Unpin for VerifyingKey
impl UnwindSafe for VerifyingKey
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.