Workspace of 9 crates (noxis, noxis-core, noxis-classfile, noxis-analysis, noxis-passes, noxis-runtime, noxis-jar, noxis-verify, noxis-structure-check). AGPL-3.0-only license, Rust 2024 edition, unsafe_code denied.
203 lines
7.5 KiB
Rust
203 lines
7.5 KiB
Rust
//! Схемы шифрования строк: пер-строчный ключ, nonce и несколько алгоритмов.
|
||
//!
|
||
//! Требования (см. `info/evo-weaknesses.md` и `docs/techniques.md`):
|
||
//! - **разные схемы между строками** — один скрипт не покрывает весь jar;
|
||
//! - **ключ не рядом с шифротекстом** — на вызов передаётся только salt,
|
||
//! мастер-секрет живёт в рантайм-декодере (сборка мастер-секрета — P2);
|
||
//! - **nonce уникален на строку** — keystream не повторяется;
|
||
//! - **MAC** — повреждение/подмена шифротекста ловится, а не молча портит текст.
|
||
|
||
use noxis_core::{Rng, derive_seed};
|
||
|
||
use crate::codec;
|
||
|
||
/// Ошибка схемы.
|
||
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
|
||
pub enum SchemeError {
|
||
#[error("неизвестная схема `{0}`")]
|
||
UnknownScheme(String),
|
||
#[error("повреждённый шифротекст")]
|
||
CorruptCiphertext,
|
||
}
|
||
|
||
/// Поддерживаемые схемы.
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum Scheme {
|
||
/// XOR со keystream из xoshiro-like генератора (быстро, дёшево).
|
||
XorSplitmix,
|
||
/// XTEA в режиме счётчика (блочная, другая структура шифротекста).
|
||
XteaCtr,
|
||
}
|
||
|
||
impl Scheme {
|
||
/// Имя схемы, как она пишется в конфиге.
|
||
pub const fn name(self) -> &'static str {
|
||
match self {
|
||
Scheme::XorSplitmix => "xor-splitmix",
|
||
Scheme::XteaCtr => "xtea-ctr",
|
||
}
|
||
}
|
||
|
||
/// Разбор имени из конфига.
|
||
pub fn parse(name: &str) -> Result<Self, SchemeError> {
|
||
match name {
|
||
"xor-splitmix" => Ok(Scheme::XorSplitmix),
|
||
"xtea-ctr" => Ok(Scheme::XteaCtr),
|
||
other => Err(SchemeError::UnknownScheme(other.to_string())),
|
||
}
|
||
}
|
||
|
||
/// Все схемы в порядке объявления (для ротации).
|
||
pub const fn all() -> [Scheme; 2] {
|
||
[Scheme::XorSplitmix, Scheme::XteaCtr]
|
||
}
|
||
}
|
||
|
||
/// Зашифрованный блоб: шифротекст (base64) + tag для целостности.
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub struct Blob {
|
||
/// base64 шифротекста.
|
||
pub cipher: String,
|
||
/// 32-битный MAC по ключу от plaintext — ловит подмену/порчу.
|
||
pub tag: u32,
|
||
}
|
||
|
||
/// Ключ строки из мастер-секрета и salt (то же вычисление делает Java-декодер).
|
||
pub fn string_key(master: u64, salt: i32) -> u64 {
|
||
derive_seed(master, "string/key", u64::from(salt as u32))
|
||
}
|
||
|
||
/// Nonce строки: детерминированный от salt, но другой домен — keystream не
|
||
/// пересекается даже при совпадении ключей.
|
||
pub fn string_nonce(master: u64, salt: i32) -> u64 {
|
||
derive_seed(master, "string/nonce", u64::from(salt as u32))
|
||
}
|
||
|
||
/// Зашифровать строку.
|
||
pub fn encrypt(scheme: Scheme, master: u64, salt: i32, plain: &str) -> Blob {
|
||
let key = string_key(master, salt);
|
||
let nonce = string_nonce(master, salt);
|
||
let mut data = plain.as_bytes().to_vec();
|
||
match scheme {
|
||
Scheme::XorSplitmix => xor_splitmix(key, nonce, &mut data),
|
||
Scheme::XteaCtr => xtea_ctr(key, nonce, &mut data),
|
||
}
|
||
Blob {
|
||
cipher: codec::encode(&data),
|
||
tag: mac(key, &data),
|
||
}
|
||
}
|
||
|
||
/// Расшифровать блоб (зеркало того, что делает рантайм-декодер).
|
||
pub fn decrypt(scheme: Scheme, master: u64, salt: i32, blob: &Blob) -> Result<String, SchemeError> {
|
||
let key = string_key(master, salt);
|
||
let nonce = string_nonce(master, salt);
|
||
let mut data = codec::decode(&blob.cipher).map_err(|_| SchemeError::CorruptCiphertext)?;
|
||
if mac(key, &data) != blob.tag {
|
||
return Err(SchemeError::CorruptCiphertext);
|
||
}
|
||
match scheme {
|
||
Scheme::XorSplitmix => xor_splitmix(key, nonce, &mut data),
|
||
Scheme::XteaCtr => xtea_ctr(key, nonce, &mut data),
|
||
}
|
||
String::from_utf8(data).map_err(|_| SchemeError::CorruptCiphertext)
|
||
}
|
||
|
||
/// MAC: fnv1a поверх keystream-домена (дёшево, ловит точечные правки).
|
||
fn mac(key: u64, data: &[u8]) -> u32 {
|
||
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
|
||
for b in data.iter().chain(key.to_le_bytes().iter()) {
|
||
hash ^= u64::from(*b);
|
||
hash = hash.wrapping_mul(0x0000_0100_0000_01B3);
|
||
}
|
||
(hash ^ (hash >> 32)) as u32
|
||
}
|
||
|
||
fn xor_splitmix(key: u64, nonce: u64, data: &mut [u8]) {
|
||
let mut rng = Rng::from_seed(key ^ nonce.rotate_left(17));
|
||
for chunk in data.chunks_mut(8) {
|
||
let stream = rng.next_u64().to_le_bytes();
|
||
for (b, s) in chunk.iter_mut().zip(stream.iter()) {
|
||
*b ^= s;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// XTEA в режиме счётчика: keystream = XTEA(k, counter), XOR — на месте.
|
||
fn xtea_ctr(key: u64, nonce: u64, data: &mut [u8]) {
|
||
let k = [
|
||
key as u32,
|
||
(key >> 32) as u32,
|
||
nonce as u32,
|
||
(nonce >> 32) as u32,
|
||
];
|
||
for (i, chunk) in data.chunks_mut(8).enumerate() {
|
||
let stream = xtea_encrypt_block(k, (i as u64).to_be_bytes());
|
||
for (b, s) in chunk.iter_mut().zip(stream.iter()) {
|
||
*b ^= s;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Один блок XTEA (32 раунда, delta = 0x9E3779B9).
|
||
fn xtea_encrypt_block(k: [u32; 4], block: [u8; 8]) -> [u8; 8] {
|
||
let mut v0 = u32::from_be_bytes([block[0], block[1], block[2], block[3]]);
|
||
let mut v1 = u32::from_be_bytes([block[4], block[5], block[6], block[7]]);
|
||
let mut sum: u32 = 0;
|
||
const DELTA: u32 = 0x9E37_79B9;
|
||
for _ in 0..32 {
|
||
v0 = v0.wrapping_add(
|
||
(((v1 << 4) ^ (v1 >> 5)).wrapping_add(v1)) ^ (sum.wrapping_add(k[(sum & 3) as usize])),
|
||
);
|
||
sum = sum.wrapping_add(DELTA);
|
||
v1 = v1.wrapping_add(
|
||
(((v0 << 4) ^ (v0 >> 5)).wrapping_add(v0))
|
||
^ (sum.wrapping_add(k[((sum >> 11) & 3) as usize])),
|
||
);
|
||
}
|
||
let mut out = [0u8; 8];
|
||
out[..4].copy_from_slice(&v0.to_be_bytes());
|
||
out[4..].copy_from_slice(&v1.to_be_bytes());
|
||
out
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
#![allow(clippy::expect_used, clippy::unwrap_used)]
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn roundtrip_all_schemes() {
|
||
for scheme in Scheme::all() {
|
||
for text in ["", "a", "Hello, мир!", "x".repeat(33).as_str()] {
|
||
let blob = encrypt(scheme, 42, 7, text);
|
||
let back = decrypt(scheme, 42, 7, &blob).expect("decrypt");
|
||
assert_eq!(back, text, "scheme={:?}", scheme);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn different_salt_different_cipher() {
|
||
let a = encrypt(Scheme::XorSplitmix, 1, 1, "same");
|
||
let b = encrypt(Scheme::XorSplitmix, 1, 2, "same");
|
||
assert_ne!(a.cipher, b.cipher);
|
||
}
|
||
|
||
#[test]
|
||
fn tampering_is_detected() {
|
||
let mut blob = encrypt(Scheme::XteaCtr, 5, 3, "sensitive");
|
||
let mut bytes = codec::decode(&blob.cipher).expect("b64");
|
||
bytes[0] ^= 0xFF;
|
||
blob.cipher = codec::encode(&bytes);
|
||
assert_eq!(
|
||
decrypt(Scheme::XteaCtr, 5, 3, &blob),
|
||
Err(SchemeError::CorruptCiphertext)
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn unknown_scheme_rejected() {
|
||
assert!(Scheme::parse("rot13").is_err());
|
||
}
|
||
}
|