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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::errors::*;

use crate::engine::ctx::State;
use crate::engine::structs::{byte_array, lua_bytes};
use crate::hlua::{self, AnyLuaValue};
use crate::websockets::WebSocketOptions;
use std::sync::Arc;
use crate::json;
use url::Url;

pub fn ws_connect(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_connect", hlua::function2(move |url: String, options: AnyLuaValue| -> Result<String> {
        let options = WebSocketOptions::try_from(options)
            .context("Invalid websocket options")
            .map_err(|err| state.set_error(Error::from(err)))?;

        let url = Url::parse(&url)
            .context("Failed to parse url")
            .map_err(|err| state.set_error(Error::from(err)))?;

        state.ws_connect(url, &options)
            .map_err(|err| state.set_error(err))
    }))
}

pub fn ws_options(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_options", hlua::function2(move |sock: String, options: AnyLuaValue| -> Result<()> {
        let options = WebSocketOptions::try_from(options)
            .context("Invalid websocket options")
            .map_err(|err| state.set_error(Error::from(err)))?;

        let sock = state.get_ws(&sock);
        let sock = sock.lock().unwrap();

        sock.options(&options)
            .map_err(|err| state.set_error(err))?;

        Ok(())
    }))
}

pub fn ws_recv_text(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_recv_text", hlua::function1(move |sock: String| -> Result<Option<String>> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        let text = sock.read_text()
            .map_err(|err| state.set_error(err))?;

        Ok(text)
    }))
}

pub fn ws_recv_binary(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_recv_binary", hlua::function1(move |sock: String| -> Result<Option<AnyLuaValue>> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        let bytes = sock.read_binary()
            .map_err(|err| state.set_error(err))?
            .map(|bytes| lua_bytes(&bytes));

        Ok(bytes)
    }))
}

pub fn ws_recv_json(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_recv_json", hlua::function1(move |sock: String| -> Result<Option<AnyLuaValue>> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        let json = sock.read_text()
            .map_err(|err| state.set_error(err))?;

        let json = if let Some(json) = json {
            let json = json::decode(json)
                .map_err(|err| state.set_error(err))?;
            Some(json)
        } else {
            None
        };

        Ok(json)
    }))
}

pub fn ws_send_text(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_send_text", hlua::function2(move |sock: String, text: String| -> Result<()> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        sock.write_text(text)
            .map_err(|err| state.set_error(err))?;

        Ok(())
    }))
}

pub fn ws_send_binary(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_send_binary", hlua::function2(move |sock: String, bytes: AnyLuaValue| -> Result<()> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        let bytes = byte_array(bytes)
            .map_err(|err| state.set_error(err))?;

        sock.write_binary(bytes)
            .map_err(|err| state.set_error(err))?;

        Ok(())
    }))
}

pub fn ws_send_json(lua: &mut hlua::Lua, state: Arc<dyn State>) {
    lua.set("ws_send_json", hlua::function2(move |sock: String, json: AnyLuaValue| -> Result<()> {
        let sock = state.get_ws(&sock);
        let mut sock = sock.lock().unwrap();

        let json = json::encode(json)
            .map_err(|err| state.set_error(err))?;

        sock.write_text(json)
            .map_err(|err| state.set_error(err))?;

        Ok(())
    }))
}