absolutebi/serai
1
0
Fork 0
mirror of https://github.com/serai-dex/serai.git synced 2025-12-09 04:39:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Consolidate concise/efficient and clean

Browse Source
This commit is contained in:
Luke Parker
2022-07-07 07:30:10 -04:00
parent 7d80b6e854
commit 1a2e6dc5cf
13 changed files with 458 additions and 663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
crypto/dleq/src/tests/cross_group/linear/aos.rs → crypto/dleq/src/tests/cross_group/aos.rs
View File

@@ -5,7 +5,7 @@ use group::{ff::Field, Group};
use multiexp::BatchVerifier;
use crate::{
cross_group::linear::aos::{Re, Aos},
cross_group::aos::{Re, Aos},
tests::cross_group::{G0, G1, transcript, generators}
};
@@ -21,6 +21,8 @@ fn test_aos<const RING_LEN: usize>(default: Re<G0, G1>) {
let generators = generators();
let mut ring_keys = [(<G0 as Group>::Scalar::zero(), <G1 as Group>::Scalar::zero()); RING_LEN];
// Side-effect of G0 being a type-alias with identity() deprecated
#[allow(deprecated)]
let mut ring = [(G0::identity(), G1::identity()); RING_LEN];
for i in 0 .. RING_LEN {
ring_keys[i] = (
@@ -58,6 +60,7 @@ fn test_aos_e() {
test_aos::<4>(Re::e_default());
}
#[allow(non_snake_case)]
#[test]
fn test_aos_R() {
// Batch verification appreciates the longer vectors, which means not batching bits

98
crypto/dleq/src/tests/cross_group/linear/concise.rs
View File

@@ -1,98 +0,0 @@
use rand_core::{RngCore, OsRng};
use ff::{Field, PrimeField};
use k256::Scalar;
#[cfg(feature = "serialize")]
use k256::ProjectivePoint;
#[cfg(feature = "serialize")]
use dalek_ff_group::EdwardsPoint;
use blake2::{Digest, Blake2b512};
use crate::{
cross_group::{scalar::mutual_scalar_from_bytes, linear::ConciseDLEq},
tests::cross_group::{transcript, generators}
};
#[test]
fn test_linear_concise_cross_group_dleq() {
let generators = generators();
for i in 0 .. 1 {
let (proof, keys) = if i == 0 {
let mut seed = [0; 32];
OsRng.fill_bytes(&mut seed);
ConciseDLEq::prove(
&mut OsRng,
&mut transcript(),
generators,
Blake2b512::new().chain_update(seed)
)
} else {
let mut key;
let mut res;
while {
key = Scalar::random(&mut OsRng);
res = ConciseDLEq::prove_without_bias(
&mut OsRng,
&mut transcript(),
generators,
key
);
res.is_none()
} {}
let res = res.unwrap();
assert_eq!(key, res.1.0);
res
};
let public_keys = proof.verify(&mut OsRng, &mut transcript(), generators).unwrap();
assert_eq!(generators.0.primary * keys.0, public_keys.0);
assert_eq!(generators.1.primary * keys.1, public_keys.1);
#[cfg(feature = "serialize")]
{
let mut buf = vec![];
proof.serialize(&mut buf).unwrap();
let deserialized = ConciseDLEq::<ProjectivePoint, EdwardsPoint>::deserialize(
&mut std::io::Cursor::new(&buf)
).unwrap();
assert_eq!(proof, deserialized);
deserialized.verify(&mut OsRng, &mut transcript(), generators).unwrap();
}
}
}
#[test]
fn test_remainder() {
// Uses Secp256k1 for both to achieve an odd capacity of 255
assert_eq!(Scalar::CAPACITY, 255);
let generators = (generators().0, generators().0);
let keys = mutual_scalar_from_bytes(&[0xFF; 32]);
assert_eq!(keys.0, keys.1);
let (proof, res) = ConciseDLEq::prove_without_bias(
&mut OsRng,
&mut transcript(),
generators,
keys.0
).unwrap();
assert_eq!(keys, res);
let public_keys = proof.verify(&mut OsRng, &mut transcript(), generators).unwrap();
assert_eq!(generators.0.primary * keys.0, public_keys.0);
assert_eq!(generators.1.primary * keys.1, public_keys.1);
#[cfg(feature = "serialize")]
{
let mut buf = vec![];
proof.serialize(&mut buf).unwrap();
let deserialized = ConciseDLEq::<ProjectivePoint, ProjectivePoint>::deserialize(
&mut std::io::Cursor::new(&buf)
).unwrap();
assert_eq!(proof, deserialized);
deserialized.verify(&mut OsRng, &mut transcript(), generators).unwrap();
}
}

66
crypto/dleq/src/tests/cross_group/linear/efficient.rs
View File

@@ -1,66 +0,0 @@
use rand_core::{RngCore, OsRng};
use ff::Field;
use k256::Scalar;
#[cfg(feature = "serialize")]
use k256::ProjectivePoint;
#[cfg(feature = "serialize")]
use dalek_ff_group::EdwardsPoint;
use blake2::{Digest, Blake2b512};
use crate::{
cross_group::linear::EfficientDLEq,
tests::cross_group::{transcript, generators}
};
#[test]
fn test_linear_efficient_cross_group_dleq() {
let generators = generators();
for i in 0 .. 1 {
let (proof, keys) = if i == 0 {
let mut seed = [0; 32];
OsRng.fill_bytes(&mut seed);
EfficientDLEq::prove(
&mut OsRng,
&mut transcript(),
generators,
Blake2b512::new().chain_update(seed)
)
} else {
let mut key;
let mut res;
while {
key = Scalar::random(&mut OsRng);
res = EfficientDLEq::prove_without_bias(
&mut OsRng,
&mut transcript(),
generators,
key
);
res.is_none()
} {}
let res = res.unwrap();
assert_eq!(key, res.1.0);
res
};
let public_keys = proof.verify(&mut OsRng, &mut transcript(), generators).unwrap();
assert_eq!(generators.0.primary * keys.0, public_keys.0);
assert_eq!(generators.1.primary * keys.1, public_keys.1);
#[cfg(feature = "serialize")]
{
let mut buf = vec![];
proof.serialize(&mut buf).unwrap();
let deserialized = EfficientDLEq::<ProjectivePoint, EdwardsPoint>::deserialize(
&mut std::io::Cursor::new(&buf)
).unwrap();
assert_eq!(proof, deserialized);
deserialized.verify(&mut OsRng, &mut transcript(), generators).unwrap();
}
}
}

2
crypto/dleq/src/tests/cross_group/linear/mod.rs
View File

@@ -1,2 +0,0 @@
mod concise;
mod efficient;

105
crypto/dleq/src/tests/cross_group/mod.rs
View File

@@ -1,26 +1,33 @@
mod scalar;
mod schnorr;
use hex_literal::hex;
use rand_core::OsRng;
use rand_core::{RngCore, OsRng};
use ff::{Field, PrimeField};
use group::{Group, GroupEncoding};
use blake2::{Digest, Blake2b512};
use k256::{Scalar, ProjectivePoint};
use dalek_ff_group::{self as dfg, EdwardsPoint, CompressedEdwardsY};
use transcript::RecommendedTranscript;
use crate::{Generators, cross_group::linear::EfficientDLEq};
use crate::{
Generators,
cross_group::{scalar::mutual_scalar_from_bytes, EfficientLinearDLEq, ConciseLinearDLEq}
};
mod linear;
mod scalar;
mod schnorr;
mod aos;
type G0 = ProjectivePoint;
type G1 = EdwardsPoint;
pub(crate) fn transcript() -> RecommendedTranscript {
RecommendedTranscript::new(b"Cross-Group DLEq Proof Test")
}
pub(crate) fn generators() -> (Generators<ProjectivePoint>, Generators<EdwardsPoint>) {
pub(crate) fn generators() -> (Generators<G0>, Generators<G1>) {
(
Generators::new(
ProjectivePoint::GENERATOR,
@@ -38,6 +45,66 @@ pub(crate) fn generators() -> (Generators<ProjectivePoint>, Generators<EdwardsPo
)
}
macro_rules! verify_and_deserialize {
($type: ident, $proof: ident, $generators: ident, $keys: ident) => {
let public_keys = $proof.verify(&mut OsRng, &mut transcript(), $generators).unwrap();
assert_eq!($generators.0.primary * $keys.0, public_keys.0);
assert_eq!($generators.1.primary * $keys.1, public_keys.1);
#[cfg(feature = "serialize")]
{
let mut buf = vec![];
$proof.serialize(&mut buf).unwrap();
let deserialized = $type::<G0, G1>::deserialize(&mut std::io::Cursor::new(&buf)).unwrap();
assert_eq!(proof, deserialized);
}
}
}
macro_rules! test_dleq {
($name: ident, $type: ident) => {
#[test]
fn $name() {
let generators = generators();
for i in 0 .. 1 {
let (proof, keys) = if i == 0 {
let mut seed = [0; 32];
OsRng.fill_bytes(&mut seed);
$type::prove(
&mut OsRng,
&mut transcript(),
generators,
Blake2b512::new().chain_update(seed)
)
} else {
let mut key;
let mut res;
while {
key = Scalar::random(&mut OsRng);
res = $type::prove_without_bias(
&mut OsRng,
&mut transcript(),
generators,
key
);
res.is_none()
} {}
let res = res.unwrap();
assert_eq!(key, res.1.0);
res
};
verify_and_deserialize!($type, proof, generators, keys);
}
}
}
}
test_dleq!(test_efficient_linear_dleq, EfficientLinearDLEq);
test_dleq!(test_concise_linear_dleq, ConciseLinearDLEq);
#[test]
fn test_rejection_sampling() {
let mut pow_2 = Scalar::one();
@@ -46,7 +113,8 @@ fn test_rejection_sampling() {
}
assert!(
EfficientDLEq::prove_without_bias(
// Either would work
EfficientLinearDLEq::prove_without_bias(
&mut OsRng,
&mut RecommendedTranscript::new(b""),
generators(),
@@ -54,3 +122,24 @@ fn test_rejection_sampling() {
).is_none()
);
}
#[test]
fn test_remainder() {
// Uses Secp256k1 for both to achieve an odd capacity of 255
assert_eq!(Scalar::CAPACITY, 255);
let generators = (generators().0, generators().0);
// This will ignore any unused bits, ensuring every remaining one is set
let keys = mutual_scalar_from_bytes(&[0xFF; 32]);
assert_eq!(keys.0 + Scalar::one(), Scalar::from(2u64).pow_vartime(&[255]));
assert_eq!(keys.0, keys.1);
let (proof, res) = ConciseLinearDLEq::prove_without_bias(
&mut OsRng,
&mut transcript(),
generators,
keys.0
).unwrap();
assert_eq!(keys, res);
verify_and_deserialize!(ConciseLinearDLEq, proof, generators, keys);
}

25
crypto/dleq/src/tests/cross_group/schnorr.rs
View File

@@ -1,23 +1,30 @@
use rand_core::OsRng;
use group::{ff::Field, prime::PrimeGroup};
use group::{ff::{Field, PrimeFieldBits}, prime::PrimeGroup};
use multiexp::BatchVerifier;
use transcript::RecommendedTranscript;
use crate::cross_group::schnorr::SchnorrPoK;
fn test_schnorr<G: PrimeGroup>() {
fn test_schnorr<G: PrimeGroup>() where G::Scalar: PrimeFieldBits {
let private = G::Scalar::random(&mut OsRng);
let transcript = RecommendedTranscript::new(b"Schnorr Test");
assert!(
SchnorrPoK::prove(
&mut OsRng,
&mut transcript.clone(),
G::generator(),
private
).verify(&mut transcript.clone(), G::generator(), G::generator() * private)
let mut batch = BatchVerifier::new(3);
SchnorrPoK::prove(
&mut OsRng,
&mut transcript.clone(),
G::generator(),
private
).verify(
&mut OsRng,
&mut transcript.clone(),
G::generator(),
G::generator() * private,
&mut batch
);
assert!(batch.verify_vartime());
}
#[test]