Rustls

https://docs.rs/rustls/latest/rustls
Admin
Rustls is a modern TLS library implementing TLS1.2 and TLS1.3, prioritizing cryptographic security...
Tokens:563,328
Snippets:5,067
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Run client example and show first lines of output

Source: https://docs.rs/rustls/latest/rustls/crypto/struct.CryptoProvider.html

Command to run the client example and pipe the first 3 lines of output, showing the ciphersuite and HTTP response headers.

```bash
$ cargo run --example client | head -3
Current ciphersuite: TLS13_CHACHA20_POLY1305_SHA256
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 19899
```

--------------------------------

### get example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns a reference to an element or subslice by index or range. Returns None for out-of-bounds indices or ranges.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### SupportedKxGroup::start_and_complete

Source: https://docs.rs/rustls/latest/rustls/crypto/trait.SupportedKxGroup.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts and completes a key exchange in one operation. The default implementation calls start() and then complete() on the result, suitable for Diffie-Hellman-like algorithms. Override if there is a data dependency between our key share and the peer's.

```APIDOC
## SupportedKxGroup::start_and_complete

### Description
Starts and completes a key exchange in one operation. The default implementation calls start() and then complete() on the result, suitable for Diffie-Hellman-like algorithms. Override if there is a data dependency between our key share and the peer's.

### Method
start_and_complete

### Signature
fn start_and_complete(&self, peer_pub_key: &[u8]) -> Result<CompletedKeyExchange, Error>

### Parameters
- **self** (&Self) - Required - The trait object.
- **peer_pub_key** (&[u8]) - Required - The peer's public key bytes.

### Returns
- **Result<CompletedKeyExchange, Error>** - The completed key exchange on success, or an Error on failure.
```

--------------------------------

### Install FIPS provider as process default

Source: https://docs.rs/rustls/latest/rustls/crypto/fn.default_fips_provider.html

Installs the FIPS provider as the process-default provider. Panics if a default provider is already set.

```rust
rustls::crypto::default_fips_provider().install_default()
    .expect("default provider already set elsewhere");
```

--------------------------------

### windows example with short slice

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

When the slice is shorter than the window size, the iterator returns no values.

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

--------------------------------

### Accepted::client_hello

Source: https://docs.rs/rustls/latest/rustls/server/struct.Accepted.html?search=u32+-%3E+bool

Get the ClientHello for this connection.

```APIDOC
## Accepted::client_hello

### Description
Get the `ClientHello` for this connection.

### Method
`client_hello(&self) -> ClientHello<'_>`

### Parameters
None.

### Returns
- `ClientHello<'_>` - The ClientHello message.

### Example
```rust
let client_hello = accepted.client_hello();
```
```

--------------------------------

### HpkeAwsLcRs::setup_opener

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=std%3A%3Avec

Sets up an opener context for the secret key with application supplied info.

```APIDOC
## HpkeAwsLcRs::setup_opener

### Description
Set up an opener context for the secret key `secret_key` with application supplied `info`.

### Method
`setup_opener`

### Signature
```rust
fn setup_opener(
    &self,
    enc: &EncapsulatedSecret,
    info: &[u8],
    secret_key: &HpkePrivateKey,
) -> Result<Box<dyn HpkeOpener + 'static>, Error>
```

### Parameters
- `enc` (`&EncapsulatedSecret`) - Required - The encapsulated secret.
- `info` (`&[u8]`) - Required - Application supplied info.
- `secret_key` (`&HpkePrivateKey`) - Required - The recipient private key.

### Returns
- `Result<Box<dyn HpkeOpener + 'static>, Error>` - On success, returns an opener context.

```

--------------------------------

### as_chunks_mut: Mutable chunking with remainder

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Splits the slice into a slice of N-element arrays starting at the beginning, with a mutable remainder slice. Panics if N is zero. The example shows modifying chunks and the remainder.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);
```

--------------------------------

### rsplitn: Split slice from end at most n times by predicate

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html?search=

Splits a slice at most n times by a predicate, starting from the end and working backwards. The matched elements are excluded. This example prints groups [50] and [10, 40, 30, 20].

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}

