openaws-vpn-client 0.1.4

Unofficial open-source AWS VPN client written in Rust
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

use crate::cmd::{connect_ovpn, ProcessInfo};
use crate::config::Pwd;
use crate::state_manager::StateManager;
use crate::task::{OavcProcessTask, OavcTask};
use crate::VpnApp;
use std::collections::HashMap;
use std::ops::Deref;
use std::rc::Rc;
use std::sync::mpsc::SyncSender;
use std::sync::Arc;
use tokio::sync::Mutex;
use warp::http::StatusCode;
use warp::reply::WithStatus;
use warp::{Filter, Rejection};

pub struct SamlServer {}

impl SamlServer {
    pub fn new() -> SamlServer {
        SamlServer {}
    }

    pub fn start_server(&self, app: Rc<VpnApp>) {
        app.log.append("Starting SAML server at 0.0.0.0:35001...");
        let (tx, rx) = std::sync::mpsc::sync_channel::<Saml>(1);

        println!("Starting server");
        let sender = warp::any().map(move || tx.clone());

        let pwd = app.config.pwd.clone();
        let pwd = warp::any().map(move || pwd.clone());
        let runtime = app.runtime.clone();

        let saml = warp::post()
            .and(warp::body::form())
            .and(sender)
            .and(pwd)
            .and_then(
                async move |data: HashMap<String, String>,
                            sender: SyncSender<Saml>,
                            pwd: Arc<Mutex<Option<Pwd>>>| {
                    let pwd = pwd.lock().await;
                    let saml = Saml {
                        data: data["SAMLResponse"].clone(),
                        pwd: pwd.deref().as_ref().unwrap().pwd.clone(),
                    };
                    sender.send(saml).unwrap();
                    println!("Got SAML data!");

                    Result::<WithStatus<_>, Rejection>::Ok(warp::reply::with_status(
                        "Got SAMLResponse field, it is now safe to close this window",
                        StatusCode::OK,
                    ))
                },
            );

        let handle = runtime.spawn(warp::serve(saml).run(([0, 0, 0, 0], 35001)));

        let log = app.log.clone();
        let join = OavcTask {
            name: "SAML Server".to_string(),
            handle,
            log,
        };

        app.server.replace(Some(join));
        let log = app.log.clone();
        let addr = app.config.addresses.clone();
        let port = app.config.remote.clone();
        let config = app.config.config.clone();
        let st = app.openvpn_connection.clone();
        let stager = app.state.clone();
        let manager = app.connection_manager.clone();

        std::thread::spawn(move || loop {
            let data = rx.recv().unwrap();
            {
                log.append(format!("SAML Data: {:?}...", &data.data[..6]).as_str());
            }

            let addr = {
                let addr = addr.clone();
                let addr = addr.lock().unwrap();
                addr.as_ref().unwrap()[0].to_string()
            };
            let config = {
                let config = config.clone();
                let config = config.lock().unwrap();
                config.as_ref().unwrap().clone()
            };
            let port = {
                let port = port.clone();
                let port = port.lock().unwrap();
                port.as_ref().unwrap().clone().1
            };

            let info = Arc::new(ProcessInfo::new());

            let handle = {
                let info = info.clone();
                let log = log.clone();
                let manager = manager.clone();
                runtime.clone().spawn(async move {
                    let con = connect_ovpn(log.clone(), config, addr, port, data, info).await;
                    let man = manager.lock().unwrap();
                    man.as_ref().unwrap().try_disconnect();
                    con
                })
            };

            let task =
                OavcProcessTask::new("OpenVPN Connection".to_string(), handle, log.clone(), info);
            {
                let mut st = st.lock().unwrap();
                *st = Some(task);
            }

            let state_manager = stager.clone();
            StateManager::change_state(move || {
                let stager = state_manager.lock().unwrap();
                stager.as_ref().unwrap().set_connected();
            });
        });
    }
}

#[derive(Debug, Clone)]
pub struct Saml {
    pub data: String,
    pub pwd: String,
}

unsafe impl Send for Saml {}
unsafe impl Sync for Saml {}