saltminer 0.1.0__tar.gz

saltminer-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: saltminer
+Version: 0.1.0
+Summary: Identify and audit password hashes, offline.
+License: MIT
+Requires-Python: >=3.13

saltminer-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["maturin>=1.7,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "saltminer"
+version = "0.1.0"
+description = "Identify and audit password hashes, offline."
+requires-python = ">=3.13"
+license = { text = "MIT" }
+
+[tool.maturin]
+module-name = "saltminer"
+manifest-path = "saltminer-py/Cargo.toml"

saltminer-0.1.0/saltminer-core/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "saltminer-core"
+version = "0.0.1"
+edition = "2024"
+license = "MIT"
+
+[dependencies]
+
+[dev-dependencies]
+proptest = "1.11.0"

saltminer-0.1.0/saltminer-core/src/lib.rs

@@ -0,0 +1,549 @@
+//! Saltminer core — the identification and audit engine.
+
+/// How sure we are about a single guess.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Confidence {
+    High,
+    Medium,
+    Low,
+}
+
+/// One possible identification of a hash string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Candidate {
+    pub algorithm: String,
+    pub confidence: Confidence,
+    pub reason: String,
+}
+
+/// Known hash prefixes: (prefix, algorithm, note).
+const PREFIX_RULES: &[(&str, &str, &str)] = &[
+    (
+        "$argon2id$",
+        "Argon2id",
+        "modern PHC string, current standard",
+    ),
+    (
+        "$argon2i$",
+        "Argon2i",
+        "PHC string, side-channel-resistant variant",
+    ),
+    ("$argon2d$", "Argon2d", "PHC string, GPU-resistant variant"),
+    ("$2b$", "bcrypt", "bcrypt PHC string, 2b variant"),
+    ("$2y$", "bcrypt", "bcrypt PHC string, 2y variant (PHP)"),
+    ("$2a$", "bcrypt", "bcrypt PHC string, 2a variant (legacy)"),
+    ("$6$", "SHA-512 crypt", "Unix crypt(3) using SHA-512"),
+    ("$5$", "SHA-256 crypt", "Unix crypt(3) using SHA-256"),
+    ("$1$", "MD5 crypt", "Unix crypt(3) using MD5 (legacy)"),
+    ("$apr1$", "Apache MD5-crypt", "Apache htpasswd MD5 variant"),
+    (
+        "pbkdf2_sha256$",
+        "Django PBKDF2-SHA256",
+        "Django default password hash",
+    ),
+];
+
+/// True if the text is non-empty and every character is a hex digit.
+fn is_hex(text: &str) -> bool {
+    !text.is_empty() && text.chars().all(|c| c.is_ascii_hexdigit())
+}
+
+/// True for MySQL5: a `*` followed by exactly 40 uppercase hex chars.
+fn is_mysql5(text: &str) -> bool {
+    if text.len() != 41 || !text.starts_with('*') {
+        return false;
+    }
+    text[1..]
+        .chars()
+        .all(|c| c.is_ascii_hexdigit() && !c.is_ascii_lowercase())
+}
+
+/// Algorithms that produce a hex string of this length, most common first.
+fn length_rules(len: usize) -> &'static [&'static str] {
+    match len {
+        32 => &["MD5", "NTLM", "MD4", "RIPEMD-128"],
+        40 => &["SHA-1", "RIPEMD-160"],
+        56 => &["SHA-224", "SHA3-224"],
+        64 => &["SHA-256", "SHA3-256", "BLAKE2s-256"],
+        96 => &["SHA-384", "SHA3-384"],
+        128 => &["SHA-512", "SHA3-512", "BLAKE2b-512"],
+        _ => &[],
+    }
+}
+
+/// A parsed PHC-style hash string, broken into its parts.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PhcHash {
+    pub id: String,
+    pub params: Vec<(String, String)>,
+    pub segments: Vec<String>,
+}
+
+impl PhcHash {
+    /// Get the value of a named parameter, if present.
+    pub fn param(&self, key: &str) -> Option<&str> {
+        self.params
+            .iter()
+            .find(|(k, _)| k == key)
+            .map(|(_, v)| v.as_str())
+    }
+}
+
+/// Parse a PHC-style string like `$argon2id$v=19$m=65536,t=3,p=4$salt$hash`.
+/// Returns `None` if the input has no `$`-separated structure.
+pub fn parse_phc(input: &str) -> Option<PhcHash> {
+    let text = input.trim();
+    let body = text.strip_prefix('$').unwrap_or(text);
+    let segments: Vec<String> = body.split('$').map(str::to_string).collect();
+
+    if segments.len() < 2 || segments[0].is_empty() {
+        return None;
+    }
+
+    let id = segments[0].clone();
+    let mut params = Vec::new();
+    for seg in &segments[1..] {
+        for pair in seg.split(',') {
+            if let Some((key, value)) = pair.split_once('=') {
+                params.push((key.to_string(), value.to_string()));
+            }
+        }
+    }
+
+    Some(PhcHash {
+        id,
+        params,
+        segments,
+    })
+}
+
+/// A security verdict on how a hash was produced.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Verdict {
+    Secure,
+    WeakParams,
+    Deprecated,
+    Broken,
+}
+
+/// The result of auditing a hash's algorithm and cost parameters.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AuditReport {
+    pub algorithm: String,
+    pub verdict: Verdict,
+    pub detail: String,
+}
+
+// OWASP 2026 password-storage minimums.
+const ARGON2_MIN_MEMORY_KIB: u32 = 19_456; // 19 MiB
+const BCRYPT_MIN_COST: u32 = 10;
+const PBKDF2_MIN_ITERATIONS: u32 = 600_000;
+
+/// Judge a hash against OWASP 2026 password-storage guidance.
+pub fn audit(input: &str) -> Option<AuditReport> {
+    if let Some(phc) = parse_phc(input) {
+        return audit_phc(&phc);
+    }
+
+    // Not a PHC string: judge common raw hashes by what identify() sees.
+    let candidates = identify(input);
+    let first = candidates.first()?;
+    const BROKEN: &[&str] = &["MD5", "SHA-1", "NTLM", "MySQL5", "MySQL323", "MD4"];
+    if BROKEN.contains(&first.algorithm.as_str()) {
+        return Some(AuditReport {
+            algorithm: first.algorithm.clone(),
+            verdict: Verdict::Broken,
+            detail: "fast, unsalted hash — not safe for passwords; use Argon2id".to_string(),
+        });
+    }
+
+    None
+}
+
+/// Rate a parsed PHC hash. Returns None for formats we do not rate.
+fn audit_phc(phc: &PhcHash) -> Option<AuditReport> {
+    let report = match phc.id.as_str() {
+        "argon2id" | "argon2i" | "argon2d" => {
+            let memory = phc
+                .param("m")
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(0);
+            let (verdict, detail) = if memory < ARGON2_MIN_MEMORY_KIB {
+                (
+                    Verdict::WeakParams,
+                    format!("memory {memory} KiB is below the 19 MiB minimum"),
+                )
+            } else {
+                (
+                    Verdict::Secure,
+                    format!("memory {memory} KiB meets current guidance"),
+                )
+            };
+            AuditReport {
+                algorithm: "Argon2".to_string(),
+                verdict,
+                detail,
+            }
+        }
+        "2a" | "2b" | "2y" | "2x" => {
+            let cost = phc
+                .segments
+                .get(1)
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(0);
+            let (verdict, detail) = if cost < BCRYPT_MIN_COST {
+                (
+                    Verdict::WeakParams,
+                    format!("cost {cost} is below the minimum of {BCRYPT_MIN_COST}"),
+                )
+            } else {
+                (
+                    Verdict::Secure,
+                    format!("cost {cost} meets current guidance"),
+                )
+            };
+            AuditReport {
+                algorithm: "bcrypt".to_string(),
+                verdict,
+                detail,
+            }
+        }
+        "pbkdf2_sha256" => {
+            let iters = phc
+                .segments
+                .get(1)
+                .and_then(|v| v.parse::<u32>().ok())
+                .unwrap_or(0);
+            let (verdict, detail) = if iters < PBKDF2_MIN_ITERATIONS {
+                (
+                    Verdict::WeakParams,
+                    format!("{iters} iterations is below the 600,000 minimum"),
+                )
+            } else {
+                (
+                    Verdict::Secure,
+                    format!("{iters} iterations meets current guidance"),
+                )
+            };
+            AuditReport {
+                algorithm: "PBKDF2-SHA256".to_string(),
+                verdict,
+                detail,
+            }
+        }
+        "1" | "apr1" => AuditReport {
+            algorithm: "MD5-based crypt".to_string(),
+            verdict: Verdict::Deprecated,
+            detail: "MD5-based — obsolete; migrate to Argon2id or bcrypt".to_string(),
+        },
+        "6" => AuditReport {
+            algorithm: "SHA-512 crypt".to_string(),
+            verdict: Verdict::Secure,
+            detail: "SHA-512 crypt is acceptable when rounds are high enough".to_string(),
+        },
+        _ => return None,
+    };
+    Some(report)
+}
+
+/// Identify a hash string. Returns a ranked list of candidates.
+pub fn identify(input: &str) -> Vec<Candidate> {
+    let trimmed = input.trim();
+
+    if trimmed.is_empty() {
+        return Vec::new();
+    }
+
+    for &(prefix, algorithm, note) in PREFIX_RULES {
+        if trimmed.starts_with(prefix) {
+            return vec![Candidate {
+                algorithm: algorithm.to_string(),
+                confidence: Confidence::High,
+                reason: format!("prefix {prefix} — {note}"),
+            }];
+        }
+    }
+
+    // MySQL5
+    if is_mysql5(trimmed) {
+        return vec![Candidate {
+            algorithm: "MySQL5".to_string(),
+            confidence: Confidence::High,
+            reason: "`*` + 40 uppercase hex chars".to_string(),
+        }];
+    }
+
+    // pwdump / NTLM (Windows SAM): user:rid:lm(32 hex):nt(32 hex):::
+    if trimmed.ends_with(":::") {
+        let parts: Vec<&str> = trimmed.split(':').collect();
+        if parts.len() == 7
+            && parts[1].chars().all(|c| c.is_ascii_digit())
+            && parts[2].len() == 32
+            && is_hex(parts[2])
+            && parts[3].len() == 32
+            && is_hex(parts[3])
+        {
+            return vec![Candidate {
+                algorithm: "NTLM".to_string(),
+                confidence: Confidence::High,
+                reason: "pwdump line — the NT hash is NTLM".to_string(),
+            }];
+        }
+    }
+
+    // NetNTLMv2 / NetNTLMv1: colon-delimited challenge-response records
+    if trimmed.contains("::") && trimmed.matches(':').count() >= 4 {
+        let parts: Vec<&str> = trimmed.split(':').collect();
+        if parts.len() >= 6 && parts[4].len() == 32 && is_hex(parts[4]) {
+            return vec![Candidate {
+                algorithm: "NetNTLMv2".to_string(),
+                confidence: Confidence::High,
+                reason: "user::domain:challenge:hmac(32 hex):blob shape".to_string(),
+            }];
+        }
+        if parts.len() >= 6 && parts[3].len() == 48 && is_hex(parts[3]) {
+            return vec![Candidate {
+                algorithm: "NetNTLMv1".to_string(),
+                confidence: Confidence::High,
+                reason: "user::domain:lm(48 hex):nt(48 hex):challenge shape".to_string(),
+            }];
+        }
+    }
+
+    if is_hex(trimmed) {
+        let algorithms = length_rules(trimmed.len());
+        let mut candidates = Vec::new();
+        for (index, algorithm) in algorithms.iter().enumerate() {
+            let confidence = if index == 0 {
+                Confidence::Medium
+            } else {
+                Confidence::Low
+            };
+            let label = if index == 0 {
+                "most likely at this length"
+            } else {
+                "also possible at this length"
+            };
+            candidates.push(Candidate {
+                algorithm: algorithm.to_string(),
+                confidence,
+                reason: format!("{} hex chars — {label}", trimmed.len()),
+            });
+        }
+        return candidates;
+    }
+
+    // Not hashes, but say what they actually are.
+    if trimmed.starts_with("eyJ") {
+        return vec![Candidate {
+            algorithm: "JWT (not a hash)".to_string(),
+            confidence: Confidence::Low,
+            reason: "leading `eyJ` is base64 of `{\"` — a JWT, not a hash".to_string(),
+        }];
+    }
+
+    if trimmed.len() > 8 && trimmed.contains(['+', '/', '=']) {
+        return vec![Candidate {
+            algorithm: "Base64 blob (not a hash)".to_string(),
+            confidence: Confidence::Low,
+            reason: "contains base64-only chars (`+`, `/`, `=`)".to_string(),
+        }];
+    }
+
+    Vec::new()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_input_returns_no_candidates() {
+        assert!(identify("").is_empty());
+    }
+
+    #[test]
+    fn bcrypt_prefix_is_high_confidence() {
+        let result = identify("$2b$12$abcdefghijklmnopqrstuv");
+        assert_eq!(result[0].algorithm, "bcrypt");
+        assert_eq!(result[0].confidence, Confidence::High);
+    }
+
+    #[test]
+    fn argon2id_prefix_is_recognized() {
+        let result = identify("$argon2id$v=19$m=65536,t=3,p=4$c2FsdA$aGFzaA");
+        assert_eq!(result[0].algorithm, "Argon2id");
+    }
+
+    #[test]
+    fn md5_length_is_medium_confidence() {
+        let result = identify("5f4dcc3b5aa765d61d8327deb882cf99");
+        assert_eq!(result[0].algorithm, "MD5");
+        assert_eq!(result[0].confidence, Confidence::Medium);
+        let names: Vec<&str> = result.iter().map(|c| c.algorithm.as_str()).collect();
+        assert!(names.contains(&"NTLM"));
+    }
+
+    #[test]
+    fn sha256_length_is_recognized() {
+        let hash = "a".repeat(64);
+        let result = identify(&hash);
+        assert_eq!(result[0].algorithm, "SHA-256");
+    }
+
+    #[test]
+    fn mysql5_is_recognized() {
+        let result = identify("*A4B6157319038724E3560894F7F932C8886EBFCF");
+        assert_eq!(result[0].algorithm, "MySQL5");
+        assert_eq!(result[0].confidence, Confidence::High);
+    }
+
+    #[test]
+    fn mysql5_rejects_lowercase_body() {
+        let result = identify("*a4b6157319038724e3560894f7f932c8886ebfcf");
+        let claimed_mysql5 = !result.is_empty() && result[0].algorithm == "MySQL5";
+        assert!(!claimed_mysql5);
+    }
+
+    #[test]
+    fn netntlmv2_is_recognized() {
+        let sample = format!(
+            "alice::CORP:1122334455667788:{}:{}",
+            "a".repeat(32),
+            "b".repeat(64)
+        );
+        let result = identify(&sample);
+        assert_eq!(result[0].algorithm, "NetNTLMv2");
+    }
+
+    #[test]
+    fn pwdump_line_is_ntlm() {
+        let sample = "Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::";
+        let result = identify(sample);
+        assert_eq!(result[0].algorithm, "NTLM");
+    }
+
+    #[test]
+    fn jwt_is_flagged_as_not_a_hash() {
+        let result = identify("eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.sig");
+        assert!(result[0].algorithm.contains("JWT"));
+        assert_eq!(result[0].confidence, Confidence::Low);
+    }
+
+    #[test]
+    fn base64_blob_is_flagged_as_not_a_hash() {
+        let result = identify("VGhpcyBpcyBub3QgYSBoYXNoLg==");
+        assert!(result[0].algorithm.contains("Base64"));
+    }
+
+    #[test]
+    fn unknown_input_returns_empty() {
+        assert!(identify("just some random text").is_empty());
+    }
+
+    #[test]
+    fn sha1_length_is_recognized() {
+        let result = identify(&"a".repeat(40));
+        assert_eq!(result[0].algorithm, "SHA-1");
+    }
+
+    #[test]
+    fn netntlmv1_is_recognized() {
+        let sample = format!(
+            "alice::CORP:{}:{}:1122334455667788",
+            "a".repeat(48),
+            "b".repeat(48)
+        );
+        let result = identify(&sample);
+        assert_eq!(result[0].algorithm, "NetNTLMv1");
+    }
+
+    #[test]
+    fn whitespace_is_trimmed() {
+        let result = identify("  5f4dcc3b5aa765d61d8327deb882cf99\n");
+        assert_eq!(result[0].algorithm, "MD5");
+    }
+
+    #[test]
+    fn parses_argon2id_params() {
+        let phc = parse_phc("$argon2id$v=19$m=65536,t=3,p=4$c2FsdA$aGFzaA").unwrap();
+        assert_eq!(phc.id, "argon2id");
+        assert_eq!(phc.param("m"), Some("65536"));
+        assert_eq!(phc.param("t"), Some("3"));
+        assert_eq!(phc.param("p"), Some("4"));
+    }
+
+    #[test]
+    fn parses_bcrypt_cost_segment() {
+        let phc = parse_phc("$2b$12$abcdefghijklmnopqrstuv").unwrap();
+        assert_eq!(phc.id, "2b");
+        assert_eq!(phc.segments[1], "12");
+    }
+
+    #[test]
+    fn non_phc_returns_none() {
+        assert!(parse_phc("5f4dcc3b5aa765d61d8327deb882cf99").is_none());
+        assert!(parse_phc("hello").is_none());
+    }
+
+    #[test]
+    fn strong_argon2id_is_secure() {
+        let report = audit("$argon2id$v=19$m=65536,t=3,p=4$c2FsdA$aGFzaA").unwrap();
+        assert_eq!(report.verdict, Verdict::Secure);
+    }
+
+    #[test]
+    fn weak_argon2id_memory_is_flagged() {
+        let report = audit("$argon2id$v=19$m=1024,t=1,p=1$c2FsdA$aGFzaA").unwrap();
+        assert_eq!(report.verdict, Verdict::WeakParams);
+    }
+
+    #[test]
+    fn low_bcrypt_cost_is_weak() {
+        let report = audit("$2b$04$abcdefghijklmnopqrstuv").unwrap();
+        assert_eq!(report.verdict, Verdict::WeakParams);
+    }
+
+    #[test]
+    fn strong_bcrypt_cost_is_secure() {
+        let report = audit("$2b$12$abcdefghijklmnopqrstuv").unwrap();
+        assert_eq!(report.verdict, Verdict::Secure);
+    }
+
+    #[test]
+    fn raw_md5_is_broken() {
+        let report = audit("5f4dcc3b5aa765d61d8327deb882cf99").unwrap();
+        assert_eq!(report.verdict, Verdict::Broken);
+    }
+
+    #[test]
+    fn md5_crypt_is_deprecated() {
+        let report = audit("$1$salt$abcdefghijklmnopqrstuv").unwrap();
+        assert_eq!(report.verdict, Verdict::Deprecated);
+    }
+
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn identify_never_panics(input in ".*") {
+            let _ = identify(&input);
+        }
+
+        #[test]
+        fn parse_phc_never_panics(input in ".*") {
+            let _ = parse_phc(&input);
+        }
+
+        #[test]
+        fn audit_never_panics(input in ".*") {
+            let _ = audit(&input);
+        }
+
+        #[test]
+        fn any_32_hex_is_md5_first(hex in "[0-9a-f]{32}") {
+            let result = identify(&hex);
+            prop_assert_eq!(result[0].algorithm.as_str(), "MD5");
+        }
+    }
+}

