sn0int 0.25.0

Semi-automatic OSINT framework and package manager
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
98
99
100
101
102
103
104
105

use crate::errors::*;

use crate::engine::ctx::State;
use crate::engine::structs::LuaList;
use crate::hlua::{self, AnyLuaValue};
use regex::{Regex, Captures};
use std::sync::Arc;


fn capture_to_lua(caps: &Captures) -> AnyLuaValue {
    let mut i = 0;
    let mut list = LuaList::new();
    while let Some(cap) = caps.get(i) {
        list.push_str(cap.as_str());
        i += 1;
    }
    list.into()
}

pub fn regex_find(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("regex_find", hlua::function2(move |regex: String, data: String| -> Result<AnyLuaValue> {
        let re = Regex::new(&regex)
            .map_err(|err| state.set_error(Error::from(err)))?;

        match re.captures(&data) {
            Some(caps) => Ok(capture_to_lua(&caps)),
            None => Ok(AnyLuaValue::LuaNil),
        }
    }))
}

pub fn regex_find_all(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("regex_find_all", hlua::function2(move |regex: String, data: String| -> Result<Vec<AnyLuaValue>> {
        let re = Regex::new(&regex)
            .map_err(|err| state.set_error(Error::from(err)))?;

        let list = re.captures_iter(&data)
            .map(|x| capture_to_lua(&x))
            .collect();

        Ok(list)
    }))
}


#[cfg(test)]
mod tests {
    use crate::engine::ctx::Script;

    #[test]
    fn verify_find() {
        let script = Script::load_unchecked(r#"
        function run()
            m = regex_find(".(.)", "abcdef")

            if m == nil then
                return 'No captures'
            end

            if m[1] ~= 'ab' then
                return 'Incorrect result in m[1]'
            end

            if m[2] ~= 'b' then
                return 'Incorrect result in m[2]'
            end
        end
        "#).expect("Failed to load script");
        script.test().expect("Script failed");
    }

    #[test]
    fn verify_find_all() {
        let script = Script::load_unchecked(r#"
        function run()
            m = regex_find_all(".(.)", "abcdef")

            if m[1][1] ~= 'ab' then
                return 'Incorrect result in m[1][1]'
            end

            if m[1][2] ~= 'b' then
                return 'Incorrect result in m[1][2]'
            end

            if m[2][1] ~= 'cd' then
                return 'Incorrect result in m[2][1]'
            end

            if m[2][2] ~= 'd' then
                return 'Incorrect result in m[2][2]'
            end

            if m[3][1] ~= 'ef' then
                return 'Incorrect result in m[3][1]'
            end

            if m[3][2] ~= 'f' then
                return 'Incorrect result in m[3][2]'
            end
        end
        "#).expect("Failed to load script");
        script.test().expect("Script failed");
    }
}