use std::collections::HashSet;
use std::io::{BufRead, BufReader};
use std::path::{Path, PathBuf};
fn default_paths() -> Vec<PathBuf> {
let mut v = Vec::new();
if let Some(xdg) = std::env::var_os("XDG_DATA_HOME") {
v.push(PathBuf::from(xdg).join("hashcat").join("hashcat.potfile"));
}
if let Some(home) = std::env::var_os("HOME") {
v.push(PathBuf::from(&home).join(".local/share/hashcat/hashcat.potfile"));
v.push(PathBuf::from(&home).join(".hashcat/hashcat.potfile"));
}
if let Some(userprofile) = std::env::var_os("USERPROFILE") {
v.push(PathBuf::from(&userprofile).join("hashcat.potfile"));
}
if let Some(appdata) = std::env::var_os("APPDATA") {
v.push(
PathBuf::from(appdata)
.join("hashcat")
.join("hashcat.potfile"),
);
}
v
}
pub fn resolve(explicit: Option<&Path>) -> Option<PathBuf> {
if let Some(p) = explicit {
return Some(p.to_path_buf());
}
default_paths().into_iter().find(|p| p.is_file())
}
pub struct Pot {
solved: HashSet<String>,
pub source: PathBuf,
}
impl Pot {
pub fn load(path: PathBuf) -> std::io::Result<Self> {
let file = std::fs::File::open(&path)?;
let mut solved = HashSet::new();
for line in BufReader::new(file).lines().map_while(Result::ok) {
if let Some((hash, _plain)) = line.split_once(':') {
let h = hash.trim();
if !h.is_empty() {
solved.insert(h.to_string());
}
}
}
Ok(Pot {
solved,
source: path,
})
}
pub fn contains(&self, hash: &str) -> bool {
self.solved.contains(hash.trim())
}
pub fn len(&self) -> usize {
self.solved.len()
}
pub fn is_empty(&self) -> bool {
self.solved.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn write_temp_pot(content: &str) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"hashglass_pot_test_{}_{}.pot",
std::process::id(),
content.len(),
));
let mut f = std::fs::File::create(&path).unwrap();
f.write_all(content.as_bytes()).unwrap();
path
}
#[test]
fn loads_bare_hash_potfile() {
let path = write_temp_pot(
"31d6cfe0d16ae931b73c59d7e0c089c0:\n8846f7eaee8fb117ad06bdd830b7586c:password\n",
);
let pot = Pot::load(path.clone()).unwrap();
assert_eq!(pot.len(), 2);
assert!(pot.contains("31d6cfe0d16ae931b73c59d7e0c089c0"));
assert!(pot.contains("8846f7eaee8fb117ad06bdd830b7586c"));
assert!(!pot.contains("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
let _ = std::fs::remove_file(&path);
}
#[test]
fn splits_at_first_colon_only() {
let path = write_temp_pot("abc123:pass:with:colons\n");
let pot = Pot::load(path.clone()).unwrap();
assert!(pot.contains("abc123"));
assert_eq!(pot.len(), 1);
let _ = std::fs::remove_file(&path);
}
#[test]
fn skips_blank_and_malformed_lines() {
let path = write_temp_pot("\ngood_hash:pw\nno_colon_here\n\n");
let pot = Pot::load(path.clone()).unwrap();
assert_eq!(pot.len(), 1);
assert!(pot.contains("good_hash"));
let _ = std::fs::remove_file(&path);
}
#[test]
fn explicit_path_wins_over_defaults() {
let path = write_temp_pot("x:y\n");
let resolved = resolve(Some(&path)).unwrap();
assert_eq!(resolved, path);
let _ = std::fs::remove_file(&path);
}
#[test]
fn missing_file_errors() {
let missing = std::env::temp_dir().join("definitely_nonexistent_potfile_xyz.pot");
assert!(Pot::load(missing).is_err());
}
}