pub const WIDTH_BITS: u32 = 40;
pub const ROUNDS: usize = 6;
pub const MAX_ID: u64 = (1u64 << WIDTH_BITS) - 1;
const GOLDEN: u64 = 0x9E37_79B9_7F4A_7C15;
#[inline]
fn subkey(key: u64, round: usize) -> u32 {
let x = key.rotate_left((round as u32) * 7 + 1) ^ GOLDEN.wrapping_mul(round as u64 + 1);
(x as u32).wrapping_add((x >> 32) as u32)
}
#[inline]
fn round_fn(r: u32, key: u64, round: usize, half_bits: u32) -> u32 {
let mask = (1u32 << half_bits) - 1;
let rk = subkey(key, round);
let mut x = r.wrapping_add(rk);
x ^= x.rotate_left(7);
x = x.wrapping_add(x.rotate_left(13));
x ^= x.rotate_left(17);
x & mask
}
#[inline]
pub fn feistel_n(input: u64, key: u64, rounds: usize, width: u32) -> u64 {
let half = width / 2;
let mask = (1u64 << half) - 1;
let mut l = ((input >> half) & mask) as u32;
let mut r = (input & mask) as u32;
for round in 0..rounds {
let f = round_fn(r, key, round, half);
let new_l = r;
let new_r = l ^ f;
l = new_l;
r = new_r;
}
((l as u64) << half) | (r as u64)
}
#[inline]
pub fn feistel_n_inv(input: u64, key: u64, rounds: usize, width: u32) -> u64 {
let half = width / 2;
let mask = (1u64 << half) - 1;
let mut l = ((input >> half) & mask) as u32;
let mut r = (input & mask) as u32;
for round in (0..rounds).rev() {
let r_prev = l;
let f = round_fn(r_prev, key, round, half);
let l_prev = r ^ f;
l = l_prev;
r = r_prev;
}
((l as u64) << half) | (r as u64)
}
pub fn obfuscate(id: u64, key: u64) -> u64 {
feistel_n(id & MAX_ID, key, ROUNDS, WIDTH_BITS)
}
pub fn deobfuscate(code: u64, key: u64) -> u64 {
feistel_n_inv(code & MAX_ID, key, ROUNDS, WIDTH_BITS)
}
#[cfg(test)]
mod tests {
#[cfg(feature = "alloc")]
use alloc::{vec, vec::Vec};
use super::*;
#[test]
fn round_trip_edges() {
let key = 0x9E37_79B9_7F4A_7C15;
for id in [0u64, 1, 2, 42, 1000, MAX_ID / 2, MAX_ID - 1, MAX_ID] {
let code = obfuscate(id, key);
assert!(code <= MAX_ID, "code out of range: {code}");
assert_eq!(deobfuscate(code, key), id, "round-trip failed for id={id}");
}
}
#[test]
fn out_of_domain_input_is_reduced_not_rejected() {
let key = 3;
assert_eq!(obfuscate(u64::MAX, key), obfuscate(MAX_ID, key));
assert_eq!(deobfuscate(obfuscate(MAX_ID + 1, key), key), 0);
}
#[cfg(feature = "alloc")]
#[test]
fn bijectivity_on_small_width() {
let key = 0xDEAD_BEEF_CAFE_BABE;
let n = 1u64 << 20;
let mut seen = vec![false; n as usize];
for id in 0..n {
let c = feistel_n(id, key, ROUNDS, 20);
assert!(c < n);
assert!(!seen[c as usize], "collision at id={id} -> {c}");
seen[c as usize] = true;
}
}
#[cfg(feature = "alloc")]
#[test]
fn distinct_keys_give_distinct_outputs() {
let ids = [0u64, 1, 42, 12345, MAX_ID];
let keys = [0u64, 1, GOLDEN, 0x0123_4567_89AB_CDEF];
for id in ids {
let mut outs: Vec<u64> = keys.map(|k| obfuscate(id, k)).to_vec();
outs.sort_unstable();
let before = outs.len();
outs.dedup();
assert_eq!(outs.len(), before, "keys collided on id={id}");
}
}
#[cfg(feature = "alloc")]
#[test]
fn input_ordering_is_not_preserved() {
let key = 0x0123_4567_89AB_CDEF;
let codes: Vec<u64> = (100..200).map(|id| obfuscate(id, key)).collect();
let ascending = codes.windows(2).filter(|w| w[0] < w[1]).count();
assert!(
(20..80).contains(&ascending),
"codes preserve too much of the input ordering: {ascending}/99 ascending steps"
);
}
#[test]
fn complement_keys_are_no_longer_equivalent() {
for key in [0u64, 1, GOLDEN, 0xD1B5_4A32_D192_ED03, 1 << 63] {
let differs = (0..ROUNDS).any(|round| subkey(key, round) != subkey(!key, round));
assert!(
differs,
"key {key:#x} still derives the subkeys of its complement"
);
assert_ne!(
obfuscate(12345, key),
obfuscate(12345, !key),
"key {key:#x} and its complement still define the same permutation"
);
}
}
#[test]
fn subkey_matches_spec_section_4() {
assert_eq!(subkey(1, 0), 0x1D81_F5D0);
}
}