Pingora OpenSSL

https://docs.rs/pingora-openssl/0.8.0/
Admin
Pingora OpenSSL is an OpenSSL API compatibility layer for Rust that makes OpenSSL APIs...
Tokens:635,851
Snippets:4,803
Trust Score:9.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### RSA Key Generation Example

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/pkey/index.html?search=u32+-%3E+bool

This example demonstrates how to generate a 2048-bit RSA public/private key pair and then print the public key in PEM format.

```APIDOC
## Example

Generate a 2048-bit RSA public/private key pair and print the public key.

### Method

```rust
use openssl::rsa::Rsa;
use openssl::pkey::PKey;
use std::str;

let rsa = Rsa::generate(2048).unwrap();
let pkey = PKey::from_rsa(rsa).unwrap();

let pub_key: Vec<u8> = pkey.public_key_to_pem().unwrap();
println!("{:?}", str::from_utf8(pub_key.as_slice()).unwrap());
```

### Description

This code snippet shows the process of creating an RSA key pair using the `openssl` crate. It first generates a new RSA key with a specified bit length, then converts it into a `PKey` object, and finally extracts and prints the public key in PEM format.
```

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

### Server SSL/TLS Connection Example in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/index.html?search=

Provides an example of setting up a server to accept incoming SSL/TLS connections using pingora-openssl. It uses `SslAcceptor` to configure server-side TLS, loads certificate and private key files, and then listens for incoming `TcpStream` connections. Each accepted connection is handled in a separate thread.

```rust
use openssl::ssl::{SslMethod, SslAcceptor, SslStream, SslFiletype};
use std::net::{TcpListener, TcpStream};
use std::sync::Arc;
use std::thread;


let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
acceptor.set_private_key_file("key.pem", SslFiletype::PEM).unwrap();
acceptor.set_certificate_chain_file("certs.pem").unwrap();
acceptor.check_private_key().unwrap();
let acceptor = Arc::new(acceptor.build());

let listener = TcpListener::bind("0.0.0.0:8443").unwrap();

fn handle_client(stream: SslStream<TcpStream>) {
    // ...
}

for stream in listener.incoming() {
    match stream {
        Ok(stream) => {
            let acceptor = acceptor.clone();
            thread::spawn(move || {
                let stream = acceptor.accept(stream).unwrap();
                handle_client(stream);
            });
        }
        Err(e) => { /* connection failed */ }
    }
}
```

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

### ConnectConfiguration TLS Setup

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=

Methods for configuring and initiating a client-side TLS connection using the ConnectConfiguration struct.

```APIDOC
## [METHOD] ConnectConfiguration::connect

### Description
Initiates a client-side TLS session on a provided stream. The domain is used for SNI and hostname verification if enabled.

### Method
Rust Method

### Parameters
#### Path Parameters
- **domain** (&str) - Required - The target hostname for the TLS connection.
- **stream** (S) - Required - The underlying stream (must implement Read + Write).

### Request Example
```rust
let config = ConnectConfiguration::new();
let stream = TcpStream::connect("example.com:443").unwrap();
let ssl_stream = config.connect("example.com", stream);
```

### Response
#### Success Response (200)
- **SslStream<S>** (Object) - The established TLS-encrypted stream.

#### Error Handling
- Returns `HandshakeError<S>` if the TLS handshake fails.

---

## [METHOD] ConnectConfiguration::set_verify_hostname

### Description
Configures whether the client should verify the server's hostname against the certificate. Defaults to true.

### Method
Rust Method

### Parameters
- **verify_hostname** (bool) - Required - Set to false to disable verification (Warning: insecure).

### Request Example
```rust
config.set_verify_hostname(true);
```
```

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

### Example: Only Support TLSv1.2

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslOptions.html

This example demonstrates how to configure SslOptions to exclusively support TLSv1.2. It utilizes bitwise operations to mask out all other protocols except for TLSv1.2.

```rust
use openssl::ssl::SslOptions;

let options = SslOptions::NO_SSL_MASK & !SslOptions::NO_TLSV1_2;
```

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

### ConnectConfiguration TLS Setup

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=u32+-%3E+bool

Methods for configuring client-side TLS connection settings such as SNI and hostname verification.

```APIDOC
## POST /ConnectConfiguration/configure

### Description
Configures the client-side TLS session settings before establishing a connection.

### Method
POST

### Parameters
#### Request Body
- **use_sni** (bool) - Optional - Enables or disables Server Name Indication (default: true).
- **verify_hostname** (bool) - Optional - Enables or disables hostname verification (default: true).

### Request Example
{
  "use_sni": true,
  "verify_hostname": true
}

### Response
#### Success Response (200)
- **status** (string) - Configuration applied successfully.

#### Response Example
{
  "status": "success"
}
```

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

### GET /slice/starts_with

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=u32+-%3E+bool

Checks if the slice starts with a specific prefix.

```APIDOC
## GET /slice/starts_with

### Description
Returns true if the provided needle is a prefix of the slice.

### Method
GET

### Endpoint
/slice/starts_with

### Parameters
#### Query Parameters
- **needle** (Array) - Required - The prefix to check against.

### Response
#### Success Response (200)
- **result** (bool) - True if the slice starts with the needle.
```

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

