🌌 Scintia-96

Scintia-96 is a lightweight, keyed 96-bit permutation built for situations where you need guaranteed uniqueness for a 96-bit input. ⚡

🚀 Quick Start

Getting started is easy! Add it to your project:

cargo add scintia-96

Basic Usage

use scintia_96::Scintia96;

// 128-bit key (4 x u32)
const KEY: [u32; 4] = [0x01020304, 0x05060708, 0x090a0b0c, 0x0d0e0f10];
const PERMUTATION: Scintia96 = Scintia96::new(KEY);

fn main() {
    // 96-bit block (3 x u32)
    let block = [0xdeadbeef, 0xcafebabe, 0xfacefeed];
    
    // Permute it!
    let permuted = PERMUTATION.permute(block);
    
    println!("Original: {:x?}", block);
    println!("Permuted: {:x?}", permuted);
}

🎯 Why Scintia-96?

The Use Case

Ever needed to derive a USB serial number from a 96-bit unique chip ID (like those on STM32 microcontrollers)? That's exactly why Scintia-96 exists! 🛠️

While you could use a hash function, a permutation is often more suitable for cases like this. Since it's a one-to-one mapping, the output inherits the guaranteed uniqueness of the input, meaning there can never be a collision.

Why a Keyed Permutation?

By using a key, you ensure that your derived result is unique to your use case. Even if other apps use Scintia-96 for the same purpose, their results will differ from yours. 🧂

🛠️ The Algorithm

Scintia-96 is based on the Speck block cipher (specifically Speck-64/128) with a few tweaks:

3-word GFN: It operates on three 32-bit words using a Generalized Feistel Network.
32 Rounds: Since we have 3 lanes and leave one out each round, diffusion is slightly slower. We bumped the round count to 32 to compensate and ensure robust mixing. 🌪️

🔒 Security & Promises

I'm a developer, not a cryptographer, so I can't vouch for its resistance to cryptanalysis. But here’s what Scintia-96 brings to the table:

✅ No Collisions: It's a true permutation: 96-bit input, 96-bit output, with a one-to-one mapping.
✅ Statistically Sound: Passes avalanche and random distribution tests.
✅ Hard to Reverse: Prevents recovery of the input without the key.
❌ Not Side-Channel Resistant: If an attacker can perform side-channel analysis on your hardware, they can probably just as well extract the key from flash memory. 🤷‍♂️

⚠️ A Note on Safety

Please don't use this to encrypt sensitive data. For AEAD, KDF, or MAC use cases, stick to well-established primitives like Xoodyak. Again, Scintia-96 is a keyed permutation, not a block cipher!

🔑 Key Generation

We provide a handy script to generate keys for your project:

python3 scripts/keygen.py

Quick One-Liners

Random Generation (via /dev/urandom):

python3 -c "import os; d=os.urandom(16); print('const KEY: [u32; 4] = [%s];' % ', '.join('0x%08x' % int.from_bytes(d[i:i+4], 'big') for i in range(0, 16, 4)))"

Deterministic Derivation (via SHA-512):

key_material="my-unique-variant"
python3 -c "import hashlib; m='$key_material'; h=hashlib.sha512(('scintia-96:key:'+m).encode()).digest(); print('// derive_key(\"%s\")\nconst KEY: [u32; 4] = [%s];' % (m, ', '.join('0x%08x' % int.from_bytes(h[i:i+4], 'big') for i in range(0, 16, 4))))"

📜 License

This project is licensed under the BSD 2-Clause License. See LICENSE.md for the full text. 📄

scintia-96 0.1.0