```

--------------------------------

### HpkeAwsLcRs::setup_opener

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=u32+-%3E+bool

Sets up an opener context for the secret key with application supplied info.

```APIDOC
## HpkeAwsLcRs::setup_opener

### Description
Set up an opener context for the secret key `secret_key` with application supplied `info`.

### Method
setup_opener

### Signature
fn setup_opener(&self, enc: &EncapsulatedSecret, info: &[u8], secret_key: &HpkePrivateKey) -> Result<Box<dyn HpkeOpener + 'static>, Error>

### Parameters
- **enc** (&EncapsulatedSecret) - Required - The encapsulated secret.
- **info** (&[u8]) - Required - Application supplied info.
- **secret_key** (&HpkePrivateKey) - Required - The secret key.

### Returns
- **Result<Box<dyn HpkeOpener + 'static>, Error>** - On success, returns an opener context.

```

--------------------------------

### as_chunks: Split slice into N-element chunks with remainder

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Splits the slice into a slice of N-element arrays starting at the beginning, with a remainder slice of length less than N. Panics if N is zero. The example shows splitting a 5-element slice into 2-element chunks and a remainder.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);
```

--------------------------------

### HpkeAwsLcRs::setup_opener

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=

Sets up an opener context for the secret key with application-supplied info.

```APIDOC
## HpkeAwsLcRs::setup_opener

### Description
Set up an opener context for the secret key `secret_key` with application supplied `info`.

### Method
setup_opener

### Signature
fn setup_opener(&self, enc: &EncapsulatedSecret, info: &[u8], secret_key: &HpkePrivateKey) -> Result<Box<dyn HpkeOpener + 'static>, Error>

### Parameters
- **enc** (`&EncapsulatedSecret`) - Required - The encapsulated secret.
- **info** (`&[u8]`) - Required - Application-supplied info.
- **secret_key** (`&HpkePrivateKey`) - Required - The secret key.

### Returns
- **Result<Box<dyn HpkeOpener + 'static>, Error>** - On success, returns an opener context.

```

--------------------------------

### Hpke::setup_opener

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html

Sets up an opener context for the secret key with application supplied info.

```APIDOC
## Hpke::setup_opener

### Description
Set up an opener context for the secret key `secret_key` with application supplied `info`.

### Method
setup_opener

### Signature
```rust
fn setup_opener(
    &self,
    enc: &EncapsulatedSecret,
    info: &[u8],
    secret_key: &HpkePrivateKey,
) -> Result<Box<dyn HpkeOpener + 'static>, Error>
```

### Parameters
- `enc` (&EncapsulatedSecret) - Required - The encapsulated secret.
- `info` (&[u8]) - Required - Application supplied info.
- `secret_key` (&HpkePrivateKey) - Required - The recipient private key.

### Returns
- `Result<Box<dyn HpkeOpener + 'static>, Error>` - On success, returns an opener context.

```

--------------------------------

### as_rchunks: Split slice into N-element chunks from the end

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Splits the slice into a slice of N-element arrays starting at the end, with a remainder slice of length less than N. Panics if N is zero. The example shows splitting a 5-element slice into 2-element chunks and a remainder at the beginning.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

--------------------------------

### escape_ascii example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Example from the documentation of the escape_ascii method, showing how to escape a byte slice as an ASCII string.

```rust
let s = b"0\t\r\n'\"\\\x9d";
let escaped = s.escape_ascii().to_string();
assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
```

--------------------------------

### Example: Using Acceptor with TcpListener

Source: https://docs.rs/rustls/latest/rustls/server/struct.Acceptor.html?search=

Demonstrates how to create an Acceptor, read TLS data from a stream, accept a connection, choose a ServerConfig based on the ClientHello, and convert to a ServerConnection.

```rust
use rustls::server::{Acceptor, ServerConfig};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
for stream in listener.incoming() {
    let mut stream = stream.unwrap();
    let mut acceptor = Acceptor::default();
    let accepted = loop {
        acceptor.read_tls(&mut stream).unwrap();
        if let Some(accepted) = acceptor.accept().unwrap() {
            break accepted;
        }
    };

    // For some user-defined choose_server_config:
    let config = choose_server_config(accepted.client_hello());
    let conn = accepted
        .into_connection(config)
        .unwrap();

    // Proceed with handling the ServerConnection.
}
```

--------------------------------

### take

Source: https://docs.rs/rustls/latest/rustls/struct.Reader.html?search=

Creates an adapter that reads at most limit bytes from it.

```APIDOC
## take

