use core::{ops::Deref as _, convert::AsRef};
use alloc::{boxed::Box, vec::Vec, vec};
use zeroize::Zeroizing;
use rand::rngs::OsRng;
use blake2::{
digest::{Digest as _, CustomizedInit as _},
Blake2b512,
};
use ciphersuite::{
group::{ff::{PrimeField, FromUniformBytes as _}, GroupEncoding},
Ciphersuite,
};
use dalek_ff_group::Ristretto;
use schnorr::{
SchnorrSignature,
aggregate::{SchnorrAggregator, SchnorrAggregate},
};
use borsh::{
io::{self, Read, Write},
BorshSerialize, BorshDeserialize,
};
use tendermint::InvalidAggregateSignature;
const AGGREGATOR_DST: &[u8] = b"Tributary Tendermint Commit Aggregator";
#[derive(Clone)]
struct MessageScopedTranscript(Blake2b512);
impl MessageScopedTranscript {
fn challenge(self, key: [u8; 32], nonce: &[u8]) -> <Ristretto as Ciphersuite>::F {
<Ristretto as Ciphersuite>::F::from_uniform_bytes(
&self.0.chain_update(key).chain_update(nonce).finalize().into(),
)
}
}
#[test]
fn message_scoped_transcript() {
let transcript = MessageScopedTranscript(Blake2b512::new());
let rand_bytes = || {
use rand::RngCore as _;
let mut bytes = [0; 32];
rand::rngs::OsRng.fill_bytes(&mut bytes);
bytes
};
let key_a = rand_bytes();
let key_b = rand_bytes();
let nonce_a = rand_bytes();
let nonce_b = rand_bytes();
assert_eq!(
transcript.clone().challenge(key_a, &nonce_a),
transcript.clone().challenge(key_a, &nonce_a)
);
assert_ne!(
transcript.clone().challenge(key_a, &nonce_a),
transcript.clone().challenge(key_b, &nonce_a)
);
assert_ne!(
transcript.clone().challenge(key_a, &nonce_a),
transcript.clone().challenge(key_a, &nonce_b)
);
assert_ne!(
transcript.clone().challenge(key_a, &nonce_a),
transcript.clone().challenge(key_b, &nonce_b)
);
}
#[derive(Clone)]
pub(crate) struct SignatureScheme {
genesis_scoped_transcript: Blake2b512,
validators: usize,
}
#[derive(Clone)]
pub(crate) struct Signer {
signature_scheme: SignatureScheme,
private_key: Zeroizing<<Ristretto as Ciphersuite>::F>,
public_key: [u8; 32],
}
impl SignatureScheme {
pub(crate) fn new(genesis: [u8; 32], validators: usize) -> Self {
Self {
genesis_scoped_transcript: Blake2b512::new_customized(b"tendermint").chain_update(genesis),
validators,
}
}
pub(crate) fn signer(&self, private_key: Zeroizing<<Ristretto as Ciphersuite>::F>) -> Signer {
let public_key = (Ristretto::generator() * private_key.deref()).to_bytes();
Signer { signature_scheme: self.clone(), private_key, public_key }
}
fn message_scope(
&self,
message: impl IntoIterator<Item: AsRef<[u8]>>,
) -> MessageScopedTranscript {
let mut transcript = self.genesis_scoped_transcript.clone();
for message_part in message {
transcript.update(message_part);
}
MessageScopedTranscript(transcript)
}
}
#[test]
fn genesis_scoped_transcript() {
let rand_scheme = || {
use rand::RngCore as _;
let mut bytes = [0; 32];
rand::rngs::OsRng.fill_bytes(&mut bytes);
SignatureScheme::new(bytes, 1)
};
let scheme = rand_scheme();
assert_ne!(
scheme.genesis_scoped_transcript.clone().finalize(),
rand_scheme().genesis_scoped_transcript.finalize()
);
assert_eq!(
scheme.message_scope([*b"a", *b"b"]).0.finalize(),
scheme.message_scope([b"ab"]).0.finalize()
);
assert_ne!(scheme.message_scope([b"a"]).0.finalize(), scheme.message_scope([b"b"]).0.finalize());
}
#[derive(Clone)]
#[cfg_attr(test, derive(PartialEq, Eq, Debug))]
pub struct AggregateSignature(Box<[u8]>);
impl AsRef<[u8]> for AggregateSignature {
fn as_ref(&self) -> &[u8] {
self.0.as_ref()
}
}
impl AggregateSignature {
fn validators(&self) -> usize {
#[expect(clippy::manual_assert)]
const {
if core::mem::size_of::<<<Ristretto as Ciphersuite>::G as GroupEncoding>::Repr>() != 32 {
panic!("(memory) representation of a Ristretto point's encoding wasn't 32 bytes")
}
if core::mem::size_of::<<<Ristretto as Ciphersuite>::F as PrimeField>::Repr>() != 32 {
panic!("(memory) representation of a Ristretto scalar's encoding wasn't 32 bytes")
}
}
let validators = (self.0.len() - 32) / (32 + 32);
debug_assert_eq!((validators * (32 + 32)) + 32, self.0.len());
validators
}
}
impl BorshSerialize for AggregateSignature {
fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), io::Error> {
writer.write_all(
&u16::try_from(self.validators())
.map_err(|_| {
io::Error::other("aggregate signature has more validators than possible weight")
})?
.to_le_bytes(),
)?;
writer.write_all(&self.0)
}
}
impl BorshDeserialize for AggregateSignature {
fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, io::Error> {
let validators = {
let mut bytes = [0; 2];
reader.read_exact(&mut bytes)?;
u16::from_le_bytes(bytes)
};
let len =
usize::from(validators).checked_mul(32 + 32).and_then(|len| len.checked_add(32)).ok_or_else(
|| io::Error::other("length of aggregate signature overflowed platform's `usize`"),
)?;
let mut result = vec![0; len].into_boxed_slice();
reader.read_exact(&mut result)?;
Ok(Self(result))
}
}
impl tendermint::SignatureScheme for SignatureScheme {
type Validator = [u8; 32];
type Signature = [u8; 64];
type AggregateSignature = AggregateSignature;
fn verify(
&self,
validator: &Self::Validator,
message: impl IntoIterator<Item = impl AsRef<[u8]>>,
signature: &Self::Signature,
) -> bool {
let challenge = self.message_scope(message).challenge(*validator, &signature[.. 32]);
let Ok(validator) = Ristretto::read_G(&mut validator.as_slice()) else {
return false;
};
let Ok(signature) = SchnorrSignature::<Ristretto>::read(signature.as_slice()) else {
return false;
};
signature.verify(validator, challenge)
}
fn aggregate<'sig>(
&self,
message: impl IntoIterator<Item = impl AsRef<[u8]>>,
signatures: impl IntoIterator<Item = (&'sig Self::Validator, &'sig Self::Signature)>,
) -> Self::AggregateSignature
where
Self::Validator: 'sig,
Self::Signature: 'sig,
{
let transcript = self.message_scope(message);
let signatures = signatures.into_iter();
let sorted = {
let mut sorted = Vec::with_capacity({
let (lower, _upper) = signatures.size_hint();
lower
});
for signature in signatures {
sorted.push(signature);
}
sorted.sort_by_key(|(validator, _signature)| **validator);
sorted
};
let mut result = Vec::with_capacity((sorted.len() * (32 + 32)) + 32);
let mut aggregator = SchnorrAggregator::<Ristretto>::new(AGGREGATOR_DST);
for (validator, signature) in sorted {
result.write_all(validator).expect("`<Vec<_> as io::Write>` is infallible");
let challenge = transcript.clone().challenge(*validator, &signature[.. 32]);
let signature = SchnorrSignature::<Ristretto>::read(signature.as_slice())
.expect("asked to aggregate an invalid signature");
aggregator.aggregate(challenge, signature);
}
let aggregate = aggregator.complete().expect("asked to aggregate no signatures");
aggregate.write(&mut result).expect("`<Vec<_> as io::Write>` is infallible");
AggregateSignature(result.into_boxed_slice())
}
fn verify_aggregate(
&self,
message: impl IntoIterator<Item = impl AsRef<[u8]>>,
aggregate_signature: &Self::AggregateSignature,
) -> Result<impl IntoIterator<Item = Self::Validator>, InvalidAggregateSignature> {
let transcript = self.message_scope(message);
let (validators, aggregate_signature) = {
let validators_len = aggregate_signature.validators();
if validators_len > self.validators {
Err(InvalidAggregateSignature)?;
}
let aggregate_signature = aggregate_signature.as_ref();
let (validators, mut aggregate_signature) = aggregate_signature.split_at(validators_len * 32);
let (validators, []) = validators.as_chunks::<32>() else {
panic!("multiple of `32` wasn't evenly divisible into chunks of length `32`")
};
if !validators.is_sorted_by(|a, b| a < b) {
Err(InvalidAggregateSignature)?;
}
let aggregate_signature = {
let Ok(aggregate_signature_value) =
SchnorrAggregate::<Ristretto>::read(&mut aggregate_signature, validators_len)
else {
Err(InvalidAggregateSignature)?
};
debug_assert_eq!(aggregate_signature, &[]);
aggregate_signature_value
};
(validators, aggregate_signature)
};
let mut challenges = vec![];
for (validator, nonce) in validators.iter().zip(aggregate_signature.Rs()) {
let challenge = transcript.clone().challenge(*validator, nonce.to_bytes().as_ref());
let Ok(validator) = <Ristretto as Ciphersuite>::read_G(&mut validator.as_slice()) else {
Err(InvalidAggregateSignature)?
};
challenges.push((validator, challenge));
}
if !aggregate_signature.verify(AGGREGATOR_DST, &challenges) {
Err(InvalidAggregateSignature)?;
}
Ok(validators.iter().copied())
}
}
impl tendermint::Signer for Signer {
type Validator = [u8; 32];
type Signature = [u8; 64];
fn validator(&self) -> Self::Validator {
self.public_key
}
type SignFuture = core::future::Ready<Self::Signature>;
fn sign(&self, message: impl IntoIterator<Item = impl AsRef<[u8]>>) -> Self::SignFuture {
let transcript = self.signature_scheme.message_scope(message);
let nonce = Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng));
let challenge = transcript
.challenge(self.public_key, (Ristretto::generator() * nonce.deref()).to_bytes().as_ref());
let signature = SchnorrSignature::<Ristretto>::sign(&self.private_key, nonce, challenge);
core::future::ready(crate::fixed_write::<{ 32 + 32 }>(|writer| signature.write(writer)))
}
}
#[cfg(test)]
#[tokio::test]
async fn sign() {
use ::tendermint::{SignatureScheme as _, Signer as _};
let genesis = [0xfe; 32];
let signature_scheme = SignatureScheme::new(genesis, 4);
let key = Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng));
let signer = signature_scheme.signer(key);
const MESSAGE: [&[u8]; 1] = [b"abc"];
const OTHER_MESSAGE: [&[u8]; 1] = [b"def"];
let signature = signer.sign(MESSAGE).await;
assert!(signature_scheme.verify(&signer.validator(), MESSAGE, &signature));
assert!(!signature_scheme.verify(&signer.validator(), OTHER_MESSAGE, &signature));
}
#[cfg(test)]
#[tokio::test]
async fn aggregate() {
use ::tendermint::{SignatureScheme as _, Signer as _};
let genesis = [0xfe; 32];
let signature_scheme = SignatureScheme::new(genesis, 4);
let alice =
signature_scheme.signer(Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng)));
let bob =
signature_scheme.signer(Zeroizing::new(<Ristretto as Ciphersuite>::F::random(&mut OsRng)));
const MESSAGE: [&[u8]; 1] = [b"abc"];
const OTHER_MESSAGE: [&[u8]; 1] = [b"def"];
let test = async move |signature_scheme: &SignatureScheme, signers: &[&Signer]| {
let mut aggregate = vec![];
for signer in signers {
aggregate.push((signer.validator(), signer.sign(MESSAGE).await));
}
let aggregate = signature_scheme
.aggregate(MESSAGE, aggregate.iter().map(|(signer, signature)| (signer, signature)));
assert_eq!(aggregate.validators(), signers.len());
{
let deserialized_aggregate = {
let aggregate = borsh::to_vec(&aggregate).unwrap();
let mut aggregate = aggregate.as_slice();
let deserialized_aggregate =
AggregateSignature::deserialize_reader(&mut aggregate).unwrap();
assert_eq!(aggregate, []);
deserialized_aggregate
};
assert_eq!(aggregate, deserialized_aggregate);
}
let mut validators = signers.iter().copied().map(Signer::validator).collect::<Vec<_>>();
validators.sort_unstable();
assert_eq!(
signature_scheme
.verify_aggregate(MESSAGE, &aggregate)
.unwrap()
.into_iter()
.collect::<Vec<_>>(),
validators
);
assert!(signature_scheme.verify_aggregate(OTHER_MESSAGE, &aggregate).is_err());
};
test(&signature_scheme, &[&alice]).await;
test(&signature_scheme, &[&bob]).await;
test(&signature_scheme, &[&alice, &bob]).await;
}