### Initialize and Build X509Store in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html

Demonstrates how to create a new, empty X509StoreBuilder and then use it to construct an X509Store. This is the fundamental way to begin working with certificate stores.

```rust
use pingora_openssl::x509::store::X509StoreBuilder;

// Create a new builder
let mut builder = X509StoreBuilder::new()?;

// Build the store
let store = builder.build();

// The 'store' can now be used for certificate verification.
```

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

### Configure SSL Session Parameters

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.Ssl.html?search=std%3A%3Avec

Examples of configuring session-specific settings such as SNI hostnames and verification modes.

```Rust
let mut ssl = Ssl::new(&ctx)?;
ssl.set_hostname("example.com")?;
ssl.set_verify(SslVerifyMode::PEER);
```

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

### Initialize and Verify Certificates with X509StoreContext

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContext.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to instantiate an X509StoreContext and use the init method to verify a certificate against a store and chain. The init method handles lifecycle management by cleaning up the context after the provided closure executes.

```Rust
pub fn new() -> Result<X509StoreContext, ErrorStack> {
    X509StoreContext::new()
}

// Example usage of init for verification
ctx.init(&trust_store, &cert, &cert_chain, |ctx| {
    ctx.verify_cert()
})?;
```

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

### Get PSK Identity (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=u32+-%3E+bool

Retrieves the Pre-Shared Key (PSK) identity used during connection setup. This corresponds to `SSL_get_psk_identity`.

```rust
pub fn psk_identity(&self) -> Option<&[u8]>
```

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

### Get Digest Output Size (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.MessageDigest.html

Returns the output size (digest size) of the message digest algorithm in bytes. For example, SHA-256 produces a 32-byte hash.

```Rust
pub fn size(&self) -> usize
```

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

### Create and Initialize X509StoreContext in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContext.html

Demonstrates creating a new X509StoreContext and initializing it with trust anchors, a certificate, and a certificate chain. The `init` method takes a closure that operates on the initialized context, allowing for operations like certificate verification before the context is cleaned up.

```rust
use pingora_openssl::x509::{X509StoreContext, X509StoreRef, X509Ref, StackRef};
use pingora_openssl::error::ErrorStack;

fn example_init(
    trust: &X509StoreRef,
    cert: &X509Ref,
    cert_chain: &StackRef<X509>,
) -> Result<(), ErrorStack> {
    let mut ctx = X509StoreContext::new()?;
    ctx.init(trust, cert, cert_chain, |ctx_ref| {
        // Operations with the initialized context can be performed here
        // For example, verifying the certificate:
        // ctx_ref.verify_cert()?;
        Ok(())
    })?
    Ok(())
}
```

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

### Get PSK Identity Hint (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=u32+-%3E+bool

Retrieves the Pre-Shared Key (PSK) identity hint used during connection setup. May return `None` if no PSK identity hint was used. This corresponds to `SSL_get_psk_identity_hint`.

```rust
pub fn psk_identity_hint(&self) -> Option<&[u8]>
```

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

### Construct and configure an X509Store using X509StoreBuilder

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html?search=u32+-%3E+bool

Demonstrates how to instantiate a new X509StoreBuilder, add certificates, set default paths, and build the final X509Store object.

```rust
use pingora_openssl::x509::store::X509StoreBuilder;

// Create a new builder
let mut builder = X509StoreBuilder::new()?;

// Configure the store
builder.set_default_paths()?;

// Build the final store
let store = builder.build();
```

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

### Get Element Offset in Slice (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=

Returns the byte offset of an element reference within a slice. It uses pointer arithmetic and does not compare elements. Returns `None` if the element reference does not point to the start of an element within the slice. Panics if `T` is zero-sized.

```rust
pub fn element_offset(&self, element: &T) -> Option<usize>
{
    // Implementation details omitted for brevity
    unimplemented!();
}

// Example Usage:
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### Get Element Offset in a Slice

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=std%3A%3Avec

Returns the index of a given element reference within the slice. It uses pointer arithmetic and does not compare elements. Returns `None` if the element reference does not point to the start of an element within the slice. Panics if `T` is zero-sized.

```rust
pub fn element_offset(&self, element: &T) -> Option<usize>
```

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

### X509StoreBuilder Initialization and Construction

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html?search=std%3A%3Avec

Methods for creating a new builder instance and finalizing the X509Store object.

```APIDOC
## POST /X509StoreBuilder/new

### Description
Creates a new, empty X509StoreBuilder instance.

### Method
POST

### Endpoint
/X509StoreBuilder/new

### Response
#### Success Response (200)
- **builder** (X509StoreBuilder) - A new builder instance.

---

## POST /X509StoreBuilder/build

### Description
Consumes the builder and constructs the final X509Store.

### Method
POST

### Endpoint
/X509StoreBuilder/build

### Request Body
- **builder** (X509StoreBuilder) - The builder instance to consume.