### Description
Creates an adapter which will read at most `limit` bytes from it.

### Method
`fn take(self, limit: u64) -> Take<Self> where Self: Sized`

### Parameters
- **limit** (`u64`) - Required - Maximum number of bytes to read.

### Returns
- `Take<Self>` - A take adapter.

```

--------------------------------

### len example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the number of elements in the slice. The example asserts that a slice of three elements has length 3.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### trim_ascii_end example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Example from the documentation of the trim_ascii_end method, showing how to trim trailing ASCII whitespace from a byte slice.

```rust
assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
assert_eq!(b"  ".trim_ascii_end(), b"");
assert_eq!(b"".trim_ascii_end(), b"");
```

--------------------------------

### fn take(self, limit: u64) -> Take<Self>

Source: https://docs.rs/rustls/latest/rustls/struct.Reader.html?search=u32+-%3E+bool

Creates an adapter that reads at most limit bytes.

```APIDOC
## fn take(self, limit: u64) -> Take<Self>

### Description
Creates an adapter which will read at most `limit` bytes from it.

### Method
take

### Parameters
- **limit** (`u64`) - Required - The maximum number of bytes to read.

### Returns
- `Take<Self>` - A take adapter.

```

--------------------------------

### trim_ascii_start example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Example from the documentation of the trim_ascii_start method, showing how to trim leading ASCII whitespace from a byte slice.

```rust
assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");
```

--------------------------------

### split_last_mut example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the last and all the rest of the elements of the slice, or `None` if it is empty. The example modifies the last element and the rest.

```rust
let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);
```

--------------------------------

### RootCertStore::empty

Source: https://docs.rs/rustls/latest/rustls/struct.RootCertStore.html

Creates a new, empty RootCertStore.

```APIDOC
## RootCertStore::empty

### Description
Creates a new, empty `RootCertStore`.

### Method
`pub fn empty() -> Self`

### Parameters
None.

### Returns
A new empty `RootCertStore`.

```

--------------------------------

### KeyLogFile::new

Source: https://docs.rs/rustls/latest/rustls/struct.KeyLogFile.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new KeyLogFile instance. The environment variable SSLKEYLOGFILE is inspected and the named file is opened during this call.

```APIDOC
## KeyLogFile::new

### Description
Creates a new KeyLogFile instance. The environment variable SSLKEYLOGFILE is inspected and the named file is opened during this call.

### Method
new

### Signature
pub fn new() -> Self

### Parameters
None

### Returns
- **Self** - A new KeyLogFile instance.

### Errors
If the file cannot be opened, this does nothing but logs errors at warning-level.
```

--------------------------------

### split_last example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the last and all the rest of the elements of the slice, or `None` if it is empty. The example destructures the result into last and elements.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

--------------------------------

### split_first_mut example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the first and all the rest of the elements of the slice, or `None` if it is empty. The example modifies the first element and the rest.

```rust
let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);
```

--------------------------------

### Load root certificates from webpki_roots

Source: https://docs.rs/rustls/latest/rustls/index.html?search=std%3A%3Avec

Creates a RootCertStore from the Mozilla root certificates provided by the webpki_roots crate. This is the first step to authenticate the server.

```rust
let root_store = rustls::RootCertStore::from_iter(
    webpki_roots::TLS_SERVER_ROOTS
        .iter()
        .cloned(),
);
```

--------------------------------

### split_first example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the first and all the rest of the elements of the slice, or `None` if it is empty. The example destructures the result into first and elements.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

--------------------------------

### SupportedKxGroup::start

Source: https://docs.rs/rustls/latest/rustls/crypto/trait.SupportedKxGroup.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a key exchange by preparing an ephemeral secret key and corresponding public key in the supported group. Returns a boxed ActiveKeyExchange or an error if the random source fails.

```APIDOC
## SupportedKxGroup::start