saltminer-0.1.0/saltminer-py/Cargo.lock

@@ -0,0 +1,217 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "cc"
+version = "1.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad534f4357a5264cce5019c989cf66a4f0dc4e0d1b1d15f8aacec0ff7360273"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+dependencies = [
+ "once_cell",
+ "python3-dll-a",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "python3-dll-a"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d80ba7540edb18890d444c5aa8e1f1f99b1bdf26fb26ae383135325f4a36042b"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "saltminer-core"
+version = "0.0.1"
+
+[[package]]
+name = "saltminer-py"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+ "saltminer-core",
+]
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

saltminer-0.1.0/saltminer-py/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "saltminer-py"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+name = "saltminer"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.23", features = ["extension-module", "abi3-py310", "generate-import-lib"] }
+saltminer-core = { path = "../saltminer-core" }
+
+[workspace]

saltminer-0.1.0/saltminer-py/src/lib.rs

@@ -0,0 +1,27 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+fn identify(input: &str) -> Vec<(String, String, String)> {
+    saltminer_core::identify(input)
+        .into_iter()
+        .map(|c| {
+            (
+                c.algorithm,
+                format!("{:?}", c.confidence).to_lowercase(),
+                c.reason,
+            )
+        })
+        .collect()
+}
+
+#[pyfunction]
+fn audit(input: &str) -> Option<(String, String, String)> {
+    saltminer_core::audit(input).map(|r| (r.algorithm, format!("{:?}", r.verdict), r.detail))
+}
+
+#[pymodule]
+fn saltminer(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(identify, m)?)?;
+    m.add_function(wrap_pyfunction!(audit, m)?)?;
+    Ok(())
+}

saltminer-0.1.0/saltminer-py/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[package]]
+name = "saltminer"
+version = "0.1.0"
+source = { editable = "." }