- The "Signed References" feature was reimplemented. The commits in

  `refs/rad/sigrefs` will now only verify if they carry an appropriate value for

  `refs/rad/root` in the associated `refs` blob. This reference was introduced

  in commit `989edacd564fa658358f5ccfd08c243c5ebd8cda`, which was released via

  version 1.1.0.

  Also, the new reference `refs/rad/sigrefs-parent` is introduced. If present,

  its target must match the parent commit. This is to prevent replay. It is

  optional to maintain backwards compatibility, and might become mandatory

  (like `refs/rad/root` does in this release) in the future.

  Further, the new implementation detects replay of `refs` blobs. In order to do

  so, it walks the history of `refs/rad/sigrefs` backwards to the root commit,

  if `refs/rad/sigrefs-parent` is not set.

radicle-git-metadata = { workspace = true }

        /// A reference to the parent commit.

        ///

        /// `refs/rad/sigrefs-parent`

        ///

        pub static SIGREFS_PARENT: LazyLock<Qualified> = LazyLock::new(|| {

            Qualified::from_components(component!("rad"), component!("sigrefs-parent"), None)

        });

    use crate::storage::refs::{IDENTITY_BRANCH, IDENTITY_ROOT, SIGREFS_BRANCH, SIGREFS_PARENT};

        assert!(Pattern::try_from((*SIGREFS_PARENT).clone()).is_err());

pub mod sigrefs;

    /// Add a reference with name [`crate::git::refs::storage::SIGREFS_PARENT`]

    /// and given target OID to this set of refs.

    #[inline]

    fn add_parent(&mut self, commit: Oid) -> Option<Oid> {

        self.0.insert(SIGREFS_PARENT.to_ref_string(), commit)

    }

    /// Removes reference with name [`crate::git::refs::storage::SIGREFS_PARENT`]

    /// from this set of refs, if it exists.

    /// Absence of a reference with such name is ignored.

    #[inline]

    fn remove_parent(&mut self) -> Option<Oid> {

        self.0.remove(&SIGREFS_PARENT.to_ref_string())

    }

    if bool::arbitrary(g) {

        let parent = Oid::from_sha1(Arbitrary::arbitrary(g));

        refs.insert(SIGREFS_PARENT.to_ref_string(), parent);

    }

pub mod read;

pub use read::{SignedRefsReader, VerifiedCommit};

pub mod write;

pub mod git;

#[cfg(test)]

mod property;

//! The transparency log of Radicle signed references is encoded in the Git

//! commit graph. This module provides traits for interacting with a Git

//! repository to read and write data for the transparency log process.

pub mod object;

pub mod reference;

pub use git2_impls::committer;

use crate::profile::env;

use crypto::PublicKey;

use radicle_git_metadata::author;

use radicle_git_metadata::author::Author;

/// Convenience type that corresponds to an [`Author`].

///

/// If [`env::GIT_COMMITTER_DATE`] is set, then [`Committer::from_env`] can be

/// used to construct a stable [`Author`].

///

/// Otherwise, an [`Author`] can be provided via [`Committer::new`].

#[derive(Clone, Debug, PartialEq, Eq, Hash)]

pub struct Committer {

    pub author: Author,

}

impl Committer {

    /// Construct a [`Committer`] using [`Committer::from_env`], if possible,

    /// using `default` if not.

    pub fn from_env_or_else<F>(public_key: &PublicKey, default: F) -> Self

    where

        F: FnOnce() -> Author,

    {

        Self::from_env(public_key).unwrap_or_else(|| Self::new(default()))

    }

    /// Construct a [`Committer`] with the provided [`Author`].

    pub fn new(author: Author) -> Self {

        Self { author }

    }

    /// Construct a [`Committer`] using the timestamp found at

    /// [`env::GIT_COMMITTER_DATE`], and the given [`PublicKey`] for the email.

    pub fn from_env(public_key: &PublicKey) -> Option<Self> {

        let s = env::var(env::GIT_COMMITTER_DATE).ok()?;

        let Ok(timestamp) = s.trim().parse::<i64>() else {

            panic!(

                "Invalid timestamp value {s:?} for `{}`",

                env::GIT_COMMITTER_DATE

            );

        };

        let time = author::Time::new(timestamp, 0);

        let author = Author {

            name: "radicle".to_string(),

            email: public_key.to_human(),

            time,

        };

        Some(Self::new(author))

    }

    pub fn into_inner(self) -> Author {

        self.author

    }

}

mod git2_impls {

    //! [`git2::Repository`] implementations of the [`object`] and [`reference`] traits.

    //!

    //! [`object`]: super::object

    //! [`reference`]: super::reference

    use std::path::Path;

    use radicle_core::NodeId;

    use radicle_git_metadata::author::{Author, Time};

    use radicle_oid::Oid;

    use crate::git;

    use super::object;

    use super::object::{RefsEntry, SignatureEntry};

    use super::reference;

    use super::Committer;

    pub fn committer(node: &NodeId, signature: &git2::Signature) -> Result<Committer, git2::Error> {

        let default = {

            let name = signature

                .name()

                .map(|name| name.to_string())

                .ok_or(git2::Error::new(

                    git2::ErrorCode::Invalid,

                    git2::ErrorClass::Invalid,

                    "Invalid UTF-8 of Git signature name",

                ))?;

            let email =

                signature

                    .email()

                    .map(|email| email.to_string())

                    .ok_or(git2::Error::new(

                        git2::ErrorCode::Invalid,

                        git2::ErrorClass::Invalid,

                        "Invalid UTF-8 of Git signature email",

                    ))?;

            Author {

                name,

                email,

                time: Time::new(

                    signature.when().seconds(),

                    signature.when().offset_minutes(),

                ),

            }

        };

        Ok(Committer::from_env_or_else(node, || default))

    }

