use embark_crypt::gen_key_nonce;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
struct Rng {
state: u64,
}
impl Rng {
fn new() -> Self {
let (key, nonce) = gen_key_nonce();
let mut state: u64 = 0x9E37_79B9_7F4A_7C15;
let mut mix = |bytes: &[u8]| {
for chunk in bytes.chunks(8) {
let mut b = [0u8; 8];
b[..chunk.len()].copy_from_slice(chunk);
state ^= u64::from_le_bytes(b);
state = state.rotate_left(13).wrapping_mul(0x2545_F491_4F6C_DD1D);
}
};
mix(&key);
mix(&nonce);
Rng { state }
}
fn next_u64(&mut self) -> u64 {
self.state = self.state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
fn below(&mut self, n: u32) -> u32 {
(self.next_u64() % n as u64) as u32
}
fn range_incl(&mut self, lo: u32, hi: u32) -> u32 {
lo + self.below(hi - lo + 1)
}
fn byte(&mut self) -> u8 {
(self.next_u64() >> 24) as u8
}
fn arr32(&mut self) -> [u8; 32] {
let mut a = [0u8; 32];
for x in a.iter_mut() {
*x = self.byte();
}
a
}
fn perm(&mut self) -> [u8; 32] {
let mut p = [0u8; 32];
for (i, slot) in p.iter_mut().enumerate() {
*slot = i as u8;
}
for i in (1..32).rev() {
let j = self.below(i as u32 + 1) as usize;
p.swap(i, j);
}
p
}
}
#[derive(Clone)]
enum Op {
Xor([u8; 32]),
Add([u8; 32]),
Rotl(u32),
Perm([u8; 32]),
Reverse,
}
impl Op {
fn random(rng: &mut Rng) -> Op {
match rng.below(5) {
0 => Op::Xor(rng.arr32()),
1 => Op::Add(rng.arr32()),
2 => Op::Rotl(rng.range_incl(1, 7)),
3 => Op::Perm(rng.perm()),
_ => Op::Reverse,
}
}
}
fn inverse_perm(p: &[u8; 32]) -> [u8; 32] {
let mut inv = [0u8; 32];
for (i, &pi) in p.iter().enumerate() {
inv[pi as usize] = i as u8;
}
inv
}
#[cfg(test)]
fn apply_forward(op: &Op, a: &mut [u8; 32]) {
match op {
Op::Xor(c) => {
for i in 0..32 {
a[i] ^= c[i];
}
}
Op::Add(c) => {
for i in 0..32 {
a[i] = a[i].wrapping_add(c[i]);
}
}
Op::Rotl(k) => {
for x in a.iter_mut() {
*x = x.rotate_left(*k);
}
}
Op::Perm(p) => {
let t = *a;
for i in 0..32 {
a[i] = t[p[i] as usize];
}
}
Op::Reverse => {
let t = *a;
for i in 0..32 {
a[i] = t[31 - i];
}
}
}
}
fn apply_inverse(op: &Op, a: &mut [u8; 32]) {
match op {
Op::Xor(c) => {
for i in 0..32 {
a[i] ^= c[i];
}
}
Op::Add(c) => {
for i in 0..32 {
a[i] = a[i].wrapping_sub(c[i]);
}
}
Op::Rotl(k) => {
for x in a.iter_mut() {
*x = x.rotate_right(*k);
}
}
Op::Perm(p) => {
let inv = inverse_perm(p);
let t = *a;
for i in 0..32 {
a[i] = t[inv[i] as usize];
}
}
Op::Reverse => {
let t = *a;
for i in 0..32 {
a[i] = t[31 - i];
}
}
}
}
fn seed_of(key: [u8; 32], program: &[Op]) -> [u8; 32] {
let mut a = key;
for op in program.iter().rev() {
apply_inverse(op, &mut a);
}
a
}
fn byte_lit(b: u8) -> TokenStream {
quote!(#b)
}
fn idx_lit(i: usize) -> TokenStream {
let lit = proc_macro2::Literal::usize_unsuffixed(i);
quote!(#lit)
}
fn emit_forward(op: &Op, slot: usize, out: &mut Vec<TokenStream>) {
match op {
Op::Xor(c) => {
for (i, &ci) in c.iter().enumerate() {
let (i, ci) = (idx_lit(i), byte_lit(ci));
out.push(quote!(a[#i] ^= #ci;));
}
}
Op::Add(c) => {
for (i, &ci) in c.iter().enumerate() {
let (i, ci) = (idx_lit(i), byte_lit(ci));
out.push(quote!(a[#i] = a[#i].wrapping_add(#ci);));
}
}
Op::Rotl(k) => {
for i in 0..32 {
let i = idx_lit(i);
out.push(quote!(a[#i] = a[#i].rotate_left(#k);));
}
}
Op::Perm(p) => {
let t = format_ident!("t{}", slot);
out.push(quote!(let #t = a;));
for (i, &pi) in p.iter().enumerate() {
let (i, pi) = (idx_lit(i), idx_lit(pi as usize));
out.push(quote!(a[#i] = #t[#pi];));
}
}
Op::Reverse => {
let t = format_ident!("t{}", slot);
out.push(quote!(let #t = a;));
for i in 0..32 {
let (i, r) = (idx_lit(i), idx_lit(31 - i));
out.push(quote!(a[#i] = #t[#r];));
}
}
}
}
struct Plan {
program: Vec<Op>,
shares: Vec<[u8; 32]>,
decoys: Vec<[u8; 32]>,
}
fn plan(rng: &mut Rng, key: [u8; 32]) -> Plan {
let m = rng.range_incl(8, 20);
let program: Vec<Op> = (0..m).map(|_| Op::random(rng)).collect();
let s0 = seed_of(key, &program);
let nshares = rng.range_incl(2, 3) as usize;
let mut shares: Vec<[u8; 32]> = (0..nshares - 1).map(|_| rng.arr32()).collect();
let mut last = s0;
for sh in &shares {
for i in 0..32 {
last[i] ^= sh[i];
}
}
shares.push(last);
let ndecoys = rng.range_incl(0, 2) as usize;
let decoys: Vec<[u8; 32]> = (0..ndecoys).map(|_| rng.arr32()).collect();
Plan {
program,
shares,
decoys,
}
}
pub(crate) fn emit_key_recon(key: [u8; 32]) -> (TokenStream, syn::Ident) {
let mut rng = Rng::new();
let Plan {
program,
shares,
decoys,
} = plan(&mut rng, key);
let name = format_ident!("__embark_recon_{:016x}", rng.next_u64());
let mut stmts: Vec<TokenStream> = Vec::new();
let share_idents: Vec<syn::Ident> =
(0..shares.len()).map(|j| format_ident!("s{}", j)).collect();
for (ident, share) in share_idents.iter().zip(&shares) {
let lits = share.iter().map(|&b| byte_lit(b));
stmts.push(quote! {
let #ident: [u8; 32] = ::core::hint::black_box([#(#lits),*]);
});
}
stmts.push(quote!(let mut a: [u8; 32] = [0u8; 32];));
for i in 0..32 {
let i = idx_lit(i);
let terms = share_idents.iter().map(|s| quote!(#s[#i]));
stmts.push(quote!(a[#i] = #(#terms)^*;));
}
for d in &decoys {
for pass in 0..2 {
let _ = pass;
for (i, &di) in d.iter().enumerate() {
let (i, di) = (idx_lit(i), byte_lit(di));
stmts.push(quote!(a[#i] ^= #di;));
}
}
}
for (slot, op) in program.iter().enumerate() {
emit_forward(op, slot, &mut stmts);
}
let item = quote! {
#[allow(clippy::all)]
fn #name() -> [u8; 32] {
#(#stmts)*
a
}
};
(item, name)
}
#[cfg(test)]
mod tests {
use super::*;
fn rng() -> Rng {
Rng::new()
}
#[test]
fn inverse_perm_is_correct() {
let mut r = rng();
for _ in 0..1000 {
let p = r.perm();
let inv = inverse_perm(&p);
let mut seen = [false; 32];
for &pi in &p {
assert!(!seen[pi as usize], "p is not a permutation");
seen[pi as usize] = true;
}
let a = r.arr32();
let mut b = a;
apply_forward(&Op::Perm(p), &mut b);
apply_forward(&Op::Perm(inv), &mut b);
assert_eq!(a, b, "Perm(p) then Perm(inv_p) must be identity");
}
}
#[test]
fn each_op_forward_then_inverse_is_identity() {
let mut r = rng();
for _ in 0..2000 {
let ops = [
Op::Xor(r.arr32()),
Op::Add(r.arr32()),
Op::Rotl(r.range_incl(1, 7)),
Op::Perm(r.perm()),
Op::Reverse,
];
for op in &ops {
let a = r.arr32();
let mut b = a;
apply_forward(op, &mut b);
apply_inverse(op, &mut b);
assert_eq!(a, b, "forward then inverse must be identity");
let mut c = a;
apply_inverse(op, &mut c);
apply_forward(op, &mut c);
assert_eq!(a, c, "inverse then forward must be identity");
}
}
}
#[test]
fn forward_of_seed_recovers_key() {
let mut r = rng();
for _ in 0..5000 {
let key = r.arr32();
let m = r.range_incl(8, 20);
let program: Vec<Op> = (0..m).map(|_| Op::random(&mut r)).collect();
let s0 = seed_of(key, &program);
let mut a = s0;
for op in &program {
apply_forward(op, &mut a);
}
assert_eq!(a, key, "F(F^-1(key)) must equal key");
}
}
#[test]
fn shares_xor_to_seed() {
let mut r = rng();
for _ in 0..2000 {
let key = r.arr32();
let p = plan(&mut r, key);
let s0 = seed_of(key, &p.program);
let mut acc = [0u8; 32];
for sh in &p.shares {
for i in 0..32 {
acc[i] ^= sh[i];
}
}
assert_eq!(acc, s0, "shares must XOR to S0");
assert!(
p.shares.len() >= 2 && p.shares.len() <= 3,
"expected 2–3 shares"
);
}
}
#[test]
fn emitted_reconstructions_vary_per_build() {
let key = [0x42u8; 32];
let (a_tokens, a_name) = emit_key_recon(key);
let (b_tokens, b_name) = emit_key_recon(key);
assert_ne!(
a_name.to_string(),
b_name.to_string(),
"fn names must differ per build"
);
assert_ne!(
a_tokens.to_string(),
b_tokens.to_string(),
"emitted reconstructions for the same key must differ per build"
);
}
}