Struct SignedCommit 

pub struct SignedCommit {
    commit: Commit,
    signature: [u8; 64],
}

A commit and the signature over it.

Fields

commit: Commit

signature: [u8; 64]

Implementations

impl SignedCommit

pub fn new(commit: Commit, signature: [u8; 64]) -> Self

Reassembles a commit and a signature that were stored apart.

pub fn decode(block: &[u8]) -> Result<Self, CommitError>

Reads a commit block another server wrote.

The block holds exactly the six fields a version 3 commit has, prev included even when it is null. Anything else is refused here. A field this left out of Commit::to_sign would fail the signature anyway, so refusing it first says why.

pub fn commit(&self) -> &Commit

What was signed.

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

The 64-byte compact signature, r then s.

pub fn block(&self) -> Vec<u8>

The block a CAR file carries and a CID names.

pub fn cid(&self) -> Cid

The CID of that block, which is a CAR export’s root.

pub fn verify(&self, key: &VerifyingKey) -> Result<(), CommitError>

Checks the signature against a public key.

The key must come from somewhere other than this object for the answer to mean anything — a DID document, in practice. Verifying with the key that signed proves the signing code is self-consistent and nothing else; see tests/did_document.rs, which takes the key out of a serialised document instead.

A high-S signature fails, because k256 refuses one internally and atproto requires low-S. That is a known jacquard defect not applying to us, rather than something handled here.

pub fn verify_for( &self, did: &str, key: &VerifyingKey, ) -> Result<(), CommitError>

Checks the signature, and that the commit is for the repository asked about.

The two go together far more often than either goes alone: a signature that verifies against the key in did:web:a’s document, on a commit whose did is did:web:b, is a valid signature and the wrong answer.

pub fn verify_with(&self, did: &str, key: &CommitKey) -> Result<(), CommitError>

SignedCommit::verify_for, with a key of either curve.

A P-256 signature with a high s fails, as a secp256k1 one does: [secp256r1::VerifyingKey::verify] refuses it.

fn check_repo(&self, did: &str) -> Result<(), CommitError>

Refuses a commit for any repository but did’s.

fn check_version(&self) -> Result<(), CommitError>

Refuses a repository format this crate does not write.

Trait Implementations

impl Clone for SignedCommit

fn clone(&self) -> SignedCommit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignedCommit

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

Formats the value using the given formatter.

impl PartialEq for SignedCommit

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

impl StructuralPartialEq for SignedCommit