p2ps 1.0.0

Easy to implement TLS security for p2p 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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# P2P-Secure-Conn 🦀

A lightweight, async-first Rust library for establishing **Mutual TLS (mTLS)** connections. Built on top of `tokio-rustls` and `rustls`, it simplifies the process of generating self-signed identities and enforcing strict two-way authentication between peers.



## Features

* **Mutual Authentication (mTLS):** Both the client and the server must present valid certificates to establish a connection.
* **Self-Signed Friendly:** Built-in utility to generate x509 identities on the fly using `rcgen`.
* **Async Ready:** Designed specifically for the `tokio` ecosystem.
* **Simple API:** Wraps complex `rustls` configurations into straightforward `accept` and `connect` functions.

## Usage example (to see a full working example in action check out [file-express](https://github.com/Bicheka/file-express))

Set up crypto provider
```rusthttps://github.com/Bicheka/file-express
    let _ = ring::default_provider().install_default();
```

Peer A generates identity meaning cert and key, and generate fingerprint
```rust
    let (cert, key) = generate_identity()?;
    let hash = get_cert_fingerprint(&cert);
```

Peer B does the same
```rust
    let (cert, key) = generate_identity()?;
    let hash = get_cert_fingerprint(&cert);
```

**The hash must then be shared between them**

Peer A
```rust
let listener = TcpListener::bind("127.0.0.1:0").await?;
let addr = listener.local_addr()?;

let mut secure_conn: SecureConn = accept(
    &listener,
    server_cert,
    server_key,
    client_hash,
).await.expect("Server failed to accept");
```

Peer B
```rust
let mut secure_conn: SecureConn = connect(
    &addr.to_string(),
    server_hash,
    client_cert,
    client_key,
).await?;
```

SecureConnection is a Tls wrapper
```rust
pub struct SecureConn {
    pub stream: TlsStream<TcpStream>
}
```

So you can use **secure_conn** variable like this for example
```rust
    secure_conn.stream.write_all(b"Hello Server").await?;

    let mut buf = [0u8; 12];
    secure_conn.stream.read_exact(&mut buf).await?;
```

License

This project is licensed under the MIT License, see the [LICENSE](LICENSE) file for details.