recon-cli 0.77.13

Versatile network reconnaissance CLI: HTTP/TLS/DNS, multi-protocol probes, and a Rhai script engine
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Norwegian VAT / MVA (organisasjonsnummer).
//!
//! 9 digits. Weights `[3,2,7,6,5,4,3,2]` on the first 8 digits.
//! `check_raw = 11 - (sum mod 11)`. If `check_raw == 11`, check digit = 0.
//! If `check_raw == 10`, the number is structurally invalid.
//!
//! Source: Brønnøysundregistrene (Norwegian Register Centre), python-stdnum no.mva.
//! Hand-verified: 974760673 → sum=173, 173%11=8, check_raw=3, last digit=3 ✓

use super::super::{sanitize, Verdict};
use anyhow::{anyhow, Result};

const WEIGHTS: [u32; 8] = [3, 2, 7, 6, 5, 4, 3, 2];

pub fn verify_no_vat(input: &str) -> Verdict {
    let clean = match super::strip_vat_prefix(input, "NO") {
        Ok(body) => body,
        Err(v) => return v,
    };
    // Strip optional "MVA" suffix (users may type "974760673MVA")
    let clean = if clean.to_ascii_uppercase().ends_with("MVA") {
        clean[..clean.len() - 3].to_string()
    } else {
        clean
    };
    if clean.len() != 9 {
        return Verdict::Invalid {
            reason: format!("expected 9 digits, got {}", clean.len()),
        };
    }
    if !clean.chars().all(|c| c.is_ascii_digit()) {
        return Verdict::Invalid {
            reason: "non-digit input".into(),
        };
    }
    let digits: Vec<u32> = clean.chars().map(|c| c.to_digit(10).unwrap()).collect();
    let sum: u32 = digits[..8].iter().zip(WEIGHTS.iter()).map(|(d, w)| d * w).sum();
    let check_raw = 11 - (sum % 11);
    let check = if check_raw == 11 {
        0
    } else if check_raw == 10 {
        return Verdict::Invalid {
            reason: "NO VAT check_raw == 10: structurally invalid number".into(),
        };
    } else {
        check_raw
    };
    if check == digits[8] {
        Verdict::Valid {
            formatted: format!("NO{}", clean),
            detected: "Norwegian VAT / MVA (organisasjonsnummer)".into(),
            comment: String::new(),
        }
    } else {
        Verdict::Invalid {
            reason: format!("NO VAT check mismatch: expected {}, got {}", check, digits[8]),
        }
    }
}

pub fn create_no_vat(input: &str, _raw: bool) -> Result<String> {
    let clean = sanitize(input, false);
    if clean.len() != 8 {
        return Err(anyhow!("expected 8 digits (body), got {}", clean.len()));
    }
    if !clean.chars().all(|c| c.is_ascii_digit()) {
        return Err(anyhow!("non-digit input"));
    }
    let digits: Vec<u32> = clean.chars().map(|c| c.to_digit(10).unwrap()).collect();
    let sum: u32 = digits.iter().zip(WEIGHTS.iter()).map(|(d, w)| d * w).sum();
    let check_raw = 11 - (sum % 11);
    if check_raw == 10 {
        return Err(anyhow!("this 8-digit body produces check_raw=10, which is structurally invalid in the NO MVA scheme"));
    }
    let check = if check_raw == 11 { 0 } else { check_raw };
    Ok(format!("NO{}{}", clean, check))
}

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

    /// Brønnøysundregistrene's own orgnr — verified by hand.
    /// sum=173, 173%11=8, check_raw=3, last digit 3 ✓
    #[test]
    fn no_vat_reference_974760673() {
        match verify_no_vat("974760673") {
            Verdict::Valid { formatted, detected, .. } => {
                assert_eq!(formatted, "NO974760673");
                assert!(detected.contains("Norwegian"));
            }
            v => panic!("{:?}", v),
        }
    }

    #[test]
    fn no_vat_accepts_no_prefix() {
        match verify_no_vat("NO974760673") {
            Verdict::Valid { .. } => {}
            v => panic!("{:?}", v),
        }
    }

    #[test]
    fn no_vat_accepts_mva_suffix() {
        match verify_no_vat("974760673MVA") {
            Verdict::Valid { .. } => {}
            v => panic!("{:?}", v),
        }
    }

    #[test]
    fn no_vat_rejects_bad_length() {
        match verify_no_vat("97476067") {
            Verdict::Invalid { .. } => {}
            v => panic!("{:?}", v),
        }
    }

    #[test]
    fn no_vat_rejects_wrong_check() {
        match verify_no_vat("974760674") {
            Verdict::Invalid { reason } => assert!(reason.contains("check mismatch")),
            v => panic!("{:?}", v),
        }
    }

    #[test]
    fn no_vat_round_trip() {
        // Use first 8 digits of 974760673
        let body = "97476067";
        let full = create_no_vat(body, false).unwrap();
        assert_eq!(full, "NO974760673");
        match verify_no_vat(&full) {
            Verdict::Valid { .. } => {}
            v => panic!("{:?}", v),
        }
    }
}