use std::fs;
use std::path::{Path, PathBuf};
use alloy_primitives::Address;
use alloy_signer_local::PrivateKeySigner;
use thiserror::Error as ThisError;
#[derive(Debug, Clone)]
pub enum KeySource {
File { path: PathBuf },
}
#[derive(Debug, ThisError)]
pub enum KeystoreError {
#[error("home directory not found; set $HOME or $XDG_DATA_HOME")]
HomeNotFound,
#[error("failed to create keystore dir {path}: {source}")]
CreateDir {
path: PathBuf,
#[source]
source: std::io::Error,
},
#[error("keystore file not found: {0}")]
NotFound(PathBuf),
#[error("signer/keystore error: {0}")]
Signer(String),
#[error("I/O error: {0}")]
Io(#[from] std::io::Error),
}
pub fn default_keystore_dir() -> Result<PathBuf, KeystoreError> {
let base = match std::env::var("XDG_DATA_HOME") {
Ok(xdg) if !xdg.is_empty() => PathBuf::from(xdg),
_ => home_fallback()?,
};
let dir = base.join("taskfast").join("wallets");
ensure_dir(&dir)?;
Ok(dir)
}
fn home_fallback() -> Result<PathBuf, KeystoreError> {
std::env::var_os("HOME")
.filter(|s| !s.is_empty())
.map(|home| PathBuf::from(home).join(".local").join("share"))
.ok_or(KeystoreError::HomeNotFound)
}
fn ensure_dir(dir: &Path) -> Result<(), KeystoreError> {
fs::create_dir_all(dir).map_err(|source| KeystoreError::CreateDir {
path: dir.to_path_buf(),
source,
})?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mut perms = fs::metadata(dir)?.permissions();
perms.set_mode(0o700);
fs::set_permissions(dir, perms)?;
}
Ok(())
}
pub fn default_keyfile_name(address: Address) -> String {
let hex = hex::encode(address.as_slice());
format!("{hex}.json")
}
pub fn default_keyfile_path(address: Address) -> Result<PathBuf, KeystoreError> {
Ok(default_keystore_dir()?.join(default_keyfile_name(address)))
}
pub fn save_signer(
signer: &PrivateKeySigner,
path: &Path,
password: &str,
) -> Result<PathBuf, KeystoreError> {
let parent = path
.parent()
.ok_or_else(|| KeystoreError::NotFound(path.to_path_buf()))?;
ensure_dir(parent)?;
let file_name = path
.file_name()
.and_then(|s| s.to_str())
.ok_or_else(|| KeystoreError::NotFound(path.to_path_buf()))?;
let written = parent.join(file_name);
#[cfg(unix)]
{
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let f = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(false) .mode(0o600)
.open(&written)?;
let mut perms = f.metadata()?.permissions();
perms.set_mode(0o600);
f.set_permissions(perms)?;
}
let mut rng = rand::thread_rng();
let pk_bytes = signer.to_bytes();
PrivateKeySigner::encrypt_keystore(parent, &mut rng, pk_bytes, password, Some(file_name))
.map_err(|e| KeystoreError::Signer(e.to_string()))?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mut perms = fs::metadata(&written)?.permissions();
perms.set_mode(0o600);
fs::set_permissions(&written, perms)?;
}
Ok(written)
}
pub fn generate_and_save(password: &str) -> Result<(PrivateKeySigner, PathBuf), KeystoreError> {
let signer = PrivateKeySigner::random();
let path = default_keyfile_path(signer.address())?;
save_signer(&signer, &path, password)?;
Ok((signer, path))
}
#[cfg(unix)]
fn mode_is_too_open(mode: u32) -> bool {
mode & 0o077 != 0
}
pub fn load_signer(path: &Path, password: &str) -> Result<PrivateKeySigner, KeystoreError> {
if !path.exists() {
return Err(KeystoreError::NotFound(path.to_path_buf()));
}
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = fs::metadata(path)?.permissions().mode() & 0o777;
if mode_is_too_open(mode) {
tracing::warn!(
keystore = %path.display(),
mode = format!("{mode:o}"),
"keystore is group/world-accessible (expected 0600) โ \
run `chmod 600` on it; it holds your encrypted private key"
);
}
}
PrivateKeySigner::decrypt_keystore(path, password)
.map_err(|e| KeystoreError::Signer(e.to_string()))
}
pub fn load(source: &KeySource, password: &str) -> Result<PrivateKeySigner, KeystoreError> {
match source {
KeySource::File { path } => load_signer(path, password),
}
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::TempDir;
#[test]
fn default_keyfile_name_is_lowercase_hex_without_prefix() {
let mut bytes = [0u8; 20];
for (i, b) in bytes.iter_mut().enumerate() {
*b = (i + 1) as u8;
}
let addr = Address::from(bytes);
let name = default_keyfile_name(addr);
assert_eq!(name, "0102030405060708090a0b0c0d0e0f1011121314.json");
}
#[test]
fn save_then_load_roundtrips_signer() {
let tmp = TempDir::new().unwrap();
let signer = PrivateKeySigner::random();
let expected = signer.address();
let path = tmp.path().join("wallet.json");
save_signer(&signer, &path, "s3kret").expect("save");
assert!(path.exists(), "keystore file must exist after save");
let loaded = load_signer(&path, "s3kret").expect("load");
assert_eq!(loaded.address(), expected);
}
#[test]
fn load_with_wrong_password_errors() {
let tmp = TempDir::new().unwrap();
let signer = PrivateKeySigner::random();
let path = tmp.path().join("wallet.json");
save_signer(&signer, &path, "correct").expect("save");
let err = load_signer(&path, "wrong").unwrap_err();
assert!(matches!(err, KeystoreError::Signer(_)));
}
#[test]
fn load_missing_file_reports_not_found() {
let tmp = TempDir::new().unwrap();
let missing = tmp.path().join("nope.json");
let err = load_signer(&missing, "pw").unwrap_err();
assert!(matches!(err, KeystoreError::NotFound(_)));
}
#[test]
fn save_creates_parent_dirs() {
let tmp = TempDir::new().unwrap();
let nested = tmp.path().join("a").join("b").join("wallet.json");
let signer = PrivateKeySigner::random();
save_signer(&signer, &nested, "pw").expect("save");
assert!(nested.exists());
}
#[cfg(unix)]
#[test]
fn saved_keyfile_has_0600_perms() {
use std::os::unix::fs::PermissionsExt;
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("wallet.json");
let signer = PrivateKeySigner::random();
save_signer(&signer, &path, "pw").expect("save");
let mode = fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600, "keyfile must be owner-only readable/writable");
}
#[cfg(unix)]
#[test]
fn overwriting_a_world_readable_keystore_tightens_to_0600() {
use std::os::unix::fs::PermissionsExt;
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("wallet.json");
fs::write(&path, b"stale").unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o664)).unwrap();
let signer = PrivateKeySigner::random();
save_signer(&signer, &path, "pw").expect("save over existing file");
let mode = fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600, "overwrite must tighten 0664 -> 0600");
}
#[cfg(unix)]
#[test]
fn mode_is_too_open_flags_group_and_other_bits() {
assert!(!mode_is_too_open(0o600));
assert!(!mode_is_too_open(0o400));
assert!(mode_is_too_open(0o640), "group-readable is too open");
assert!(mode_is_too_open(0o604), "other-readable is too open");
assert!(mode_is_too_open(0o664), "the observed leak mode");
}
#[test]
fn key_source_file_dispatches_to_file_backend() {
let tmp = TempDir::new().unwrap();
let signer = PrivateKeySigner::random();
let expected = signer.address();
let path = tmp.path().join("wallet.json");
save_signer(&signer, &path, "pw").expect("save");
let loaded = load(&KeySource::File { path: path.clone() }, "pw").expect("load");
assert_eq!(loaded.address(), expected);
}
}