    impl object::Reader for git2::Repository {

        fn read_commit(&self, oid: &Oid) -> Result<Option<Vec<u8>>, object::error::ReadCommit> {

            use object::error::ReadCommit;

            let odb = self.odb().map_err(ReadCommit::other)?;

            let object = odb.read(git2::Oid::from(*oid));

            match object {

                Ok(object) => {

                    if object.kind() != git2::ObjectType::Commit {

                        return Err(ReadCommit::incorrect_object_error(*oid, object.kind()));

                    }

                    Ok(Some(object.data().to_vec()))

                }

                Err(e) if e.code() == git2::ErrorCode::NotFound => Ok(None),

                Err(e) => Err(ReadCommit::other(e)),

            }

        }

        fn read_blob(

            &self,

            oid: &Oid,

            path: &Path,

        ) -> Result<Option<object::Blob>, object::error::ReadBlob> {

            use object::error::ReadBlob;

            let commit = match self.find_commit(git2::Oid::from(*oid)) {

                Ok(c) => c,

                Err(e) if e.code() == git2::ErrorCode::NotFound => {

                    return Err(ReadBlob::commit_not_found_error(*oid))

                }

                Err(e) => return Err(ReadBlob::other(e)),

            };

            let tree = commit.tree().map_err(ReadBlob::other)?;

            let entry = match tree.get_path(path) {

                Ok(e) => e,

                Err(e) if e.code() == git2::ErrorCode::NotFound => return Ok(None),

                Err(e) => return Err(ReadBlob::other(e)),

            };

            let object = entry.to_object(self).map_err(ReadBlob::other)?;

            let blob = object.as_blob().ok_or(ReadBlob::incorrect_object_error(

                *oid,

                path.to_path_buf(),

                object.kind().unwrap_or(git2::ObjectType::Any),

            ))?;

            Ok(Some(object::Blob {

                oid: blob.id().into(),

                bytes: blob.content().to_vec(),

            }))

        }

    }

    impl object::Writer for git2::Repository {

        fn write_tree(

            &self,

            refs: RefsEntry,

            signature: SignatureEntry,

        ) -> Result<Oid, object::error::WriteTree> {

            use object::error::WriteTree;

            let odb = self.odb().map_err(WriteTree::write_error)?;

            let refs_oid = odb

                .write(git2::ObjectType::Blob, &refs.content)

                .map_err(WriteTree::refs_error)?;

            let sig_oid = odb

                .write(git2::ObjectType::Blob, &signature.content)

                .map_err(WriteTree::signature_error)?;

            let mut builder = self.treebuilder(None).map_err(WriteTree::write_error)?;

            builder

                .insert(&refs.path, refs_oid, git2::FileMode::Blob.into())

                .map_err(WriteTree::refs_error)?;

            builder

                .insert(&signature.path, sig_oid, git2::FileMode::Blob.into())

                .map_err(WriteTree::signature_error)?;

            let tree_oid = builder.write().map_err(WriteTree::write_error)?;

            Ok(Oid::from(tree_oid))

        }

        fn write_commit(&self, bytes: &[u8]) -> Result<Oid, object::error::WriteCommit> {

            use object::error::WriteCommit;

            let odb = self.odb().map_err(WriteCommit::other)?;

            let oid = odb

                .write(git2::ObjectType::Commit, bytes)

                .map_err(WriteCommit::other)?;

            Ok(Oid::from(oid))

        }

    }

    impl reference::Reader for git2::Repository {

        fn find_reference(

            &self,

            reference: &git::fmt::Namespaced,

        ) -> Result<Option<Oid>, reference::error::FindReference> {

            match self.refname_to_id(reference.as_str()) {

                Ok(oid) => Ok(Some(Oid::from(oid))),

                Err(e) if e.code() == git2::ErrorCode::NotFound => Ok(None),

                Err(e) => Err(reference::error::FindReference::other(e)),

            }

        }

    }

    impl reference::Writer for git2::Repository {

        fn write_reference(

            &self,

            reference: &git::fmt::Namespaced,

            commit: Oid,

            parent: Option<Oid>,

            reflog: String,

        ) -> Result<(), reference::error::WriteReference> {

            let new = git2::Oid::from(commit);

            match parent {

                Some(parent) => {

                    let old = git2::Oid::from(parent);

                    // The old OID provides a guard, which gives us a compare-and-swap —

                    // the write will fail if the ref has moved since we read it.

                    self.reference_matching(reference.as_str(), new, true, old, &reflog)

                        .map_err(reference::error::WriteReference::other)?;

                }

                None => {

                    self.reference(reference.as_str(), new, false, &reflog)

                        .map_err(reference::error::WriteReference::other)?;

                }

            }

            Ok(())

        }

    }

}

//! Traits for interacting with Git objects, necessary for implementing Radicle

//! signed references.

// TODO(finto): I think these are more generally useful than just being used for

// signed references. They might be worth moving into a crate,

// `radicle-git-traits`, but for now they can live here.

pub mod error;

use std::path::{Path, PathBuf};

use radicle_oid::Oid;

/// A Git blob object, returned by [`Reader::read_blob`].

pub struct Blob {

    /// The [`Oid`] of the Git blob.

    pub oid: Oid,

    /// The contents of the Git blob.

    pub bytes: Vec<u8>,

}

/// Git object reader, generally a Git repository, or its corresponding Object

/// Database (ODB).

pub trait Reader {

    /// Read the raw bytes of a commit object identified by `oid`.

    ///

    /// Returns `None` if no such object exists.

    ///

    /// # Errors

    ///

    /// - [`error::ReadCommit::IncorrectObject`]: the object identified by the

    ///   [`Oid`] was found, but was not a commit.

    /// - [`error::ReadCommit::Other`]: failed to read the Git commit.

