enseal 0.15.1

Secure, ephemeral secret sharing for developers
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

#[cfg(feature = "server")]
use anyhow::Result;

#[cfg(feature = "server")]
use clap::Args;

#[cfg(feature = "server")]
use crate::server;
#[cfg(feature = "server")]
use crate::ui::display;

#[cfg(feature = "server")]
#[derive(Args)]
pub struct ServeArgs {
    /// Listen port
    #[arg(long, default_value = "4443")]
    pub port: u16,

    /// Bind address
    #[arg(long, default_value = "0.0.0.0")]
    pub bind: String,

    /// Max concurrent channels
    #[arg(long, default_value = "100")]
    pub max_mailboxes: usize,

    /// How long idle channels survive in seconds
    #[arg(long, default_value = "300")]
    pub channel_ttl: u64,

    /// Max WebSocket message size in bytes
    #[arg(long, default_value = "1048576")]
    pub max_payload: usize,

    /// Max new connections per minute per IP
    #[arg(long, default_value = "10")]
    pub rate_limit: usize,

    /// Print server health check and exit
    #[arg(long)]
    pub health: bool,
}

#[cfg(feature = "server")]
pub async fn run(args: ServeArgs) -> Result<()> {
    if args.health {
        return check_health(&args).await;
    }

    let addr = format!("{}:{}", args.bind, args.port);

    let config = server::ServerConfig {
        port: args.port,
        bind: args.bind.clone(),
        max_channels: args.max_mailboxes,
        channel_ttl_secs: args.channel_ttl,
        max_payload_bytes: args.max_payload,
        rate_limit_per_min: args.rate_limit,
    };

    let app = server::build_router(config);

    display::ok(&format!("enseal relay listening on {}", addr));
    eprintln!("  max channels:  {}", args.max_mailboxes);
    eprintln!("  channel TTL:   {}s", args.channel_ttl);
    eprintln!("  max payload:   {} bytes", args.max_payload);
    eprintln!("  rate limit:    {}/min per IP", args.rate_limit);

    let listener = tokio::net::TcpListener::bind(&addr).await?;
    axum::serve(
        listener,
        app.into_make_service_with_connect_info::<std::net::SocketAddr>(),
    )
    .await?;

    Ok(())
}

#[cfg(feature = "server")]
async fn check_health(args: &ServeArgs) -> Result<()> {
    let _url = format!("http://{}:{}/health", args.bind, args.port);
    // Use a simple TCP check since we don't want to add reqwest as a dep
    match tokio::net::TcpStream::connect(format!("{}:{}", args.bind, args.port)).await {
        Ok(_) => {
            display::ok(&format!(
                "relay is reachable at {}:{}",
                args.bind, args.port
            ));
            Ok(())
        }
        Err(e) => {
            display::error(&format!(
                "cannot connect to {}:{}: {}",
                args.bind, args.port, e
            ));
            std::process::exit(1);
        }
    }
}