### Response
#### Success Response (200)
- **store** (X509Store) - The constructed certificate store.
```

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

### Get TypeId of self

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/dh/struct.Dh.html?search=

Implements the Any trait, providing a method to get the TypeId of the current type. This is useful for runtime type checking.

```rust
impl<T> Any for T
where
    T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId {
        TypeId::of::<T>()
    }
}
```

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

### Get SslRef Protocol Version String (Deprecated) in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslRef.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Deprecated method to get the protocol version of the session. Renamed to `version_str`. Corresponds to SSL_version.

```rust
pub fn version(&self) -> &str
```

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

### Construct and Configure X509StoreBuilder in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize a new X509StoreBuilder, add certificates, and build the final X509Store object. This builder pattern ensures proper initialization of OpenSSL store structures.

```rust
use pingora_openssl::x509::store::X509StoreBuilder;
use openssl::x509::X509;

// Create a new builder
let mut builder = X509StoreBuilder::new()?;

// Add a certificate and set default paths
builder.add_cert(cert)?;
builder.set_default_paths()?;

// Build the store
let store = builder.build();
```

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

### Rust Slice Partial Sort Unstable By Key Example

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Showcases the `partial_sort_unstable_by_key` method in Rust, which sorts a slice based on a key extracted from each element. The example demonstrates partial sorting of different ranges using a key extraction function, though specific examples for this method are not provided in the source text, only its signature and description.

```rust
#![feature(slice_partial_sort_unstable)]

// Example usage of partial_sort_unstable_by_key would go here.
// This function sorts a slice based on a key extracted from each element.
// For instance, to sort by the absolute value:
// let mut v = [4, -5, 1, -3, 2];
// v.partial_sort_unstable_by_key(.., |x| x.abs());
// assert_eq!(v, [1, 2, -3, 4, -5]); // Or a similar permutation based on unstable sort

```

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

### ExtensionContext Initialization Methods

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ExtensionContext.html

Provides methods to create ExtensionContext instances, including creating an empty context, a context with all known bits set, or converting from raw bit values.

```rust
pub const fn empty() -> ExtensionContext

```

```rust
pub const fn all() -> ExtensionContext

```

```rust
pub const fn from_bits(bits: u32) -> Option<ExtensionContext>

```

```rust
pub const fn from_bits_truncate(bits: u32) -> ExtensionContext

```

```rust
pub const fn from_bits_retain(bits: u32) -> ExtensionContext

```

```rust
pub fn from_name(name: &str) -> Option<ExtensionContext>
```

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

### Initialize X509 Context

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContextRef.html

Initializes the X509 store context with a trust store, certificate, and chain, executing a provided closure within the initialized state.

```APIDOC
## POST /x509/init

### Description
Initializes the X509 context with the provided trust store, target certificate, and certificate chain. The context remains valid for the duration of the provided closure.

### Method
POST

### Endpoint
/x509/init

### Parameters
#### Request Body
- **trust** (X509StoreRef) - Required - The certificate store containing trusted certificates.
- **cert** (X509Ref) - Required - The certificate to be verified.
- **cert_chain** (StackRef<X509>) - Required - The certificate chain.
- **with_context** (FnOnce) - Required - Closure to execute while the context is initialized.

### Response
#### Success Response (200)
- **result** (T) - The result returned by the closure.

### Response Example
{
  "status": "success",
  "data": "verification_result"
}
```

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

### Initialize X509Lookup Methods

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509Lookup.html

Demonstrates how to access the two primary lookup methods: hash_dir for dynamic, cached directory lookups and file for static file-based loading.

```Rust
use pingora_openssl::x509::store::X509Lookup;

// Method for loading certificates/CRLs from a directory with caching
let hash_dir_method = X509Lookup::<HashDir>::hash_dir();

// Method for loading certificates/CRLs from a specific file
let file_method = X509Lookup::<File>::file();
```

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

### Get Max Early Data (Rust OpenSSL)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html

Gets the maximum amount of early data that can be sent on this connection. Requires OpenSSL 1.1.1 or LibreSSL 3.4.0 or newer. Corresponds to `SSL_get_max_early_data`.

```rust
pub fn max_early_data(&self) -> u32
```

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

### Initialize and Configure Ssl Session

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.Ssl.html?search=u32+-%3E+bool

Demonstrates creating an Ssl instance from a context and initiating a client-side TLS handshake. Note that direct usage of Ssl is discouraged in favor of SslConnector for secure defaults.

```Rust
pub fn new(ctx: &SslContextRef) -> Result<Ssl, ErrorStack>;
pub fn connect<S>(self, stream: S) -> Result<SslStream<S>, HandshakeError<S>> where S: Read + Write;
```

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

### Get Mutable Last Element of a Slice in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=

Shows how to get a mutable reference to the last element of a slice, allowing in-place modification. It returns `Some(&mut T)` if the slice is not empty and `None` if it is. This is useful for updating the final value of a slice.

```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());
```

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

### Construct and Configure X509StoreBuilder in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html?search=

Demonstrates how to instantiate an X509StoreBuilder, add a certificate, and build the final X509Store object. This process requires handling potential ErrorStack results from OpenSSL operations.

```rust
use pingora_openssl::x509::store::X509StoreBuilder;
use pingora_openssl::x509::X509;

