VNOX-Server/hub/src/identity.rs
loki5512344 cca084b0ae
feat(hub): email one-time-code sign-in
POST /v1/auth/email/start and /verify with HMAC-protected 8-digit codes
(10 min, 5 tries, atomic single use), browser-bound via a __Host- cookie,
same-origin checks, per-address/source/global rate limits and an injectable
sender. Enabled in /v1/info only when SMTP is configured. Email identities
use external_identities(provider='email') and never merge with GitHub.
2026-10-24 17:42:52 +02:00

220 lines
8 KiB
Rust

use std::{fs::OpenOptions, io::Write, path::Path};
use anyhow::{Context, Result, bail};
use ed25519_dalek::SigningKey;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct StoredIdentity {
version: u32,
issuer_id: Uuid,
secret_key: String,
public_key: String,
}
/// Stable issuer identity. Only its public projection is exposed through HTTP.
pub struct Issuer {
pub id: Uuid,
pub public_key: String,
}
impl Issuer {
pub fn load_or_create(directory: &Path) -> Result<Self> {
let mut builder = std::fs::DirBuilder::new();
builder.recursive(true);
#[cfg(unix)]
{
use std::os::unix::fs::DirBuilderExt;
builder.mode(0o700);
}
builder
.create(directory)
.context("creating Hub data directory")?;
check_private_directory(directory)?;
let path = directory.join("issuer.json");
let stored = match OpenOptions::new().read(true).open(&path) {
Ok(file) => {
check_private_permissions(&file)?;
if file.metadata()?.len() > 4096 {
bail!("Hub issuer identity exceeds the expected size");
}
let value: StoredIdentity =
serde_json::from_reader(file).context("reading Hub issuer identity")?;
value
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
let key = SigningKey::generate(&mut rand::rng());
let value = StoredIdentity {
version: 1,
issuer_id: Uuid::new_v4(),
secret_key: hex::encode(key.to_bytes()),
public_key: hex::encode(key.verifying_key().to_bytes()),
};
persist_new_identity(&path, &value)?;
value
}
Err(error) => return Err(error).context("opening Hub issuer identity"),
};
let secret = hex::decode(&stored.secret_key)
.ok()
.and_then(|bytes| <[u8; 32]>::try_from(bytes).ok())
.context("Hub issuer private key has invalid encoding or length")?;
let key = SigningKey::from_bytes(&secret);
if stored.version != 1 || hex::encode(key.verifying_key().to_bytes()) != stored.public_key {
bail!("Hub issuer identity failed integrity validation");
}
Ok(Self {
id: stored.issuer_id,
public_key: stored.public_key,
})
}
}
/// Loads a 32-byte server secret stored as hex in a 0600 file, creating it from the OS
/// CSPRNG on first use. The value is never logged and has no Debug/Serialize wrapper.
pub fn load_or_create_secret(directory: &Path, name: &str) -> Result<[u8; 32]> {
check_private_directory(directory)?;
let path = directory.join(name);
for _ in 0..2 {
match OpenOptions::new().read(true).open(&path) {
Ok(file) => {
check_private_permissions(&file)?;
if file.metadata()?.len() > 256 {
bail!("Hub secret file exceeds the expected size");
}
let text = std::io::read_to_string(file).context("reading Hub secret file")?;
return hex::decode(text.trim())
.ok()
.and_then(|bytes| <[u8; 32]>::try_from(bytes).ok())
.context("Hub secret file has invalid encoding or length");
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
use rand::Rng;
let mut bytes = [0u8; 32];
rand::rng().fill_bytes(&mut bytes);
// A concurrent creator winning the race is fine: the loop re-reads its file.
let _ = persist_new_file(&path, hex::encode(bytes).as_bytes());
}
Err(error) => return Err(error).context("opening Hub secret file"),
}
}
bail!("could not create Hub secret file")
}
fn check_private_permissions(file: &std::fs::File) -> Result<()> {
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
if file.metadata()?.permissions().mode() & 0o077 != 0 {
bail!("Hub issuer identity must not be accessible to group/other users (use 0600)");
}
}
Ok(())
}
fn check_private_directory(directory: &Path) -> Result<()> {
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
if std::fs::metadata(directory)?.permissions().mode() & 0o077 != 0 {
bail!("Hub data directory must be private (use 0700)");
}
}
Ok(())
}
// Publish a fully synced key file without replacing any concurrent issuer.
// A failed first write must never leave a truncated final identity behind.
fn persist_new_identity(path: &Path, identity: &StoredIdentity) -> Result<()> {
persist_new_file(path, &serde_json::to_vec_pretty(identity)?)
}
fn persist_new_file(path: &Path, contents: &[u8]) -> Result<()> {
let temporary = path.with_extension(format!("{}.tmp", Uuid::new_v4()));
let result = (|| -> Result<()> {
let mut options = OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
options.mode(0o600);
}
{
let mut file = options
.open(&temporary)
.context("preparing Hub issuer identity")?;
file.write_all(contents)
.context("writing Hub issuer identity")?;
file.sync_all().context("syncing Hub issuer identity")?;
}
std::fs::hard_link(&temporary, path).context("publishing new Hub issuer identity")?;
#[cfg(unix)]
std::fs::File::open(path.parent().context("issuer directory is missing")?)?
.sync_all()
.context("syncing Hub issuer directory")?;
Ok(())
})();
let _ = std::fs::remove_file(&temporary);
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn generated_secret_is_stable_private_and_validated() {
let directory = tempfile::tempdir().unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(directory.path(), std::fs::Permissions::from_mode(0o700))
.unwrap();
}
let first = load_or_create_secret(directory.path(), "s.key").unwrap();
assert_eq!(
first,
load_or_create_secret(directory.path(), "s.key").unwrap()
);
assert_ne!(first, [0; 32]);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(directory.path().join("s.key"))
.unwrap()
.permissions()
.mode();
assert_eq!(mode & 0o077, 0);
}
std::fs::write(directory.path().join("bad.key"), "zz").unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(
directory.path().join("bad.key"),
std::fs::Permissions::from_mode(0o600),
)
.unwrap();
}
assert!(load_or_create_secret(directory.path(), "bad.key").is_err());
}
#[test]
fn publishing_never_overwrites_an_existing_identity_or_leaves_temp_files() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("issuer.json");
std::fs::write(&path, b"existing issuer").unwrap();
let key = SigningKey::generate(&mut rand::rng());
let candidate = StoredIdentity {
version: 1,
issuer_id: Uuid::new_v4(),
secret_key: hex::encode(key.to_bytes()),
public_key: hex::encode(key.verifying_key().to_bytes()),
};
assert!(persist_new_identity(&path, &candidate).is_err());
assert_eq!(std::fs::read(&path).unwrap(), b"existing issuer");
assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
}
}