    fn read_commit(&self, oid: &Oid) -> Result<Option<Vec<u8>>, error::ReadCommit>;

    /// Read the raw bytes of the blob at `path` within the tree of `commit`.

    ///

    /// Returns `None` if the path does not exist in that tree.

    ///

    /// # Errors

    ///

    /// - [`error::ReadBlob::CommitNotFound`]: failed to find the commit

    ///   identified by the [`Oid`].

    /// - [`error::ReadBlob::IncorrectObject`]: the object identified by the

    ///   [`Oid`] was found, but was not a commit.

    /// - [`error::ReadBlob::Other`]: failed to read the Git blob.

    fn read_blob(&self, commit: &Oid, path: &Path) -> Result<Option<Blob>, error::ReadBlob>;

}

/// Input to the [`Writer::write_tree`] method.

///

/// The entry describes where in the Git tree to write the [`Refs`] content

/// blob.

///

/// [`Refs`]: crate::storage::refs::Refs

#[derive(Clone, Debug, PartialEq, Eq, Hash)]

pub struct RefsEntry {

    /// Path in the Git tree to write to.

    pub path: PathBuf,

    /// The contents of the Git blob.

    pub content: Vec<u8>,

}

/// Input to the [`Writer::write_tree`] method.

///

/// The entry describes where in the Git tree to write the signature content

/// blob.

#[derive(Clone, Debug, PartialEq, Eq, Hash)]

pub struct SignatureEntry {

    /// Path in the Git tree to write to.

    pub path: PathBuf,

    /// The contents of the Git blob.

    pub content: Vec<u8>,

}

/// Git object writer, generally a Git repository, or its corresponding Object

/// Database (ODB).

pub trait Writer {

    /// Write the [`RefsEntry`] and [`SignatureEntry`] to two separate Git blobs

    /// within a shared Git tree.

    ///

    /// Returns the [`Oid`] of the Git tree.

    ///

    /// # Errors

    ///

    /// - [`error::WriteTree::Refs`]: failed to write the references Git blob.

    /// - [`error::WriteTree::Signature`]: failed to write the signature Git blob.

    /// - [`error::WriteTree::Write`]: failed to write the Git tree.

    fn write_tree(

        &self,

        refs: RefsEntry,

        signature: SignatureEntry,

    ) -> Result<Oid, error::WriteTree>;

    /// Write the given Git commit, as bytes, to the Git object database.

    ///

    /// Returns the [`Oid`] of the Git commit.

    ///

    /// # Errors

    ///

    /// - [`error::WriteCommit`]: failed to write the Git commit.

    fn write_commit(&self, bytes: &[u8]) -> Result<Oid, error::WriteCommit>;

}

use std::path::PathBuf;

use radicle_oid::Oid;

use thiserror::Error;

type StdError = dyn std::error::Error + Send + Sync + 'static;

#[derive(Debug, Error)]

#[non_exhaustive]

pub enum ReadCommit {

    #[error(transparent)]

    IncorrectObject(NotCommit),

    #[error(transparent)]

    Other(Box<StdError>),

}

impl ReadCommit {

    pub fn incorrect_object_error<K>(oid: Oid, kind: K) -> Self

    where

        K: ToString,

    {

        Self::IncorrectObject(NotCommit {

            oid,

            kind: kind.to_string(),

        })

    }

    pub fn other<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self::Other(Box::new(err))

    }

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error("the object {oid} is a {kind}, not a commit")]

pub struct NotCommit {

    oid: Oid,

    kind: String,

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error(transparent)]

pub enum ReadBlob {

    #[error(transparent)]

    CommitNotFound(CommitNotFound),

    #[error(transparent)]

    IncorrectObject(NotBlob),

    #[error(transparent)]

    Other(Box<StdError>),

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error("could not find commit {oid}")]

pub struct CommitNotFound {

    oid: Oid,

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error("the object at {path:?} in commit {commit} is a {kind}, not a blob")]

pub struct NotBlob {

    commit: Oid,

    path: PathBuf,

    kind: String,

}

impl ReadBlob {

    pub fn commit_not_found_error(oid: Oid) -> Self {

        Self::CommitNotFound(CommitNotFound { oid })

    }

    pub fn incorrect_object_error<K>(commit: Oid, path: PathBuf, kind: K) -> Self

    where

        K: ToString,

    {

        Self::IncorrectObject(NotBlob {

            commit,

            path,

            kind: kind.to_string(),

        })

    }

    pub fn other<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self::Other(Box::new(err))

    }

}

#[derive(Debug, Error)]

#[non_exhaustive]

pub enum WriteTree {

    #[error("failed to write reference blob for signed references")]

    Refs(Box<StdError>),

    #[error("failed to write signature blob for signed references")]

    Signature(Box<StdError>),

    #[error(transparent)]

    Write(Box<StdError>),

}

impl WriteTree {

    pub fn refs_error<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self::Refs(Box::new(err))

    }

    pub fn signature_error<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self::Signature(Box::new(err))

    }

    pub fn write_error<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self::Write(Box::new(err))

    }

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error(transparent)]

pub struct WriteCommit {

    source: Box<StdError>,

}

impl WriteCommit {

    pub fn other<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self {

            source: Box::new(err),

        }

    }

}

#![allow(clippy::unwrap_used)]

use crypto::{signature, test::signer::MockSigner, PublicKey, Signer as _};

use qcheck::TestResult;

use qcheck_macros::quickcheck;

use radicle_core::{NodeId, RepoId};

use radicle_git_metadata::author::{Author, Time};

use radicle_oid::Oid;

use tempfile::TempDir;

use crate::storage::refs::sigrefs::{

    read::{CheckpointReason, Latest, SignedRefsReader, Tip},

    write::{Committer, SignedRefsWriter, Update},

};