fn create_store(cert: X509) -> Result<X509Store, ErrorStack> {
    let mut builder = X509StoreBuilder::new()?;
    builder.add_cert(cert)?;
    builder.set_default_paths()?;
    Ok(builder.build())
}
```

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

### Nid Struct Definition and Example in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/nid/struct.Nid.html?search=std%3A%3Avec

Defines the `Nid` struct used for OpenSSL object identifiers and provides an example of how to retrieve the raw integer value of a `Nid` constant. This is useful for understanding the underlying representation of OpenSSL objects.

```rust
pub struct Nid(/* private fields */);

use openssl::nid::Nid;

assert!(Nid::AES_256_GCM.as_raw() == 901);
```

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

### Rust Slice Partial Sort Unstable By Example

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Illustrates the use of `partial_sort_unstable_by` with a custom comparison function in Rust. This example demonstrates sorting in descending order and verifying the partial sorting of various ranges, including empty, single-element, subranges, and the full slice.

```rust
#![feature(slice_partial_sort_unstable)]

let mut v = [4, -5, 1, -3, 2];

// empty range at the beginning, nothing changed
v.partial_sort_unstable_by(0..0, |a, b| b.cmp(a));
assert_eq!(v, [4, -5, 1, -3, 2]);

// empty range in the middle, partitioning the slice
v.partial_sort_unstable_by(2..2, |a, b| b.cmp(a));
for i in 0..2 {
   assert!(v[i] >= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] >= v[i]);
}

// single element range, same as select_nth_unstable
v.partial_sort_unstable_by(2..3, |a, b| b.cmp(a));
for i in 0..2 {
   assert!(v[i] >= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] >= v[i]);
}

// partial sort a subrange
v.partial_sort_unstable_by(1..4, |a, b| b.cmp(a));
assert_eq!(&v[1..4], [2, 1, -3]);

// partial sort the whole range, same as sort_unstable
v.partial_sort_unstable_by(.., |a, b| b.cmp(a));
assert_eq!(v, [4, 2, 1, -3, -5]);

```

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

### Initialize and Verify X.509 Certificates in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContext.html?search=

Demonstrates how to initialize an X509StoreContext with a trust store and certificate chain, and perform certificate verification using the init method.

```rust
let mut ctx = X509StoreContext::new()?;
ctx.init(&trust_store, &cert, &cert_chain, |ctx| {
    let verified = ctx.verify_cert()?;
    if verified {
        Ok(())
    } else {
        Err(ErrorStack::get())
    }
})?;
```

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

### ExtensionContext::type_id

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ExtensionContext.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the `TypeId` of `self`.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **TypeId** (TypeId) - The type identifier of the instance.

#### Response Example
None
```

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

### Get All and Empty ExtensionContext Flags

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ExtensionContext.html?search=u32+-%3E+bool

The `Flags` trait provides static methods to get predefined ExtensionContext values. `empty()` returns a flags value with all bits unset, representing an empty set of flags. `all()` returns a flags value with all known bits set.

```rust
fn empty() -> Self
fn all() -> Self
```

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

### Conversion Implementations (From, Into, TryFrom, TryInto)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContext.html?search=

Details various conversion implementations including `From`, `Into`, `TryFrom`, and `TryInto` for generic type conversions.

```APIDOC
## impl<T> From<T> for T

### Description
Provides a trivial `From` trait implementation where a type `T` can be converted from itself. This means the argument is returned unchanged.

### Method
`from(t: T) -> T`

### Endpoint
N/A (Internal Implementation)

### Parameters
- **t** (T) - The value to convert.

### Request Example
None

### Response
#### Success Response (N/A)
- **T** (T) - The original value unchanged.

#### Response Example
None

## impl<T, U> Into<U> for T

### Description
Provides an `Into` trait implementation for converting type `T` into type `U`, provided that `U` implements `From<T>`. The conversion behavior is determined by the `From<T> for U` implementation.

### Method
`into(self) -> U`

### Endpoint
N/A (Internal Implementation)

### Parameters
- **self** (T) - The value to convert.

### Request Example
None

### Response
#### Success Response (N/A)
- **U** (U) - The converted value of type `U`.

#### Response Example
None

## impl<T, U> TryFrom<U> for T

### Description
Provides a `TryFrom` trait implementation for attempting to convert type `U` into type `T`. This conversion may fail, returning a `Result`.

### Type
- **Error** (Infallible) - The type returned in the event of a conversion error. In this specific implementation, it's `Infallible`, meaning the conversion will not fail.

### Method
`try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### Endpoint
N/A (Internal Implementation)

### Parameters
- **value** (U) - The value to attempt to convert.

### Request Example
None

### Response
#### Success Response (N/A)
- **Result<T, Error>** (Result) - A `Result` containing either the converted value of type `T` on success, or an error on failure.

#### Response Example
None

