seedfaker-core 0.4.0-alpha.1

Core library for seedfaker — deterministic synthetic generator for realistic, correlated, and noisy test records
Documentation 
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

use crate::ctx::GenContext;
use crate::rng::Rng;

fn luhn_check_digit(digits: &[u8]) -> u8 {
    let mut sum = 0u32;
    for (i, &d) in digits.iter().rev().enumerate() {
        let mut v = u32::from(d);
        if i % 2 == 0 {
            v *= 2;
            if v > 9 {
                v -= 9;
            }
        }
        sum += v;
    }
    ((10 - (sum % 10)) % 10) as u8
}

fn push_card_digits(rng: &mut Rng, buf: &mut String, prefix: &[u8], total_len: usize) {
    let random_count = total_len.saturating_sub(prefix.len()).saturating_sub(1);
    let mut digits: Vec<u8> = Vec::with_capacity(total_len);
    digits.extend_from_slice(prefix);
    for _ in 0..random_count {
        digits.push(rng.urange(0, 9) as u8);
    }
    let check = luhn_check_digit(&digits);
    digits.push(check);
    buf.reserve(total_len);
    for d in &digits {
        buf.push((b'0' + d) as char);
    }
}

// Format: ISO/IEC 7812 + Luhn algorithm (ISO/IEC 7812-1)
pub fn gen(ctx: &mut GenContext<'_>, buf: &mut String) {
    let sep = match ctx.modifier {
        "space" => " ",
        "dash" => "-",
        "plain" => "",
        _ => {
            let arr = [" ", "-", ""];
            arr[ctx.rng.urange(0, arr.len() - 1)]
        }
    };

    let mut digits_buf = String::with_capacity(19);
    let formatted = match ctx.rng.urange(0, 3) {
        0 => {
            push_card_digits(&mut ctx.rng, &mut digits_buf, &[4], 16);
            format_card_4444(&digits_buf, sep)
        }
        1 => {
            let sub = ctx.rng.urange(1, 5) as u8;
            push_card_digits(&mut ctx.rng, &mut digits_buf, &[5, sub], 16);
            format_card_4444(&digits_buf, sep)
        }
        2 => {
            let arr = [4u8, 7];
            let mid = arr[ctx.rng.urange(0, arr.len() - 1)];
            push_card_digits(&mut ctx.rng, &mut digits_buf, &[3, mid], 15);
            format_card_amex(&digits_buf, sep)
        }
        _ => {
            push_card_digits(&mut ctx.rng, &mut digits_buf, &[6, 0, 1, 1], 16);
            format_card_4444(&digits_buf, sep)
        }
    };
    buf.push_str(&formatted);
}

fn format_card_4444(n: &str, sep: &str) -> String {
    if sep.is_empty() {
        return n.to_string();
    }
    let mut out = String::with_capacity(n.len() + 3 * sep.len());
    out.push_str(&n[..4]);
    out.push_str(sep);
    out.push_str(&n[4..8]);
    out.push_str(sep);
    out.push_str(&n[8..12]);
    out.push_str(sep);
    out.push_str(&n[12..]);
    out
}

fn format_card_amex(n: &str, sep: &str) -> String {
    if sep.is_empty() {
        return n.to_string();
    }
    let mut out = String::with_capacity(n.len() + 2 * sep.len());
    out.push_str(&n[..4]);
    out.push_str(sep);
    out.push_str(&n[4..10]);
    out.push_str(sep);
    out.push_str(&n[10..]);
    out
}