use crate::storage::refs::Refs;

#[derive(Clone, Debug)]

struct BoundedVec<T>(Vec<T>);

impl<T: qcheck::Arbitrary> qcheck::Arbitrary for BoundedVec<T> {

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

        let size = usize::arbitrary(g) % 24;

        BoundedVec((0..size).map(|_| T::arbitrary(g)).collect())

    }

    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {

        Box::new(self.0.shrink().map(BoundedVec))

    }

}

struct Verifier {

    key: PublicKey,

}

impl Verifier {

    fn new(signer: &MockSigner) -> Self {

        Self {

            key: *signer.public_key(),

        }

    }

}

impl signature::Verifier<crypto::Signature> for Verifier {

    fn verify(&self, msg: &[u8], signature: &crypto::Signature) -> Result<(), signature::Error> {

        self.key

            .verify(msg, signature)

            .map_err(signature::Error::from_source)

    }

}

fn mock_author() -> Author {

    Author {

        name: "testy".to_string(),

        email: "testy@example.com".to_string(),

        time: Time::new(6400, 0),

    }

}

fn mock_committer() -> Committer {

    Committer::new(mock_author())

}

fn setup() -> (TempDir, git2::Repository) {

    let dir = TempDir::new().unwrap();

    let repo = git2::Repository::init_bare(dir.path()).unwrap();

    (dir, repo)

}

fn mock_root() -> RepoId {

    RepoId::from(Oid::from_sha1([1; 20]))

}

fn write_log(

    refs: Refs,

    namespace: NodeId,

    signer: &MockSigner,

    repo: &git2::Repository,

) -> Update {

    SignedRefsWriter::new(namespace, signer, repo)

        .with_refs(refs)

        .write(

            mock_committer(),

            "test commit".to_string(),

            "test reflog".to_string(),

        )

        .unwrap()

}

fn read_log(namespace: NodeId, verifier: &Verifier, repo: &git2::Repository) -> Latest {

    SignedRefsReader::new(mock_root(), Tip::Reference(namespace), repo, verifier)

        .read()

        .unwrap()

        .unwrap()

}

#[quickcheck]

fn initial_commit_roundtrip(refs: Refs) -> bool {

    let (_dir, repo) = setup();

    let signer = MockSigner::default();

    let namespace = *signer.public_key();

    let verifier = Verifier::new(&signer);

    let update = write_log(refs.clone(), namespace, &signer, &repo);

    let head_oid = match update {

        Update::Changed { ref entry } => *entry.oid(),

        Update::Unchanged { .. } => return false,

    };

    let Latest {

        refs: expected,

        checkpoint,

        ..

    } = read_log(namespace, &verifier, &repo);

    checkpoint.head() == head_oid

        && checkpoint.ancestor() == head_oid

        && checkpoint.reason() == CheckpointReason::Root

        && expected == refs

}

#[quickcheck]

fn chain_roundtrip(chain: BoundedVec<Refs>) -> TestResult {

    let chain = chain.0;

    if chain.is_empty() {

        return TestResult::discard();

    }

    let (_dir, repo) = setup();

    let signer = MockSigner::default();

    let namespace = *signer.public_key();

    let verifier = Verifier::new(&signer);

    let mut last_changed_head = None;

    for refs in chain {

        let update = write_log(refs.clone(), namespace, &signer, &repo);

        if let Update::Changed { ref entry } = update {

            last_changed_head = Some(*entry.oid());

        }

        let Latest {

            refs: expected,

            checkpoint,

            ..

        } = read_log(namespace, &verifier, &repo);

        if refs != expected {

            return TestResult::failed();

        }

        if checkpoint.reason() != CheckpointReason::Root {

            return TestResult::failed();

        }

        if let Some(expected_head) = last_changed_head {

            if checkpoint.head() != expected_head {

                return TestResult::failed();

            }

        }

    }

    TestResult::passed()

}

#[quickcheck]

fn idempotent_write(refs: Refs) -> bool {

    let (_dir, repo) = setup();

    let signer = MockSigner::default();

    let namespace = *signer.public_key();

    let first = write_log(refs.clone(), namespace, &signer, &repo);

    let head_oid = match first {

        Update::Changed { ref entry } => *entry.oid(),

        Update::Unchanged { .. } => return false,

    };

    let second = write_log(refs, namespace, &signer, &repo);

    matches!(second, Update::Unchanged { commit, .. } if commit == head_oid)

}

//! Traits for interacting with Git references, necessary for implementing

//! Radicle signed references.

// TODO(finto): I think these are more generally useful than just being used for

// signed references. They might be worth moving into a crate,

// `radicle-git-traits`, but for now they can live here.

pub mod error;

use radicle_oid::Oid;

use crate::git;

/// Git reference reader, generally a Git repository, or its corresponding Reference

/// Database (Ref DB).

pub trait Reader {

    /// Find the head [`Oid`] of the sigrefs reference for the given namespace.

    ///

    /// Returns `None` if the reference does not yet exist.

    /// # Errors

    ///

    /// - [`error::FindReference`]: failed to write the Git reference.

    fn find_reference(

        &self,

        reference: &git::fmt::Namespaced,

    ) -> Result<Option<Oid>, error::FindReference>;

}

/// Git reference writer, generally a Git repository, or its corresponding Reference

/// Database (Ref DB).

pub trait Writer {

    /// Write the given commit [`Oid`], and its parent, to the given

    /// `reference`.

    ///

    /// The `reflog` given can used as the Git reflog message of the reference.

    ///

    /// # Concurrency

    ///

    /// It is up to the implementer to ensure the safety of writing the

    /// reference safely in a concurrent environment.

    ///

    /// # Errors

    ///

    /// - [`error::WriteReference`]: failed to write the Git reference.