### Description
Starts a key exchange by preparing an ephemeral secret key and corresponding public key in the supported group. The key exchange can be completed by calling ActiveKeyExchange or discarded.

### Method
start

### Signature
fn start(&self) -> Result<Box<dyn ActiveKeyExchange>, Error>

### Parameters
- **self** (&Self) - Required - The trait object.

### Returns
- **Result<Box<dyn ActiveKeyExchange>, Error>** - A boxed ActiveKeyExchange on success, or an Error if the random source fails during ephemeral key generation.

### Errors
- **Error** - Can fail if the random source fails during ephemeral key generation.
```

--------------------------------

### HpkeAwsLcRs::setup_sealer

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=

Sets up a sealer context for the receiver public key with application-supplied info.

```APIDOC
## HpkeAwsLcRs::setup_sealer

### Description
Set up a sealer context for the receiver public key `pub_key` with application supplied `info`.

### Method
setup_sealer

### Signature
fn setup_sealer(&self, info: &[u8], pub_key: &HpkePublicKey) -> Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>

### Parameters
- **info** (`&[u8]`) - Required - Application-supplied info.
- **pub_key** (`&HpkePublicKey`) - Required - The receiver public key.

### Returns
- **Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>** - On success, returns the encapsulated secret and a sealer context.

```

--------------------------------

### trim_ascii example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Example from the documentation of the trim_ascii method, showing how to trim both leading and trailing ASCII whitespace from a byte slice.

```rust
assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
assert_eq!(b"  ".trim_ascii(), b"");
assert_eq!(b"".trim_ascii(), b"");
```

--------------------------------

### HpkeAwsLcRs::setup_sealer

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=std%3A%3Avec

Sets up a sealer context for the receiver public key with application supplied info.

```APIDOC
## HpkeAwsLcRs::setup_sealer

### Description
Set up a sealer context for the receiver public key `pub_key` with application supplied `info`.

### Method
`setup_sealer`

### Signature
```rust
fn setup_sealer(
    &self,
    info: &[u8],
    pub_key: &HpkePublicKey,
) -> Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>
```

### Parameters
- `info` (`&[u8]`) - Required - Application supplied info.
- `pub_key` (`&HpkePublicKey`) - Required - The receiver public key.

### Returns
- `Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>` - On success, returns the encapsulated secret and a sealer context.

```

--------------------------------

### sort_by_key example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sorts a mutable slice by the absolute value of its elements. The example shows sorting a vector of integers by their absolute values.

```rust
v.sort_by_key(|k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);
```

--------------------------------

### Slice last element example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html?search=

Example for a slice method that returns the last element. Asserts the slice and last element values.

```rust
assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'d');
```

--------------------------------

### HpkeAwsLcRs::setup_sealer

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html?search=u32+-%3E+bool

Sets up a sealer context for the receiver public key with application supplied info.

```APIDOC
## HpkeAwsLcRs::setup_sealer

### Description
Set up a sealer context for the receiver public key `pub_key` with application supplied `info`.

### Method
setup_sealer

### Signature
fn setup_sealer(&self, info: &[u8], pub_key: &HpkePublicKey) -> Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>

### Parameters
- **info** (&[u8]) - Required - Application supplied info.
- **pub_key** (&HpkePublicKey) - Required - The receiver public key.

### Returns
- **Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>** - On success, returns the encapsulated secret and a sealer context.

```

--------------------------------

### last_mut example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns a mutable reference to the last item in the slice, or `None` if it is empty. The example modifies the last element to 10.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

--------------------------------

### Build a ClientConfig with root certificates

Source: https://docs.rs/rustls/latest/rustls/index.html?search=std%3A%3Avec

Creates a ClientConfig using the builder pattern, adding the root store and disabling client authentication. Typically one config is created per process and reused for all connections.

```rust
let config = rustls::ClientConfig::builder()
    .with_root_certificates(root_store)
    .with_no_client_auth();
