Struct SignedMetadata 

pub struct SignedMetadata<D, M>
where
    D: Pouf,
{ /* private fields */ }

Serialized metadata with attached unverified signatures.

Implementations

impl<D, M> SignedMetadata<D, M>

where D: Pouf, M: Metadata,

pub fn new(metadata: &M, private_key: &dyn PrivateKey) -> Result<Self>

Create a new SignedMetadata. The supplied private key is used to sign the canonicalized bytes of the provided metadata with the provided scheme.

let key = Ed25519PrivateKey::from_pkcs8(&key).unwrap();

let snapshot = SnapshotMetadataBuilder::new().build().unwrap();
SignedMetadata::<Pouf1, _>::new(&snapshot, &key).unwrap();

pub fn to_raw(&self) -> Result<RawSignedMetadata<D, M>>

Serialize this metadata to canonical bytes suitable for serialization. Note that this method is only intended to serialize signed metadata generated by this crate, not to re-serialize metadata that was originally obtained from a remote source.

TUF metadata hashes are on the raw bytes of the metadata, so it is not guaranteed that the hash of the returned bytes will match a hash included in, for example, a snapshot metadata file, as:

• Parsing metadata removes unknown fields, which would not be included in the returned bytes,
• Pouf implementations only guarantee the bytes are canonical for the purpose of a signature. Metadata obtained from a remote source may have included different whitespace or ordered fields in a way that is not preserved when parsing that metadata.

pub fn add_signature(&mut self, private_key: &dyn PrivateKey) -> Result<()>

Append a signature to this signed metadata. Will overwrite signature by keys with the same ID.

WARNING: You should never have multiple TUF private keys on the same machine, so if you’re using this to append several signatures at once, you are doing something wrong. The preferred method is to generate your copy of the metadata locally and use merge_signatures to perform the “append” operations.

let key_1: &[u8] = include_bytes!("../tests/ed25519/ed25519-1.pk8.der");
let key_1 = Ed25519PrivateKey::from_pkcs8(&key_1).unwrap();

// Note: This is for demonstration purposes only.
// You should never have multiple private keys on the same device.
let key_2: &[u8] = include_bytes!("../tests/ed25519/ed25519-2.pk8.der");
let key_2 = Ed25519PrivateKey::from_pkcs8(&key_2).unwrap();

let snapshot = SnapshotMetadataBuilder::new().build().unwrap();
let mut snapshot = SignedMetadata::<Pouf1, _>::new(&snapshot, &key_1).unwrap();

snapshot.add_signature(&key_2).unwrap();
assert_eq!(snapshot.signatures().len(), 2);

snapshot.add_signature(&key_2).unwrap();
assert_eq!(snapshot.signatures().len(), 2);

pub fn merge_signatures(&mut self, other: &Self) -> Result<()>

Merge the singatures from other into self if and only if self.as_ref() == other.as_ref(). If self and other contain signatures from the same key ID, then the signatures from self will replace the signatures from other.

pub fn signatures(&self) -> &[Signature]

An immutable reference to the signatures.

pub fn assume_valid(&self) -> Result<M>

Parse this metadata without verifying signatures.

This operation is not safe to do with metadata obtained from an untrusted source.

Trait Implementations

impl<D, M: Clone> Clone for SignedMetadata<D, M>

where D: Pouf + Clone, D::RawData: Clone,

fn clone(&self) -> SignedMetadata<D, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D, M: Debug> Debug for SignedMetadata<D, M>

where D: Pouf + Debug, D::RawData: Debug,

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

Formats the value using the given formatter.

impl<'de, D, M> Deserialize<'de> for SignedMetadata<D, M>

where D: Pouf, D::RawData: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<D, M: PartialEq> PartialEq for SignedMetadata<D, M>

where D: Pouf + PartialEq, D::RawData: PartialEq,

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

where D: Pouf, D::RawData: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<D, M> StructuralPartialEq for SignedMetadata<D, M>

where D: Pouf,