    fn write_reference(

        &self,

        reference: &git::fmt::Namespaced,

        commit: Oid,

        parent: Option<Oid>,

        reflog: String,

    ) -> Result<(), error::WriteReference>;

}

use thiserror::Error;

#[derive(Debug, Error)]

#[non_exhaustive]

#[error(transparent)]

pub struct FindReference(Box<dyn std::error::Error + Send + Sync + 'static>);

impl FindReference {

    pub fn other<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self(Box::new(err))

    }

}

#[derive(Debug, Error)]

#[non_exhaustive]

#[error(transparent)]

pub struct WriteReference(Box<dyn std::error::Error + Send + Sync + 'static>);

impl WriteReference {

    pub fn other<E>(err: E) -> Self

    where

        E: std::error::Error + Send + Sync + 'static,

    {

        Self(Box::new(err))

    }

}

#![allow(clippy::unwrap_used)]

mod mock;

use mock::*;

use crypto::test::signer::MockSigner;

use crypto::Signer as _;

use qcheck::TestResult;

use qcheck_macros::quickcheck;

use crate::storage::refs::sigrefs::read::{SignedRefsReader, Tip};

use crate::storage::refs::sigrefs::write::{SignedRefsWriter, Update};

use crate::storage::refs::Refs;

#[quickcheck]

fn roundtrip(BoundedVec(all_refs): BoundedVec<Refs>) -> TestResult {

    if all_refs.is_empty() {

        return TestResult::discard();

    }

    let fixture = Fixture::new();

    let signer = MockSigner::default();

    let node_id = *signer.public_key();

    for refs in all_refs {

        let refs = fixture.with_identity_root(refs);

        let writer = SignedRefsWriter::new(refs.clone(), node_id, fixture.repo(), &signer);

        let update = match writer.write(

            fixture.committer(),

            "roundtrip write".into(),

            "roundtrip reflog".into(),

        ) {

            Ok(u) => u,

            Err(e) => return TestResult::error(format!("write error: {e}")),

        };

        let written_refs = match update {

            Update::Changed { ref entry } => entry.clone().into_refs(),

            Update::Unchanged { ref refs, .. } => refs.clone(),

        };

        assert_eq!(refs, written_refs);

        let reader = SignedRefsReader::new(

            fixture.rid(),

            Tip::Reference(node_id),

            fixture.repo(),

            &node_id,

        );

        let verified = match reader.read() {

            Ok(v) => v,

            Err(e) => return TestResult::error(format!("read error: {e}")),

        };

        if written_refs != verified.into_refs() {

            return TestResult::failed();

        }

    }

    TestResult::passed()

}

#[quickcheck]

fn idempotent(refs: Refs) -> TestResult {

    let fixture = Fixture::new();

    let refs = fixture.with_identity_root(refs);

    let signer = MockSigner::default();

    let node_id = *signer.public_key();

    if let Err(e) = SignedRefsWriter::new(refs.clone(), node_id, fixture.repo(), &signer).write(

        fixture.committer(),

        "first write".into(),

        "first reflog".into(),

    ) {

        return TestResult::error(format!("first write error: {e}"));

    }

    match SignedRefsWriter::new(refs.clone(), node_id, fixture.repo(), &signer).write(

        fixture.committer(),

        "second write".into(),

        "second reflog".into(),

    ) {

        Ok(Update::Unchanged { .. }) => TestResult::passed(),

        Ok(Update::Changed { .. }) => {

            TestResult::error("expected Update::Unchanged on second write with identical refs")

        }

        Err(e) => TestResult::error(format!("second write error: {e}")),

    }

}

use qcheck::{Arbitrary, Gen};

use radicle_core::RepoId;

use radicle_git_metadata::author::{Author, Time};

use radicle_oid::Oid;

use tempfile::TempDir;

use crate::identity::doc;

use crate::storage::refs::sigrefs::git::Committer;

use crate::storage::refs::{Refs, IDENTITY_ROOT};

/// A `Vec<T>` whose [`Arbitrary`] instance caps the length at

/// [`Self::MAX_LEN`], preventing the property runner from generating inputs

/// that would make the test prohibitively slow.

#[derive(Clone, Debug)]

pub struct BoundedVec<T>(pub Vec<T>);

impl<T> BoundedVec<T> {

    const MAX_LEN: usize = 16;

}

impl<T: Arbitrary> Arbitrary for BoundedVec<T> {

    fn arbitrary(g: &mut Gen) -> Self {

        let len = usize::arbitrary(g) % (Self::MAX_LEN + 1);

        BoundedVec((0..len).map(|_| T::arbitrary(g)).collect())

    }

    fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {

        let inner: Vec<Vec<T>> = self.0.shrink().collect();

        Box::new(inner.into_iter().map(BoundedVec))

    }

}

/// A Radicle Git repository fixture.

///

/// It is initialized in a [`TempDir`], and starts off with a single blob to

/// emulate the identity document.

pub struct Fixture {

    /// The underlying Git repository.

    repo: git2::Repository,

    /// The [`RepoId`] of the initial identity document blob.

    rid: RepoId,

    /// The commit that points to the identity document, which provides the

    /// [`RepoId`].

    identity_commit: Oid,

    _dir: TempDir,

}

impl Fixture {

    /// Initialise a bare git repository and write the minimal object graph

    /// required for identity-root verification to succeed:

    ///

    /// ```text

    /// identity-commit

    ///   └─ tree

    ///        └─ embeds/

    ///             └─ <doc::PATH>  (blob whose OID becomes the RepoId)

    /// ```

    pub fn new() -> Self {

        let dir = TempDir::new().unwrap();

        let repo = git2::Repository::init_bare(dir.path()).unwrap();

        let (identity_commit, rid) = Self::identity_commit(&repo);

        Self {

            _dir: dir,

            repo,

            rid,

            identity_commit,

        }

    }

    /// Return the [`RepoId`] of the fixture.

    pub fn rid(&self) -> RepoId {

        self.rid

    }

    /// Return the underlying Git repository of the fixture.

    pub fn repo(&self) -> &git2::Repository {

        &self.repo

    }

    /// Return a [`Committer`] with a fixed, stable [`Author`].

    pub fn committer(&self) -> Committer {

        Committer::new(Author {

            name: "radicle".to_string(),

            email: "radicle@test".to_string(),

            time: Time::new(0, 0),

        })

    }

    /// Patch an arbitrary [`Refs`] so that its [`IDENTITY_ROOT`] entry

    /// points at the fixture's identity commit, satisfying the

    /// `debug_assert` in [`SignedRefsWriter::new`] and the identity

    /// verification in [`crate::storage::refs::sigrefs::read`].

    pub fn with_identity_root(&self, mut refs: Refs) -> Refs {

        refs.insert(IDENTITY_ROOT.to_ref_string(), self.identity_commit);

        refs

    }

    fn identity_commit(repo: &git2::Repository) -> (Oid, RepoId) {

        let (doc_tree, rid) = Self::write_doc_blob(repo);

        let tree = Self::write_embeds(repo, doc_tree);

        let tree = repo.find_tree(tree).unwrap();

        let sig = git2::Signature::new("radicle", "radicle@test", &git2::Time::new(0, 0)).unwrap();

        let oid = repo

            .commit(None, &sig, &sig, "identity root", &tree, &[])

            .unwrap();

        (oid.into(), rid)

    }

    fn write_doc_blob(repo: &git2::Repository) -> (git2::Oid, RepoId) {

        let doc_blob_oid = repo.blob(b"identity").unwrap();

        let rid = RepoId::from(Oid::from(doc_blob_oid));

        let mut tb = repo.treebuilder(None).unwrap();

        tb.insert(

            doc::PATH.as_os_str(),

            doc_blob_oid,

            git2::FileMode::Blob.into(),

        )

        .unwrap();

        let oid = tb.write().unwrap();

        (oid, rid)

    }

    fn write_embeds(repo: &git2::Repository, doc: git2::Oid) -> git2::Oid {

        let mut tb = repo.treebuilder(None).unwrap();

        tb.insert("embeds", doc, git2::FileMode::Tree.into())

            .unwrap();

        tb.write().unwrap()

    }

}

pub mod error;

mod iter;

#[cfg(test)]

mod test;

use std::collections::HashMap;

use std::num::NonZeroUsize;

use std::path::Path;

use crypto::signature;

use nonempty::NonEmpty;

use radicle_core::{NodeId, RepoId};

use radicle_git_metadata::commit::CommitData;

use radicle_oid::Oid;

use crate::git;

use crate::identity::doc;

use crate::storage::refs::sigrefs::git::{object, reference};

use crate::storage::refs::{

    Refs, IDENTITY_ROOT, REFS_BLOB_PATH, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH,

};

/// A `rad/sigrefs` that has passed the following verification checks:

///

/// - Has a valid `/signature` blob, which is verified by the signing key.

/// - Contains the `refs/rad/root` entry under `/refs`, which matches the

///   [`RepoId`] of the local repository.

/// - The `refs/rad/sigrefs-parent` entry matches the commit's parent, if the

///   entry exists.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct VerifiedCommit {

    /// The commit that was verified.

    commit: Commit,

    /// Whether verification successfully found the correct

    /// value for [`SIGREFS_PARENT`] in the refs of [`Self::commit`].

    parent: bool,

}

