camo-rs 0.1.1

Camo proxies insecure HTTP images over HTTPS, preventing mixed content warnings on secure pages.
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

use camo::{
    server::{
        config::{Command, Config},
        router::{create_router, AppState},
    },
    {CamoUrl, Encoding},
};
use clap::Parser;
use std::sync::Arc;
use tracing::info;
use tracing_subscriber::EnvFilter;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let cli = Config::parse();

    let key = cli
        .key
        .as_ref()
        .ok_or_else(|| anyhow::anyhow!("CAMO_KEY is required for signing"))?;

    match &cli.command {
        Some(Command::Sign { url, base, base64 }) => {
            let camo = CamoUrl::new(key).with_encoding(if *base64 {
                Encoding::Base64
            } else {
                Encoding::Hex
            });

            let signed = camo.sign(url);

            if base.is_empty() {
                println!("Digest: {}", signed.digest);
                println!("Encoded URL: {}", signed.encoded_url);
                println!("Path: {}", signed.to_path());
            } else {
                println!("{}", signed.to_url(base));
            }
        }
        Some(Command::Serve) | None => {
            // Initialize logging
            tracing_subscriber::fmt()
                .with_env_filter(
                    EnvFilter::try_from_default_env()
                        .unwrap_or_else(|_| EnvFilter::new(&cli.log_level)),
                )
                .init();

            // Initialize metrics if enabled
            if cli.metrics {
                let builder = metrics_exporter_prometheus::PrometheusBuilder::new();
                builder
                    .install()
                    .expect("Failed to install Prometheus recorder");
            }

            let listen = cli.listen.clone();
            let config = Arc::new(Config {
                key: Some(key.clone()),
                ..cli
            });

            // Create app state
            let state = Arc::new(AppState::from_config(&config));

            // Create router
            let app = create_router(state);

            // Start server
            let listener = tokio::net::TcpListener::bind(&listen).await?;
            info!("camo-rs listening on {}", listen);

            axum::serve(listener, app).await?;
        }
    }

    Ok(())
}