Struct nix_compat::narinfo::signature::Signature

pub struct Signature<S> {
    name: S,
    bytes: SignatureBytes,
}

Fields

name: S

bytes: SignatureBytes

Implementations

impl<S> Signature<S>

where S: Deref<Target = str>,

Represents the signatures that Nix emits. It consists of a name (an identifier for a public key), and an ed25519 signature (64 bytes). It is generic over the string type that’s used for the name, and there’s SignatureRef as a type alias for one containing &str.

pub fn new(name: S, bytes: SignatureBytes) -> Self

Constructs a new Signature from a name and public key.

pub fn parse<'a>(input: &'a str) -> Result<Self, Error>

where S: From<&'a str>,

Parses a Signature from a string containing the name, a colon, and 64 base64-encoded bytes (plus padding). These strings are commonly seen in the Signature: field of a NARInfo file.

pub fn name(&self) -> &S

Returns the name field of the signature.

pub fn bytes(&self) -> &SignatureBytes

Returns the 64 bytes of signatures.

pub fn verify(&self, fingerprint: &[u8], verifying_key: &VerifyingKey) -> bool

For a given fingerprint and ed25519 verifying key, ensure if the signature is valid.

pub fn as_ref(&self) -> SignatureRef<'_>

Constructs a SignatureRef from this signature.

pub fn to_owned(&self) -> Signature<String>

Trait Implementations

impl<S: Clone> Clone for Signature<S>

fn clone(&self) -> Signature<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Signature<S>

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

Formats the value using the given formatter.

impl<'a, 'de, S> Deserialize<'de> for Signature<S>

where S: Deref<Target = str> + From<&'a str>, 'de: 'a,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> Display for Signature<S>

where S: Display,

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

Formats the value using the given formatter.

impl<S> Hash for Signature<S>

where S: AsRef<str>,

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 NixDeserialize for Signature<String>

async fn try_deserialize<R>(reader: &mut R) -> Result<Option<Self>, R::Error>

where R: ?Sized + NixRead + Send,

Read a value from the reader. This returns an Option to support gracefull shutdown.

fn deserialize<R>( reader: &mut R, ) -> impl Future<Output = Result<Self, R::Error>> + Send + '_

where R: ?Sized + NixRead + Send,

impl NixSerialize for Signature<String>

async fn serialize<W>(&self, writer: &mut W) -> Result<(), W::Error>

where W: NixWrite,

Write a value to the writer.

impl<S: PartialEq> PartialEq for Signature<S>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S> Serialize for Signature<S>

where S: Deref<Target = str> + Display,

fn serialize<SR>(&self, serializer: SR) -> Result<SR::Ok, SR::Error>

where SR: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq> Eq for Signature<S>

impl<S> StructuralPartialEq for Signature<S>