impl VerifiedCommit {

    /// The [`Oid`] of the commit.

    pub fn id(&self) -> &Oid {

        &self.commit.oid

    }

    /// The [`crypto::Signature`] found in the tree of the commit.

    pub fn signature(&self) -> &crypto::Signature {

        &self.commit.signature

    }

    /// The [`Refs`] found in the tree of the commit.

    pub fn into_refs(self) -> Refs {

        self.commit.refs

    }

    /// The parent [`Oid`] of the commit, unless it is the root commit.

    pub fn parent(&self) -> Option<&Oid> {

        self.commit.parent.as_ref()

    }

}

/// A [`SignedRefsReader`] reads and verifies a commit chain for a `rad/sigrefs`

/// entry.

///

/// To create a new reader, use [`SignedRefsReader::new`].

///

/// The construction expects:

/// - A [`RepoId`] which is the repository identifier of the Radicle repository.

/// - A [`Tip`] which describes where and how to start the verification.

/// - A `repository` which is the Git repository that is being used for the reading.

/// - A `verifier` which is the entity that verifies the cryptographic signatures.

pub struct SignedRefsReader<'a, R, V> {

    rid: RepoId,

    tip: Tip,

    repository: &'a R,

    verifier: &'a V,

}

/// Describe where to start a [`SignedRefsReader`]'s commit chain.

pub enum Tip {

    /// Use the namespace of the given [`NodeId`], resolving their `rad/sigrefs`

    /// to its commit [`Oid`].

    Reference(NodeId),

    /// Use the supplied commit [`Oid`].

    Commit(Oid),

}

impl<'a, R, V> SignedRefsReader<'a, R, V>

where

    R: object::Reader + reference::Reader,

    V: signature::Verifier<crypto::Signature>,

