ciph 0.1.0

Symmetric cipher layer for async read/write connections.
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

use std::{
    str::FromStr,
    net::SocketAddr,
};

use tokio::net::TcpListener;
use hyper::{
    Body,
    Method,
    Request,
    Response,
    StatusCode,
    server::{
        conn::Http,
        accept::from_stream,
    },
    service::{make_service_fn, service_fn},
};

use ciph::salsa::{Psk, Acceptor, Randomness, TcpListenAcceptor};

async fn echo(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
    match (req.method(), req.uri().path()) {
        (&Method::POST, "/") => Ok(Response::new(req.into_body())),
        _ => {
            let mut not_found = Response::default();
            *not_found.status_mut() = StatusCode::NOT_FOUND;
            Ok(not_found)
        },
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    const PSK_B64: &str = include_str!("example.psk");
    let psk = Psk::from_str(PSK_B64)?;
    let acceptor = Acceptor::new(psk, Randomness::Entropy);
    let args: Vec<String> = std::env::args()
        .collect();

    assert!(args.len() >= 2);

    let listen_addr = args[1].to_owned();
    let addr = SocketAddr::from_str(listen_addr.as_str())?;
    
    let listener = TcpListener::bind(&addr).await?;
    let acceptor = TcpListenAcceptor::new(acceptor, listener);
    let incoming = from_stream(acceptor);
    
    let service = make_service_fn(|_| async {
        Ok::<_, hyper::Error>(service_fn(echo))
    });

    let server = hyper::server::Builder::new(incoming, Http::new())
        .serve(service);

    server.await?;
    
    Ok(())
}