## impl<T, U> TryInto<U> for T

### Description
Provides a `TryInto` trait implementation for attempting to convert type `T` into type `U`, provided that `U` implements `TryFrom<T>`. This conversion may fail, returning a `Result`.

### Type
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error, determined by the `TryFrom<T> for U` implementation.

### Method
`try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

### Endpoint
N/A (Internal Implementation)

### Parameters
- **self** (T) - The value to attempt to convert.

### Request Example
None

### Response
#### Success Response (N/A)
- **Result<U, Error>** (Result) - A `Result` containing either the converted value of type `U` on success, or an error on failure.

#### Response Example
None
```

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

### Initialize and manage X509StoreContext in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContext.html?search=std%3A%3Avec

Demonstrates how to create a new X509StoreContext and use the init method to perform certificate verification within a scoped closure.

```rust
use pingora_openssl::x509::X509StoreContext;

// Create a new context
let mut ctx = X509StoreContext::new()?;

// Initialize and verify within a closure
let result = ctx.init(&trust_store, &cert, &chain, |ctx| {
    ctx.verify_cert()
})?;
```

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

### GET /session/state

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslStream.html

Retrieves or updates the current shutdown state of the SSL session.

```APIDOC
## GET /session/state

### Description
Retrieves the current shutdown state of the session, corresponding to SSL_get_shutdown.

### Method
GET

### Endpoint
/session/state

### Response
#### Success Response (200)
- **state** (ShutdownState) - The current session shutdown state.

## PUT /session/state

### Description
Sets the session shutdown state, useful for forcing session caching behavior.

### Method
PUT

### Request Body
- **state** (ShutdownState) - The state to apply.

### Response
#### Success Response (200)
- **status** (string) - Confirmation of state update.
```

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

### GET /concat

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=

Flattens a slice of items into a single value.

```APIDOC
## GET /concat

### Description
Flattens a slice of T into a single value (e.g., concatenating strings or arrays).

### Response
#### Success Response (200)
- **result** (Any) - The flattened output.

#### Response Example
{
  "result": "helloworld"
}
```

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

### Initialize SslContextBuilder

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslContextBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to instantiate a new SslContextBuilder or create one from an existing raw OpenSSL pointer.

```rust
pub struct SslContextBuilder(/* private fields */);

// Create a new builder
pub fn new(method: SslMethod) -> Result<SslContextBuilder, ErrorStack>;

// Create from raw pointer (unsafe)
pub unsafe fn from_ptr(ctx: *mut SSL_CTX) -> SslContextBuilder;
```

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

### Initialize X509StoreContextRef for Certificate Verification

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509StoreContextRef.html?search=

The init method initializes the context with a trust store, a certificate, and a chain. It executes a closure within the initialized context, ensuring proper cleanup of the underlying OpenSSL resources.

```rust
pub fn init<F, T>(
	&mut self,
	trust: &X509StoreRef,
	cert: &X509Ref,
	cert_chain: &StackRef<X509>,
	with_context: F,
) -> Result<T, ErrorStack>
where F: FnOnce(&mut X509StoreContextRef) -> Result<T, ErrorStack>;
```

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

### GET /to_vec

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=

Copies the contents of a slice into a new Vector.

```APIDOC
## GET /to_vec

### Description
Creates a new Vec containing a copy of the elements in the slice.

### Method
GET

### Response
#### Success Response (200)
- **data** (Array) - A new vector containing the copied elements.

#### Response Example
{
  "data": [10, 40, 30]
}
```

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

### SslContext Builder and Initialization

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslContext.html?search=u32+-%3E+bool

Methods for creating and initializing an SslContext, including building it from a method and managing extra data.

```APIDOC
## Implementations for SslContext

### `impl SslContext`

#### `pub fn builder(method: SslMethod) -> Result<SslContextBuilder, ErrorStack>`
Creates a new builder object for an `SslContext`.

#### `pub fn new_ex_index<T>() -> Result<Index<SslContext, T>, ErrorStack>`
Returns a new extra data index. Each invocation is guaranteed to return a distinct index, usable for storing and retrieving data associated with the context.
```

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

### GET /slice/contains

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=u32+-%3E+bool

Checks if the slice contains a specific element.

```APIDOC
## GET /slice/contains

### Description
Returns true if the slice contains an element with the given value.

### Method
GET

### Endpoint
/slice/contains

### Parameters
#### Query Parameters
- **value** (T) - Required - The value to search for in the slice.

### Response
#### Success Response (200)
- **result** (bool) - True if found, false otherwise.
```

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

### Create and Configure ExtendedKeyUsage Extension (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/extension/struct.ExtendedKeyUsage.html?search=

Demonstrates how to create a new ExtendedKeyUsage extension and set various flags such as server authentication, client authentication, code signing, and more. It also shows how to set a custom 'other' usage and build the final X509Extension.