{

    /// Construct a new [`SignedRefsReader`].

    pub fn new(rid: RepoId, tip: Tip, repository: &'a R, verifier: &'a V) -> Self {

        Self {

            rid,

            tip,

            repository,

            verifier,

        }

    }

    /// Read a [`VerifiedCommit`] using the [`SignedRefsReader`].

    ///

    /// The [`VerifiedCommit`] will be the first commit, if the commit verifies

    /// and contains its parent in its [`Refs`] entry.

    /// If the commit does not contain a parent, but its signature is not

    /// repeated, then it is still returned.

    /// Otherwise, the commit that is returned is either:

    /// - The first commit which has no repeated signatures, i.e. it has no replay attacks.

    /// - The first commit which is not a replay commit, i.e. the commit that

    ///   replay attacks are based on.

    ///

    /// # Replay Attacks

    ///

    /// The [`SignedRefsReader`] prevents replay attacks via two mechanisms:

    /// - The first is recording the parent commit in the `/refs` blob. This

    ///   prevents a replay by not allowing the same signature payload to be

    ///   used in a new commit, since the parents would not match. Note that

    ///   this does not detect replays by older clients, since they will not

    ///   include this entry in `/refs`.

    /// - The second mechanism uses the fact that a replay will give duplicate

    ///   signatures. This means that any repeated signatures will be skipped,

    ///   and the commit returned will be the first valid commit, that was not a

    ///   replay.

    pub fn read(self) -> Result<VerifiedCommit, error::Read> {

        const ONE: NonZeroUsize = NonZeroUsize::new(1).expect("one is non-zero");

        const SIGNATURES_COLLECTED: &str = "all signatures were collected";

        let head = CommitReader::new(self.resolve_tip()?, self.repository)

            .read()

            .map_err(error::Read::Commit)?

            .verify(self.rid, self.verifier)

            .map_err(error::Read::Verify)?;

        #[cfg(not(debug_assertions))]

        if head.parent {

            // `head` is verified, thus we know that if the parent reference

            // exists, its target actually matches the parent OID.

            // The fact that the parent OID is a hash over all previous history

            // makes it *incredibley unlikely* or rather *practically impossible*

            // that the same `/refs` blob re-appears in previous history.

            // Thus, we can spare oureselves walking the history.

            return Ok(head);

        }

        let seen = iter::Walk::new(*head.id(), self.repository).try_fold(

            HashMap::<crypto::Signature, NonEmpty<Oid>>::new(),

            |mut seen, commit| {

                let current = commit.map_err(error::Read::Commit)?;

                seen.entry(current.signature)

                    .and_modify(|value| value.push(current.oid))

                    .or_insert_with(|| NonEmpty::new(current.oid));

                Ok(seen)

            },

        )?;

        let parent = if seen

            .get(head.signature())

            .expect(SIGNATURES_COLLECTED)

            .len_nonzero()

            == ONE

        {

            // `head` has a verified, non-repeated signature, but does not

            // include the parent reference in the `/refs` blob. Maintains

            // backwards-compatibility.

            return Ok(head);

        } else {

            #[cfg(debug_assertions)]

            {

                if head.parent {

                    panic!("duplicate signature found even though parent ref did verify")

                }

            }

            // If the signature in head was seen twice, then

            // head must have a parent.

            *head.parent().expect("parent must exist")

        };

        // The second walk can start from the parent of head. We do not need to

        // verify head twice, and we already know that the parent exists.

        let mut last = None;

        for commit in iter::Walk::new(parent, self.repository) {

            let commit = commit

                .map_err(error::Read::Commit)?

                .verify(self.rid, self.verifier)

                .map_err(error::Read::Verify)?;

            let commits = seen.get(commit.signature()).expect(SIGNATURES_COLLECTED);

            if commits.len_nonzero() == ONE {

                return Ok(commit);

            } else {

                log::warn!("Duplicate sigrefs found in commits {commits:?}");

                last = Some(commit);

            }

        }

        // In the extreme case where all commits in the walk contain duplicate

        // signatures, return the oldest commit reached — the last one visited

        // by the walk, which follows the chain from newest to oldest.

        // `last` is always `Some` here because `parent` is guaranteed to exist

        // (head had a duplicate signature, so it must have a parent), meaning

        // the walk yields at least one commit.

        Ok(last.unwrap_or(head))

    }

    fn resolve_tip(&self) -> Result<Oid, error::Read> {

        match self.tip {

            Tip::Commit(oid) => Ok(oid),

            Tip::Reference(namespace) => {

                let reference =

                    SIGREFS_BRANCH.with_namespace(git::fmt::Component::from(&namespace));

                let head = self

                    .repository

                    .find_reference(&reference)

                    .map_err(error::Read::FindReference)?

                    .ok_or_else(|| error::Read::MissingSigrefs { namespace })?;

                Ok(head)

            }

        }

    }

}

#[derive(Clone, Debug, PartialEq, Eq)]

struct Commit {

    oid: Oid,

    parent: Option<Oid>,

    refs: Refs,

    signature: crypto::Signature,

    identity_root: Option<IdentityRoot>,

}

impl Commit {

    fn verify<V>(mut self, expected: RepoId, verifier: &V) -> Result<VerifiedCommit, error::Verify>

    where

        V: signature::Verifier<crypto::Signature>,

    {

        verifier

            .verify(&self.refs.canonical(), &self.signature)

            .map_err(error::Verify::Signature)?;

        if let Some(IdentityRoot {

            commit: identity_commit,

            rid,

        }) = self.identity_root

        {

            if rid != expected {

                return Err(error::Verify::MismatchedIdentity {

                    identity_commit,

                    sigrefs_commit: self.oid,

                    expected,

                    found: rid,

                });

            } else {

                // Identity verification succeeds.

            }

        } else {

            return Err(error::Verify::MissingIdentity(error::MissingIdentity {

                sigrefs_commit: self.oid,

                expected,

            }));

        }

        self.refs.remove_sigrefs();

        let parent = match (self.parent, self.refs.remove_parent()) {

            (None, None) => true,

            (Some(_), None) => false,

            (None, Some(actual)) => {

                return Err(error::Verify::DanglingParent {

                    sigrefs_commit: self.oid,

                    actual,

                })

            }

            (Some(expected), Some(actual)) if expected == actual => true,

            (Some(expected), Some(actual)) => {

                return Err(error::Verify::MismatchedParent {

                    sigrefs_commit: self.oid,

                    expected,

                    actual,

                })

            }

        };

        Ok(VerifiedCommit {

            commit: self,

            parent,

        })

    }

}