```

--------------------------------

### first_mut example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns a mutable reference to the first element of the slice, or `None` if it is empty. The example modifies the first element to 5.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

--------------------------------

### Keys::initial

Source: https://docs.rs/rustls/latest/rustls/quic/struct.Keys.html?search=

Constructs a Keys instance for use with initial packets. This is a public method that users can call directly to obtain the complete set of keys for QUIC initial communication.

```APIDOC
## Keys::initial

### Description
Constructs a complete set of keys for use with initial packets in QUIC communication.

### Method
`pub fn initial(version: Version, suite: &'static Tls13CipherSuite, quic: &'static dyn Algorithm, client_dst_connection_id: &[u8], side: Side) -> Self`

### Parameters
- `version` (Version) - Required - The QUIC version.
- `suite` (&'static Tls13CipherSuite) - Required - The TLS 1.3 cipher suite to use.
- `quic` (&'static dyn Algorithm) - Required - The QUIC algorithm.
- `client_dst_connection_id` (&[u8]) - Required - The client's destination connection ID.
- `side` (Side) - Required - The side (client or server) for which keys are constructed.

### Returns
- `Self` - A new `Keys` instance containing local and remote directional keys.

```

--------------------------------

### new

Source: https://docs.rs/rustls/latest/rustls/server/struct.UnbufferedServerConnection.html

Creates a new UnbufferedServerConnection with the given server configuration.

```APIDOC
## new

### Description
Creates a new `UnbufferedServerConnection` with the given server configuration.

### Method
Constructor

### Signature
`pub fn new(config: Arc<ServerConfig>) -> Result<Self, Error>`

### Parameters
- `config` (Arc<ServerConfig>) - Required - Controls how the connection behaves in the TLS protocol.

### Returns
- `Result<Self, Error>` - The new connection or an error.
```

--------------------------------

### Hpke::setup_sealer

Source: https://docs.rs/rustls/latest/rustls/crypto/aws_lc_rs/hpke/struct.HpkeAwsLcRs.html

Sets up a sealer context for the receiver public key with application supplied info.

```APIDOC
## Hpke::setup_sealer

### Description
Set up a sealer context for the receiver public key `pub_key` with application supplied `info`.

### Method
setup_sealer

### Signature
```rust
fn setup_sealer(
    &self,
    info: &[u8],
    pub_key: &HpkePublicKey,
) -> Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>
```

### Parameters
- `info` (&[u8]) - Required - Application supplied info.
- `pub_key` (&HpkePublicKey) - Required - The receiver public key.

### Returns
- `Result<(EncapsulatedSecret, Box<dyn HpkeSealer + 'static>), Error>` - On success, returns the encapsulated secret and a sealer context.

```

--------------------------------

### is_empty example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns `true` if the slice has a length of 0. The example shows a non-empty slice returns false, and an empty slice returns true.

```rust
let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());
```

--------------------------------

### last example

Source: https://docs.rs/rustls/latest/rustls/crypto/cipher/struct.BorrowedPayload.html

Returns the last element of the slice, or `None` if it is empty. The example shows a non-empty slice returns `Some(&30)`, and an empty slice returns `None`.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Keys::initial

Source: https://docs.rs/rustls/latest/rustls/quic/struct.Keys.html?search=u32+-%3E+bool

Constructs a Keys instance for use with initial packets, given the QUIC version, TLS 1.3 cipher suite, QUIC algorithm, client destination connection ID, and side.

```APIDOC
## Keys::initial

### Description
Constructs a `Keys` instance for use with initial packets.

### Method
`pub fn initial(version: Version, suite: &'static Tls13CipherSuite, quic: &'static dyn Algorithm, client_dst_connection_id: &[u8], side: Side) -> Self`

### Parameters
- `version` (Version) - Required - The QUIC protocol version.
- `suite` (&'static Tls13CipherSuite) - Required - The TLS 1.3 cipher suite to use.
- `quic` (&'static dyn Algorithm) - Required - The QUIC algorithm implementation.
- `client_dst_connection_id` (&[u8]) - Required - The client's destination connection ID.
- `side` (Side) - Required - The side (client or server) for which the keys are constructed.

### Returns
- `Self` - A new `Keys` instance.
```
Tokens:
Raw