```Rust
use pingora_openssl::x509::extension::ExtendedKeyUsage;

// Create a new ExtendedKeyUsage extension
let mut eku = ExtendedKeyUsage::new();

// Set specific key usages
eku.server_auth();
eku.client_auth();
eku.code_signing();

// Set a custom usage
eku.other("1.3.6.1.5.5.7.3.1"); // Example OID for Server Authentication

// Build the X509Extension
match eku.build() {
    Ok(extension) => {
        // Use the extension
        println!("Successfully built X509Extension");
    }
    Err(e) => {
        eprintln!("Error building extension: {}", e);
    }
}
```

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

### GET /slice/last

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Retrieves the last element of a slice or a mutable reference to it.

```APIDOC
## GET /slice/last

### Description
Returns the last element of the slice, or None if it is empty.

### Method
GET

### Endpoint
/slice/last

### Response
#### Success Response (200)
- **element** (Option<&T>) - The last element of the slice.

#### Response Example
{
  "result": 30
}
```

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

### GET /error_stack/get

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/error/struct.ErrorStack.html?search=

Retrieves the current contents of the OpenSSL error stack.

```APIDOC
## GET /error_stack/get

### Description
Returns the current collection of errors from the OpenSSL error stack.

### Method
GET

### Endpoint
`pingora_openssl::error::ErrorStack::get()`

### Response
#### Success Response (200)
- **ErrorStack** (Object) - A collection containing the current OpenSSL errors.

#### Response Example
{
  "errors": [
    { "code": 101, "message": "SSL error occurred" }
  ]
}
```

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

### Initialize SslContext and Extra Data Index

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslContext.html?search=std%3A%3Avec

Demonstrates how to instantiate an SslContext using a builder and how to create an index for storing custom extra data within the context.

```rust
pub fn builder(method: SslMethod) -> Result<SslContextBuilder, ErrorStack>;
pub fn new_ex_index<T>() -> Result<Index<SslContext, T>, ErrorStack>
where T: 'static + Sync + Send;
```

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

### rchunks_mut

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Returns a mutable iterator over chunks of a slice, starting from the end.

```APIDOC
## [METHOD] rchunks_mut

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are mutable slices and do not overlap.

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The number of elements per chunk.

### Request Example
`slice.rchunks_mut(2)`

### Response
#### Success Response (200)
- **iterator** (RChunksMut) - An iterator yielding mutable slices.
```

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

### RSA Key Generation Example

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/pkey/index.html?search=std%3A%3Avec

Demonstrates how to generate a 2048-bit RSA public/private key pair using the PKey structure.

```APIDOC
## Rust Library Usage: RSA Key Generation

### Description
This example demonstrates how to generate a new 2048-bit RSA key pair and export the public key in PEM format using the `pingora-openssl` crate.

### Method
N/A (Rust Library Function Call)

### Parameters
#### Request Body
- **bits** (integer) - Required - The number of bits for the RSA key (e.g., 2048).

### Request Example
```rust
use openssl::rsa::Rsa;
use openssl::pkey::PKey;

let rsa = Rsa::generate(2048).unwrap();
let pkey = PKey::from_rsa(rsa).unwrap();
```

### Response
#### Success Response (200)
- **pub_key** (Vec<u8>) - The PEM-encoded public key.

#### Response Example
```text
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA...
-----END PUBLIC KEY-----
```
```

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

### Initialize SslContextBuilder

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.SslContextBuilder.html?search=std%3A%3Avec

Demonstrates how to define the SslContextBuilder structure and create a new instance using the provided constructor.

```Rust
pub struct SslContextBuilder(/* private fields */);

// Creating a new instance
let builder = SslContextBuilder::new(method);
```

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

### Configure DTLS and Connection Settings

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=

Utility methods for configuring connection-specific parameters such as MTU for DTLS and PSK identity hints.

```rust
pub fn set_mtu(&mut self, mtu: u32) -> Result<(), ErrorStack>;
pub fn psk_identity_hint(&self) -> Option<&[u8]>;
pub fn psk_identity(&self) -> Option<&[u8]>;
```

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

### GET /X509v3Context/as_ptr

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509v3Context.html?search=

Retrieves the underlying OpenSSL pointer for the X509v3Context object.

```APIDOC
## GET /X509v3Context/as_ptr

### Description
Returns the raw pointer to the underlying OpenSSL `X509V3_CTX` structure. This is used for low-level interoperability with OpenSSL C APIs.

### Method
GET

### Endpoint
/X509v3Context/as_ptr

### Parameters
#### Path Parameters
- **self** (X509v3Context) - Required - The context instance to query.

### Request Example
{
  "action": "get_pointer"
}

### Response
#### Success Response (200)
- **pointer** (*mut X509V3_CTX) - The raw pointer to the OpenSSL context structure.

#### Response Example
{
  "pointer": "0x00007ff7b0001234"
}
```

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

### Load Default Certificate Paths in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html

Illustrates how to configure the X509StoreBuilder to load certificates from their default system locations. This simplifies trust management by using pre-configured system CAs.

```rust
use pingora_openssl::x509::store::X509StoreBuilder;

let mut builder = X509StoreBuilder::new()?;
builder.set_default_paths()?;

// The store will now include certificates from default system paths.
```

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