struct CommitReader<'a, R> {

    commit: Oid,

    repository: &'a R,

}

impl<'a, R> CommitReader<'a, R>

where

    R: object::Reader,

{

    fn new(commit: Oid, repository: &'a R) -> Self {

        Self { commit, repository }

    }

    fn read(self) -> Result<Commit, error::Commit> {

        let commit = self.read_commit_data()?;

        let Tree { refs, signature } = TreeReader::new(self.commit, self.repository)

            .read()

            .map_err(error::Commit::Tree)?;

        let identity_root = IdentityRootReader::new(&refs, self.repository)

            .read()

            .map_err(error::Commit::IdentityRoot)?;

        let parent = Self::get_parent(&commit).transpose()?;

        Ok(Commit {

            oid: self.commit,

            parent,

            refs,

            signature,

            identity_root,

        })

    }

    fn read_commit_data(&self) -> Result<CommitData<Oid, Oid>, error::Commit> {

        let bytes = self

            .repository

            .read_commit(&self.commit)

            .map_err(error::Commit::Read)?

            .ok_or(error::Commit::Missing { oid: self.commit })?;

        CommitData::from_bytes(&bytes).map_err(|err| error::Commit::Parse {

            oid: self.commit,

            source: err,

        })

    }

    /// Extract the single parent [`Oid`] from a [`CommitData`], if any.

    ///

    /// Returns `None` if the commit has no parents (i.e. it is a root commit).

    /// Returns an error if the commit has more than one parent, since the

    /// transparency log is a linear chain.

    fn get_parent(commit: &CommitData<Oid, Oid>) -> Option<Result<Oid, error::Commit>> {

        let NonEmpty {

            head: parent,

            tail: mut rest,

        } = NonEmpty::collect(commit.parents())?;

        if rest.is_empty() {

            Some(Ok(parent))

        } else {

            rest.insert(0, parent);

            let err = error::Commit::TooManyParents(error::Parent { parents: rest });

            Some(Err(err))

        }

    }

}

struct Tree {

    refs: Refs,

    signature: crypto::Signature,

}

struct TreeReader<'a, R> {

    commit: Oid,

    repository: &'a R,

}

impl<'a, R> TreeReader<'a, R>

where

    R: object::Reader,

{

    fn new(commit: Oid, repository: &'a R) -> Self {

        Self { commit, repository }

    }

    fn read(self) -> Result<Tree, error::Tree> {

        let (refs, signature) = self.try_handle_blobs()?;

        let refs = Refs::from_canonical(&refs.bytes).map_err(error::Tree::ParseRefs)?;

        let signature = crypto::Signature::try_from(signature.bytes.as_slice())

            .map_err(error::Tree::ParseSignature)?;

        Ok(Tree { refs, signature })

    }

    /// Fetch the refs blob and signature blob from the repository, returning a

    /// descriptive error if either or both are missing.

    fn try_handle_blobs(&self) -> Result<(object::Blob, object::Blob), error::Tree> {

        let commit = &self.commit;

        let refs_path = Path::new(REFS_BLOB_PATH);

        let sig_path = Path::new(SIGNATURE_BLOB_PATH);

        let refs_bytes = self

            .repository

            .read_blob(commit, refs_path)

            .map_err(error::Tree::Refs)?;

        let sig_bytes = self

            .repository

            .read_blob(commit, sig_path)

            .map_err(error::Tree::Signature)?;

        let result = match (refs_bytes, sig_bytes) {

            (None, None) => Err(error::MissingBlobs::Both {

                commit: *commit,

                refs: refs_path.to_path_buf(),

                signature: sig_path.to_path_buf(),

            }),

            (None, Some(_)) => Err(error::MissingBlobs::Signature {

                commit: *commit,

                path: sig_path.to_path_buf(),

            }),

            (Some(_), None) => Err(error::MissingBlobs::Refs {

                commit: *commit,

                path: refs_path.to_path_buf(),

            }),

            (Some(refs), Some(sig)) => Ok((refs, sig)),

        };

        result.map_err(error::Tree::from)

    }

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

struct IdentityRoot {

    commit: Oid,

    rid: RepoId,

}

struct IdentityRootReader<'a, 'b, R> {

    refs: &'a Refs,

    repository: &'b R,

}

impl<'a, 'b, R> IdentityRootReader<'a, 'b, R>

where

    R: object::Reader,

{

    fn new(refs: &'a Refs, repository: &'b R) -> Self {

        Self { refs, repository }

    }

    fn read(self) -> Result<Option<IdentityRoot>, error::IdentityRoot> {

        match self.refs.get(&IDENTITY_ROOT) {

            Some(commit) => self

                .read_blob(&commit)

                .map(|rid| Some(IdentityRoot { commit, rid })),

            None => Ok(None),

        }

    }

    fn read_blob(&self, commit: &Oid) -> Result<RepoId, error::IdentityRoot> {

        let path = Path::new("embeds").join(*doc::PATH);

        let object::Blob { oid, .. } = self

            .repository

            .read_blob(commit, &path)

            .map_err(error::IdentityRoot::Blob)?

            .ok_or_else(|| error::IdentityRoot::MissingIdentity { commit: *commit })?;

        Ok(RepoId::from(oid))

    }

}

use std::fmt;

use std::path::PathBuf;

use radicle_core::{NodeId, RepoId};

use radicle_git_metadata::commit;

use radicle_oid::Oid;