seam_codegen/

rpc_hash.rs

/* src/cli/codegen/src/rpc_hash.rs */

// RPC endpoint hash map: maps procedure names to short hex hashes for obfuscation.

use std::collections::BTreeMap;

use anyhow::{Result, bail};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RpcHashMap {
	pub salt: String,
	pub batch: String,
	pub procedures: BTreeMap<String, String>,
}

/// Generate 16 hex chars (8 random bytes) for use as a hash salt.
pub fn generate_random_salt() -> String {
	let bytes: [u8; 8] = rand::random();
	hex::encode(bytes)
}

/// Hash a name with a salt, returning `prefix` + exactly `hash_length` hex chars.
fn hash_name(name: &str, salt: &str, hash_length: usize, prefix: &str) -> String {
	let mut hasher = Sha256::new();
	hasher.update(name.as_bytes());
	hasher.update(salt.as_bytes());
	let result = hasher.finalize();
	let bytes_needed = hash_length.div_ceil(2);
	let hex = hex::encode(&result[..bytes_needed]);
	format!("{}{}", prefix, &hex[..hash_length])
}

/// Build an RPC hash map from procedure names and a salt.
/// When `type_hint` is true, hashes use `rpc-` prefix.
/// `hash_length` controls the number of hex chars in the hash portion.
/// Detects collisions and retries with modified salt (up to 100 attempts).
pub fn generate_rpc_hash_map(
	names: &[&str],
	salt: &str,
	hash_length: usize,
	type_hint: bool,
) -> Result<RpcHashMap> {
	let prefix = if type_hint { "rpc-" } else { "" };

	for attempt in 0..100u32 {
		let effective_salt = if attempt == 0 { salt.to_string() } else { format!("{salt}{attempt}") };

		let mut procedures = BTreeMap::new();
		let mut seen = BTreeMap::new();
		let mut collision = false;

		// Hash _batch first
		let batch_hash = hash_name("_batch", &effective_salt, hash_length, prefix);
		seen.insert(batch_hash.clone(), "_batch".to_string());

		for &name in names {
			let hash = hash_name(name, &effective_salt, hash_length, prefix);
			if let Some(existing) = seen.get(&hash)
				&& existing != name
			{
				collision = true;
				break;
			}
			seen.insert(hash.clone(), name.to_string());
			procedures.insert(name.to_string(), hash);
		}

		if !collision {
			return Ok(RpcHashMap { salt: effective_salt, batch: batch_hash, procedures });
		}
	}

	bail!("failed to generate collision-free RPC hash map after 100 attempts")
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn deterministic_with_same_salt() {
		let salt = generate_random_salt();
		let map1 = generate_rpc_hash_map(&["getUser", "getSession"], &salt, 12, true).unwrap();
		let map2 = generate_rpc_hash_map(&["getUser", "getSession"], &salt, 12, true).unwrap();
		assert_eq!(map1.procedures, map2.procedures);
		assert_eq!(map1.batch, map2.batch);
	}

	#[test]
	fn different_salt_different_hashes() {
		let salt1 = generate_random_salt();
		let mut salt2 = generate_random_salt();
		if salt1 == salt2 {
			salt2 = generate_random_salt();
		}
		let map1 = generate_rpc_hash_map(&["getUser"], &salt1, 12, true).unwrap();
		let map2 = generate_rpc_hash_map(&["getUser"], &salt2, 12, true).unwrap();
		assert_ne!(map1.procedures["getUser"], map2.procedures["getUser"]);
	}

	#[test]
	fn no_collision_on_typical_set() {
		let names: Vec<&str> = vec![
			"getUser",
			"getSession",
			"listPosts",
			"createPost",
			"updatePost",
			"deletePost",
			"getComments",
			"addComment",
		];
		let salt = generate_random_salt();
		let map = generate_rpc_hash_map(&names, &salt, 12, true).unwrap();
		assert_eq!(map.procedures.len(), names.len());
		// All hashes are unique
		let hashes: std::collections::HashSet<_> = map.procedures.values().collect();
		assert_eq!(hashes.len(), names.len());
	}

	#[test]
	fn hash_length_type_hint_true() {
		let salt = generate_random_salt();
		let map = generate_rpc_hash_map(&["test"], &salt, 12, true).unwrap();
		let hash = &map.procedures["test"];
		// rpc- prefix (4) + 12 hex chars = 16 total
		assert_eq!(hash.len(), 16);
		assert!(hash.starts_with("rpc-"));
		assert!(hash[4..].chars().all(|c| c.is_ascii_hexdigit()));
		assert_eq!(map.batch.len(), 16);
		assert!(map.batch.starts_with("rpc-"));
	}

	#[test]
	fn hash_length_type_hint_false() {
		let salt = generate_random_salt();
		let map = generate_rpc_hash_map(&["test"], &salt, 12, false).unwrap();
		let hash = &map.procedures["test"];
		// bare 12 hex chars, no prefix
		assert_eq!(hash.len(), 12);
		assert!(hash.chars().all(|c| c.is_ascii_hexdigit()));
		assert!(!hash.starts_with("rpc-"));
		assert_eq!(map.batch.len(), 12);
	}

	#[test]
	fn hash_length_custom() {
		let salt = generate_random_salt();
		// 8 hex chars
		let map = generate_rpc_hash_map(&["test"], &salt, 8, true).unwrap();
		let hash = &map.procedures["test"];
		assert_eq!(hash.len(), 12); // rpc- (4) + 8 hex
		assert!(hash.starts_with("rpc-"));
		assert!(hash[4..].chars().all(|c| c.is_ascii_hexdigit()));

		// 20 hex chars
		let map = generate_rpc_hash_map(&["test"], &salt, 20, false).unwrap();
		let hash = &map.procedures["test"];
		assert_eq!(hash.len(), 20);
		assert!(hash.chars().all(|c| c.is_ascii_hexdigit()));

		// Odd length (7 hex chars)
		let map = generate_rpc_hash_map(&["test"], &salt, 7, false).unwrap();
		let hash = &map.procedures["test"];
		assert_eq!(hash.len(), 7);
		assert!(hash.chars().all(|c| c.is_ascii_hexdigit()));
	}

	#[test]
	fn serialization_roundtrip() {
		let salt = generate_random_salt();
		let map = generate_rpc_hash_map(&["a", "b"], &salt, 12, true).unwrap();
		let json = serde_json::to_string(&map).unwrap();
		let restored: RpcHashMap = serde_json::from_str(&json).unwrap();
		assert_eq!(map.salt, restored.salt);
		assert_eq!(map.batch, restored.batch);
		assert_eq!(map.procedures, restored.procedures);
	}

	#[test]
	fn random_salt_is_16_hex_chars() {
		let salt = generate_random_salt();
		assert_eq!(salt.len(), 16);
		assert!(salt.chars().all(|c| c.is_ascii_hexdigit()));
	}

	#[test]
	fn empty_procedures() {
		let salt = generate_random_salt();
		let map = generate_rpc_hash_map(&[], &salt, 12, true).unwrap();
		assert!(map.procedures.is_empty());
		assert!(!map.batch.is_empty());
	}
}