### GET DistPointNameRef::fullname

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.DistPointNameRef.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the full name contents from a DistPointName reference.

```APIDOC
## GET DistPointNameRef::fullname

### Description
Returns the contents of the DistPointName if it is defined as a fullname. This is a method on the `DistPointNameRef` struct.

### Method
GET

### Endpoint
pingora_openssl::x509::DistPointNameRef::fullname

### Parameters
#### Path Parameters
- **&self** (DistPointNameRef) - Required - The reference instance to query.

### Request Example
N/A (Method call on object instance)

### Response
#### Success Response (200)
- **Option<StackRef<GeneralName>>** (Object) - Returns the full name if present, otherwise None.

#### Response Example
{
  "result": "Option<StackRef<GeneralName>>"
}
```

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

### GET /slice/is_sorted

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the elements of a slice are sorted in non-decreasing order.

```APIDOC
## GET /slice/is_sorted

### Description
Checks if the elements of this slice are sorted. For each element 'a' and its following element 'b', 'a <= b' must hold.

### Method
GET

### Response
#### Success Response (200)
- **is_sorted** (boolean) - Returns true if the slice is sorted, false otherwise.
```

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

### Initialize X509Lookup Methods

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509Lookup.html?search=u32+-%3E+bool

Methods to instantiate lookup strategies. hash_dir provides dynamic, cached directory lookups, while file provides static file-based loading.

```rust
impl X509Lookup<HashDir> {
	pub fn hash_dir() -> &'static X509LookupMethodRef<HashDir> { ... }
}

impl X509Lookup<File> {
	pub fn file() -> &'static X509LookupMethodRef<File> { ... }
}
```

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

### Build and Populate X509 Certificate Store in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/index.html?search=

Demonstrates how to create an X509 certificate store using `X509StoreBuilder`. It includes generating a self-signed certificate and adding it to the store. This is useful for setting up trusted CAs for certificate verification.

```rust
use openssl::x509::store::{X509StoreBuilder, X509Store};
use openssl::x509::{X509, X509Name};
use openssl::asn1::Asn1Time;
use openssl::pkey::PKey;
use openssl::hash::MessageDigest;
use openssl::rsa::Rsa;
use openssl::nid::Nid;

let rsa = Rsa::generate(2048).unwrap();
let pkey = PKey::from_rsa(rsa).unwrap();

let mut name = X509Name::builder().unwrap();
name.append_entry_by_nid(Nid::COMMONNAME, "foobar.com").unwrap();
let name = name.build();

// Sep 27th, 2016
let sample_time = Asn1Time::from_unix(1474934400).unwrap();

let mut builder = X509::builder().unwrap();
builder.set_version(2).unwrap();
builder.set_subject_name(&name).unwrap();
builder.set_issuer_name(&name).unwrap();
builder.set_pubkey(&pkey).unwrap();
builder.set_not_before(&sample_time);
builder.set_not_after(&sample_time);
builder.sign(&pkey, MessageDigest::sha256()).unwrap();

let certificate: X509 = builder.build();

let mut builder = X509StoreBuilder::new().unwrap();
let _ = builder.add_cert(certificate);

let store: X509Store = builder.build();

```

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

### GET /slice/first_chunk

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Retrieves the first N elements of a slice as an array reference.

```APIDOC
## GET /slice/first_chunk

### Description
Returns an array reference to the first N items in the slice. Returns None if the slice length is less than N.

### Method
GET

### Endpoint
/slice/first_chunk

### Parameters
#### Query Parameters
- **N** (usize) - Required - The number of elements to retrieve.

### Response
#### Success Response (200)
- **chunk** ([T; N]) - The array reference of size N.

#### Response Example
{
  "chunk": [10, 40]
}
```

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

### Constructing an X509 Certificate Request with X509ReqBuilder

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/struct.X509ReqBuilder.html

Demonstrates the lifecycle of building an X509 certificate request using X509ReqBuilder. This involves initializing the builder, configuring fields like the public key and subject name, adding extensions, signing the request, and finally building the object.

```rust
use pingora_openssl::x509::X509ReqBuilder;
use openssl::pkey::PKey;
use openssl::hash::MessageDigest;

// Initialize the builder
let mut builder = X509ReqBuilder::new()?;

// Configure the request
builder.set_version(0)?;
builder.set_pubkey(&pkey)?;

// Sign the request with a private key
builder.sign(&pkey, MessageDigest::sha256())?;

// Finalize the builder to get the X509Req
let req = builder.build();
```

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

### GET /slice/split_last

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Splits a slice into the last element and the remaining preceding elements.

```APIDOC
## GET /slice/split_last

### Description
Returns the last and all the rest of the elements of the slice, or None if it is empty.

### Method
GET

### Endpoint
/slice/split_last

### Response
#### Success Response (200)
- **last** (T) - The last element.
- **rest** ([T]) - The remaining elements.

#### Response Example
{
  "last": 2,
  "rest": [0, 1]
}
```

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

### ExtensionContext Initialization and Conversion Methods (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ExtensionContext.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Offers methods for creating and converting ExtensionContext values. This includes creating empty or all-bits-set contexts, converting from raw bitmasks (with or without truncation), and retrieving contexts by name.

```rust
pub const fn empty() -> ExtensionContext
pub const fn all() -> ExtensionContext
pub const fn from_bits(bits: u32) -> Option<ExtensionContext>
pub const fn from_bits_truncate(bits: u32) -> ExtensionContext
pub const fn from_bits_retain(bits: u32) -> ExtensionContext
pub fn from_name(name: &str) -> Option<ExtensionContext>
```

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

### GET /slice/as_ptr

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a raw pointer to the slice's buffer.

```APIDOC
## GET /slice/as_ptr

### Description
Returns a raw pointer to the slice's buffer. The caller must ensure the slice outlives the pointer.

### Method
GET

### Endpoint
/slice/as_ptr

### Response
#### Success Response (200)
- **pointer** (*const T) - A raw pointer to the start of the slice buffer.

### Response Example
{
  "pointer": "0x7ff7bfeff1a0"
}
```

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

### Initialize X509Lookup methods in Rust

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509Lookup.html?search=std%3A%3Avec

Demonstrates how to access the lookup methods for directory-based and file-based certificate loading. These methods return a static reference to the lookup configuration.

```rust
use pingora_openssl::x509::store::{X509Lookup, HashDir, File};

// Lookup method for directory-based certificates
let hash_dir_method = X509Lookup::<HashDir>::hash_dir();

// Lookup method for file-based certificates
let file_method = X509Lookup::<File>::file();
```

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

### Get SSL Session (Rust)

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.ConnectConfiguration.html?search=

Returns a shared reference to the SSL session. This corresponds to `SSL_get_session`.

```rust
pub fn session(&self) -> Option<&SslSessionRef>
```

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

### GET /error_stack/get

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/error/struct.ErrorStack.html

Retrieves the current contents of the OpenSSL error stack.

```APIDOC
## GET /error_stack/get

### Description
Returns the current collection of errors from the OpenSSL error stack.

### Method
GET

### Endpoint
/error_stack/get

### Response
#### Success Response (200)
- **ErrorStack** (Object) - A collection of OpenSSL errors.

#### Response Example
{
  "errors": [
    { "code": 123, "message": "SSL error occurred" }
  ]
}
```

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

### Rust: Initialize X509StoreBuilder

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509StoreBuilder.html?search=std%3A%3Avec

Creates a new, empty X509StoreBuilder. This function initializes the builder for constructing a certificate store and corresponds to the OpenSSL function `X509_STORE_new`.

```rust
pub fn new() -> Result<X509StoreBuilder, ErrorStack>
```

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

### Client Hello Callback Methods

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.Ssl.html

Methods intended for use within the client hello callback to inspect incoming handshake data.

```APIDOC
## GET /client_hello_session_id

### Description
Returns the session ID field of the client’s hello message. Must be used inside the client hello callback.

### Method
GET

### Response
#### Success Response (200)
- **session_id** (Option<&[u8]>) - The raw bytes of the session ID if available.
```

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

### rchunks_exact

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html

Returns an iterator over chunks of a slice of exact size, starting from the end.

```APIDOC
## [METHOD] rchunks_exact

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. If the length is not divisible by `chunk_size`, the remainder is omitted and accessible via the `remainder()` method.

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The exact number of elements per chunk.

### Response
#### Success Response (200)
- **iterator** (RChunksExact) - An iterator yielding slices of exactly `chunk_size`.
```

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

### rchunks_mut

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/hash/struct.DigestBytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns an iterator over mutable chunks of a slice, starting from the end.

```APIDOC
## [METHOD] rchunks_mut

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are mutable slices and do not overlap.

### Parameters
- **chunk_size** (usize) - Required - The size of each chunk. Panics if zero.

### Request Example
```rust
let v = &mut [0, 0, 0, 0, 0];
for chunk in v.rchunks_mut(2) { /* ... */ }
```

### Response
- **Iterator** (RChunksMut) - An iterator yielding mutable slices.
```

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

### Initialize X509Lookup methods

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/x509/store/struct.X509Lookup.html?search=

Provides methods to create lookup instances for either directory-based or file-based certificate storage. The hash_dir method supports dynamic loading and caching, while the file method loads resources once at initialization.

```rust
impl X509Lookup<HashDir> {
  pub fn hash_dir() -> &'static X509LookupMethodRef<HashDir> { ... }
}

impl X509Lookup<File> {
  pub fn file() -> &'static X509LookupMethodRef<File> { ... }
}
```

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

### Initialize and Configure Ssl Session

Source: https://docs.rs/pingora-openssl/0.8.0/pingora_openssl/ssl/struct.Ssl.html?search=std%3A%3Avec

Demonstrates creating a new Ssl instance from a context and initiating a client-side or server-side TLS handshake.

```Rust
let ssl = Ssl::new(&ctx)?;
// For client-side
let stream = ssl.connect(stream)?;
// For server-side
let stream = ssl.accept(stream)?;
```
Tokens:
Raw