Pingora BoringSSL

https://docs.rs/pingora-boringssl/0.8.0
Admin
Pingora BoringSSL is a Rust crate providing a BoringSSL API compatibility layer that exposes...
Tokens:1,030,376
Snippets:7,456
Trust Score:9.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### Rust: Server SSL/TLS Connection Example

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/index.html

Illustrates how to configure and run an SSL/TLS server using `SslAcceptor`. This example covers building an acceptor with certificate and private key, binding to a port, and handling incoming client connections in separate threads.

```rust
use boring::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 */ }
    }
}
```

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

### Constructing and Configuring an X509Store

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

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

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

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

// Add a certificate
builder.add_cert(cert)?;

// Load default system paths
builder.set_default_paths()?;

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

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

### Get Mutable Slice of Buffer (Rust)

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxCustomVerifyFinish.html?search=

Returns a mutable slice starting at the current position of a `BufMut` buffer. The slice length is between 0 and the remaining mutable capacity, allowing for non-continuous buffer implementations.

```rust
fn chunk_mut(&mut self) -> &mut UninitSlice
```

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

### Constructing and Configuring an X509Store

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

Demonstrates how to instantiate an X509StoreBuilder, add certificates, configure validation parameters, and build the final X509Store object.

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

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

// Add a certificate
builder.add_cert(cert)?;

// Load default system paths
builder.set_default_paths()?;

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

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

### PKeyRef: Get Key Bit Length in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/pkey/struct.PKeyRef.html?search=u32+-%3E+bool

Explains how to retrieve the bit length of a cryptographic key. This value represents the key's strength, for example, the bit length of the modulus for RSA keys.

```Rust
use pingora_boringssl::pkey::PKeyRef;

// Assuming pkey_ref is an instance of PKeyRef<T>

// Get the bit length of the key
let key_bits: u32 = pkey_ref.bits();
```

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

### Constructing and Configuring an X509Store

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

Demonstrates how to initialize a new X509StoreBuilder, add certificates, configure default paths, and build the final X509Store instance.

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

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

// Add a certificate
builder.add_cert(cert)?;

// Load default system paths
builder.set_default_paths()?;

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

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

### Get Element Index from Reference (Rust)

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

Returns the index of an element within a slice given a reference to that element. It uses pointer arithmetic and does not compare element values. 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 ...
}

// 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!(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
```

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

### Getting a Mutable Reference to a Pinned Value (`as_mut`)

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.ExDataFuture.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `as_mut` method provides a mutable reference (`Pin<&mut T>`) to the pinned value. This is safe due to the pinning contract, and it's particularly useful when a function consumes the pinning pointer (like `method` in the example) and needs to reborrow it.

```rust
pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>
where Ptr: DerefMut
```

```rust
use std::pin::Pin;

impl Type {
    fn method(self: Pin<&mut Self>) {
        // do something
    }

    fn call_method_twice(mut self: Pin<&mut Self>) {
        // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
        self.as_mut().method();
        self.as_mut().method();
    }
}
```

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

### Send HTTP Request and Read Response in Rust with SSL Stream

Source: https://docs.rs/pingora-boringssl/0.8.0/src/pingora_boringssl/boring_tokio.rs.html?search=std%3A%3Avec

This snippet shows how to send an HTTP GET request over an established SSL stream and read the entire response into a buffer. It then converts the buffer to a string and performs basic assertions on the response content. This assumes a prior setup of an `SslStream`.

```rust
stream.write_all(b"GET / HTTP/1.0\r\n\r\n").await.unwrap();

let mut buf = vec![];
stream.read_to_end(&mut buf).await.unwrap();
let response = String::from_utf8_lossy(&buf);
let response = response.trim_end();

// any response code is fine
assert!(response.starts_with("HTTP/1.0 "));
assert!(response.ends_with("</html>") || response.ends_with("</HTML>"));
```

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

### X509Req Initialization and Serialization

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509Req.html?search=std%3A%3Avec

Demonstrates how to create an X509Req instance using a builder or by parsing existing PEM/DER data, and how to serialize the request back to these formats.

```Rust
use pingora_boringssl::x509::X509Req;

// Create a builder
let builder = X509Req::builder()?;

// Load from PEM
let req_pem = X509Req::from_pem(pem_bytes)?;

// Load from DER
let req_der = X509Req::from_der(der_bytes)?;

// Serialize to formats
let pem_out = req_pem.to_pem()?;
let der_out = req_pem.to_der()?;
```

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

### Initialize and Verify Certificate Context (Rust)

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

Demonstrates initializing an X509StoreContextRef with trust anchors, a certificate, and a chain, then executing a closure with the initialized context to perform verification. The context is automatically cleaned up after the closure.

```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>,
{
  // ... implementation details ...
}

pub fn verify_cert(&mut self) -> Result<bool, ErrorStack> {
  // ... implementation details ...
}
```

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

### Get TypeId for Any Trait in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslCipher.html?search=u32+-%3E+bool

A blanket implementation of the Any trait, providing a method to get the TypeId of a type. This is a generic implementation applicable to many types.

```rust
fn type_id(&self) -> TypeId;
```

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

### Initialize X509StoreContextRef with closure

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

The init method initializes the context with a trust store, certificate, and chain, executing a provided closure within the initialized state. It ensures proper cleanup of the context after the closure completes.

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

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

### Split slice into chunks from start or end in Rust

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

Splits a mutable slice into N-element arrays and a remainder slice. as_chunks_mut processes from the start, while as_rchunks_mut processes from the end. Both panic if N is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let (chunks, remainder) = v.as_chunks_mut::<2>();
remainder[0] = 9;
for chunk in chunks { *chunk = [1; 2]; }
assert_eq!(v, &[1, 1, 2, 2, 9]);

let (remainder, chunks) = v.as_rchunks_mut::<2>();
remainder[0] = 9;
assert_eq!(v, &[9, 1, 1, 2, 2]);
```

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

### Perform TLS Handshake with SslStream

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslStream.html?search=std%3A%3Avec

Functions to initiate and manage the TLS handshake process. `connect` starts a client-side handshake, `accept` starts a server-side handshake, and `do_handshake` performs the handshake process explicitly.

```rust
pub fn connect(&mut self) -> Result<(), Error>
Initiates a client-side TLS handshake.
This corresponds to `SSL_connect`.
```

```rust
pub fn accept(&mut self) -> Result<(), Error>
Initiates a server-side TLS handshake.
This corresponds to `SSL_accept`.
```

```rust
pub fn do_handshake(&mut self) -> Result<(), Error>
Initiates the handshake.
This corresponds to `SSL_do_handshake`.
```

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

### Construct and Configure KeyUsage in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/extension/struct.KeyUsage.html?search=std%3A%3Avec

Demonstrates the initialization of a KeyUsage builder and the application of various usage flags using the fluent builder pattern.

```Rust
use pingora_boringssl::x509::extension::KeyUsage;

let mut key_usage = KeyUsage::new();
key_usage.critical()
    .digital_signature()
    .key_encipherment();

let extension = key_usage.build().expect("Failed to build extension");
```

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

### Access MessageDigest Properties in Rust

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

Methods to retrieve the raw OpenSSL pointer associated with a MessageDigest instance and to get the size (in bytes) of the digest output. Also includes a method to get the digest's type (NID).

```rust
pub fn as_ptr(&self) -> *const env_md_st
pub fn size(&self) -> usize
pub fn type_(&self) -> Nid
```

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

### Initialize and Configure Ssl Session

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.Ssl.html

Demonstrates how to create a new Ssl instance from an SslContext and configure session parameters like verification depth and curves.

```Rust
let ssl = Ssl::new(&ctx)?;
ssl.set_verify(SslVerifyMode::PEER);
ssl.set_verify_depth(5);
ssl.set_curves_list("P-256:X25519")?;
```

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

### PKeyRef: Get Key Size and Compare Public Keys in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/pkey/struct.PKeyRef.html?search=u32+-%3E+bool

Shows how to get the maximum signature size in bytes for a key and compare the public components of two keys. These methods are analogous to EVP_PKEY_size and public key comparison functions.

```Rust
use pingora_boringssl::pkey::PKeyRef;

// Assuming pkey_ref and other_pkey_ref are instances of PKeyRef<T>

// Get the maximum signature size in bytes
let signature_size: usize = pkey_ref.size();

// Compare public keys
let are_equal: bool = pkey_ref.public_eq(&other_pkey_ref);
```

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

### Configure Certificate and Private Key Operations

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslContextBuilder.html

Utility methods for checking key consistency, registering custom certificate compression algorithms, and configuring custom private key methods.

```rust
pub fn check_private_key(&self) -> Result<(), ErrorStack>
pub fn add_certificate_compression_algorithm<C>(&mut self, compressor: C) -> Result<(), ErrorStack>
pub fn set_private_key_method<M>(&mut self, method: M)
```

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

### Build and Use X509 Certificate Store in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/store/index.html?search=std%3A%3Avec

Demonstrates how to build an `X509Store` by creating a self-signed certificate and adding it to a `X509StoreBuilder`. This store can then be used to verify peer certificates.

```rust
use boring::x509::store::{X509StoreBuilder, X509Store};
use boring::x509::{X509, X509Name};
use boring::asn1::Asn1Time;
use boring::pkey::PKey;
use boring::hash::MessageDigest;
use boring::rsa::Rsa;
use boring::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();
let mut builder = X509::builder().unwrap();

// Sep 27th, 2016
let sample_time = Asn1Time::from_unix(1474934400).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 /std/pin/Pin/as_mut

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxSelectCertFuture.html?search=std%3A%3Avec

Retrieves a mutable reference to the pinned value.

```APIDOC
## GET /std/pin/Pin/as_mut

### Description
Gets a mutable reference to the pinned value this `Pin<Ptr>` points to. Useful for reborrowing the pin when calling multiple methods that consume the pointer.

### Method
GET

### Endpoint
`pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>`

### Response
#### Success Response (200)
- **return** (Pin<&mut T>) - A pinned mutable reference to the underlying data.
```

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

### Initialize and Serialize X509Req

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509Req.html?search=u32+-%3E+bool

Demonstrates how to instantiate an X509Req using the builder pattern and how to serialize the resulting request into PEM or DER formats.

```Rust
use pingora_boringssl::x509::X509Req;

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

// Serialize to PEM
let pem = req.to_pem()?;

// Serialize to DER
let der = req.to_der()?;
```

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

### GET /std/pin/Pin/as_ref

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxSelectCertFuture.html?search=std%3A%3Avec

Retrieves a shared reference to the pinned value.

```APIDOC
## GET /std/pin/Pin/as_ref

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a safe conversion from `&Pin<Pointer<T>>` to `Pin<&T>`.

### Method
GET

### Endpoint
`pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>`

### Response
#### Success Response (200)
- **return** (Pin<&T>) - A pinned shared reference to the underlying data.
```

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

### Initialize X509StoreContextRef

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509StoreContextRef.html?search=u32+-%3E+bool

Initializes the context with a trust store, certificate, and chain, executing a closure within the initialized state. This manages the lifecycle of the context by cleaning it up automatically after the closure finishes.

```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 /std/pin/Pin/as_ref

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxCustomVerifyFuture.html?search=u32+-%3E+bool

Retrieves a shared reference to the pinned value.

```APIDOC
## GET /std/pin/Pin/as_ref

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a safe operation as the contract of `Pin::new_unchecked` guarantees the pointee cannot move.

### Method
GET

### Endpoint
`pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>`

### Parameters
#### Path Parameters
- **self** (Pin<Ptr>) - Required - The pinned pointer instance.

### Response
#### Success Response (200)
- **Pin<&T>** (Object) - A pinned shared reference to the underlying data.
```

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

### Create New X509StoreBuilder

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

Instantiates a new X509StoreBuilder, returning a Result that may contain the builder or an ErrorStack. The newly created store is initially empty.

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

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

### SSL Protocol Version Information

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslRef.html?search=u32+-%3E+bool

Get the SSL/TLS protocol version of the session.

```APIDOC
## GET /ssl/session/version

### Description
Retrieves the protocol version of the SSL/TLS session.

### Method
GET

### Endpoint
/ssl/session/version

### Parameters
None

### Response
#### Success Response (200)
- **version_str** (string) - A string describing the protocol version (e.g., "TLSv1.2", "TLSv1.3").

#### Response Example
```json
{
  "version_str": "TLSv1.3"
}
```
```

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

### Configure and Initiate TLS Connection

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.ConnectConfiguration.html?search=std%3A%3Avec

Demonstrates how to use ConnectConfiguration to set TLS parameters and initiate a connection on a stream. The methods allow for fine-grained control over SNI and hostname verification.

```rust
use pingora_boringssl::ssl::ConnectConfiguration;

// Example of configuring and connecting
let mut config = ConnectConfiguration::new();
config.set_use_server_name_indication(true);
config.verify_hostname(true);

// Initiate connection on a stream
let ssl_stream = config.connect("example.com", stream)?;
```

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

### Configure TLS Server with SslAcceptor

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

Shows how to set up a TLS server using SslAcceptor with certificate and private key files. The acceptor handles incoming TCP connections and upgrades them to SslStreams.

```rust
use boring::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 */ }
    }
}
```

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

### Nid Struct Definition and Example in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/nid/struct.Nid.html

Defines the `Nid` struct used for OpenSSL object identifiers and provides an example of how to access its raw integer value. The `Nid` struct itself is private, but its constants are public. Users typically interact with these constants rather than creating `Nid` instances directly.

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

// Example usage:
use boring::nid::Nid;

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

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

### Construct and Configure BasicConstraints

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/extension/struct.BasicConstraints.html

Demonstrates how to instantiate a BasicConstraints object, configure its properties using the builder pattern, and finalize it into an X509Extension.

```rust
use pingora_boringssl::x509::extension::BasicConstraints;

let mut constraints = BasicConstraints::new();
constraints.critical()
    .ca()
    .pathlen(1);

let extension = constraints.build().expect("Failed to build extension");
```

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

### GET /std/pin/Pin/as_mut

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxCustomVerifyFuture.html?search=u32+-%3E+bool

Retrieves a mutable reference to the pinned value for reborrowing.

```APIDOC
## GET /std/pin/Pin/as_mut

### Description
Gets a mutable reference to the pinned value this `Pin<Ptr>` points to. Useful for calling multiple methods that consume the pinning pointer.

### Method
GET

### Endpoint
`pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>`

### Response
#### Success Response (200)
- **Pin<&mut T>** (Object) - A pinned mutable reference to the underlying data.
```

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

### Pin<Ptr>::as_mut

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.ExDataFuture.html

Gets a mutable reference to the pinned value.

```APIDOC
## GET /websites/rs_pingora-boringssl_0_8_0/as_mut

### Description
Gets a mutable reference to the pinned value this `Pin<Ptr>` points to. This is a generic method to go from `&mut Pin<Pointer<T>>` to `Pin<&mut T>`. It is safe because, as part of the contract of `Pin::new_unchecked`, the pointee cannot move after `Pin<Pointer<T>>` got created. This method is useful when doing multiple calls to functions that consume the pinning pointer.

### Method
GET

### Endpoint
`/websites/rs_pingora-boringssl_0_8_0/as_mut`

### Parameters
#### Query Parameters
- **Ptr** (Pointer) - Required - The pointer type.

#### Request Body
None

### Response
#### Success Response (200)
- **Pin<&mut T>** (Pin<&mut Target>) - A pinned mutable reference to the target value.

#### Response Example
```json
{
  "example": "Pin<&mut Target>"
}
```

### Example Usage
```rust
use std::pin::Pin;

impl Type {
    fn method(self: Pin<&mut Self>) {
        // do something
    }

    fn call_method_twice(mut self: Pin<&mut Self>) {
        // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
        self.as_mut().method();
        self.as_mut().method();
    }
}
```
```

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

### Initialize and Configure X509VerifyParam

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/verify/struct.X509VerifyParam.html

Demonstrates how to create a new instance of X509VerifyParam and configure verification settings such as hostname and verification depth.

```rust
use pingora_boringssl::x509::verify::X509VerifyParam;

fn configure_verification() -> Result<(), Box<dyn std::error::Error>> {
    let mut param = X509VerifyParam::new()?;
    
    // Set the expected hostname for verification
    param.set_host("example.com")?;
    
    // Set the verification depth
    param.set_depth(2);
    
    Ok(())
}
```

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

### Initialize X509StoreBuilder in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/store/struct.X509StoreBuilder.html

Creates a new, empty X509StoreBuilder. This builder is the starting point for configuring a certificate store. It returns a Result, indicating potential errors during initialization.

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

// ...

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

```

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

### Pin<Ptr>::as_ref

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.ExDataFuture.html

Gets a shared reference to the pinned value.

```APIDOC
## GET /websites/rs_pingora-boringssl_0_8_0/as_ref

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`. It is safe because, as part of the contract of `Pin::new_unchecked`, the pointee cannot move after `Pin<Pointer<T>>` got created.

### Method
GET

### Endpoint
`/websites/rs_pingora-boringssl_0_8_0/as_ref`

### Parameters
#### Query Parameters
- **Ptr** (Pointer) - Required - The pointer type.

#### Request Body
None

### Response
#### Success Response (200)
- **Pin<&T>** (Pin<&Target>) - A pinned shared reference to the target value.

#### Response Example
```json
{
  "example": "Pin<&Target>"
}
```
```

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

### Constructing an X509 Certificate Request with X509ReqBuilder

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509ReqBuilder.html?search=u32+-%3E+bool

Demonstrates the initialization and configuration of an X509ReqBuilder. This includes setting the version, subject name, public key, and signing the request with a private key.

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

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

// Configure request fields
builder.set_version(0)?;
builder.set_subject_name(&subject_name)?;
builder.set_pubkey(&pkey)?;

// Sign the request
builder.sign(&private_key, MessageDigest::sha256())?;

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

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

### GET /slice/subslice_range

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

Identifies the range of indices corresponding to a given subslice.

```APIDOC
## GET /slice/subslice_range

### Description
Returns the range of indices that a subslice points to. This is a nightly-only experimental API.

### Parameters
#### Query Parameters
- **subslice** (Slice<T>) - Required - The subslice to locate within the parent slice.

### Response
#### Success Response (200)
- **range** (Option<Range<usize>>) - The range of indices, or None if the subslice is not aligned or out of bounds.
```

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

### GET /slice/is_sorted

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

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. Returns true if for each element 'a' and its following element 'b', 'a <= b' holds.

### Method
GET

### Endpoint
/slice/is_sorted

### Response
#### Success Response (200)
- **result** (bool) - True if the slice is sorted, false otherwise.
```

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

### Initialize X509StoreContext for Verification in Rust

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

Initializes an X509StoreContext with trusted certificates, the certificate to verify, and its chain. It then calls a provided closure with the initialized context for operations like verification. The context is cleaned up after the closure returns.

```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 /slice/last

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

Retrieves the last element of the 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** (T) - The last element of the slice.

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

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

### Build X509Store from Builder

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

Consumes the X509StoreBuilder and constructs the final X509Store. This method takes ownership of the builder and returns the configured certificate store.

```rust
pub fn build(self) -> X509Store
```

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

### Slice Starts With

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

Checks if a slice begins with a specified prefix slice.

```APIDOC
## GET /slice/starts_with

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.
Always returns `true` if `needle` is an empty slice.

### Method
GET

### Endpoint
`/slice/starts_with`

### Parameters
#### Query Parameters
- **needle** (array) - Required - The slice to check as a prefix.

### Request Example
```json
{
  "example": "Not applicable for GET request"
}
```

### Response
#### Success Response (200)
- **bool** (boolean) - `true` if the slice starts with the `needle`, `false` otherwise.

#### Response Example
```json
{
  "example": true
}
```
```

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

### Initiate Client-Side TLS Session in Rust

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

Sets up a client-side TLS session on a given stream for a specified domain. This method combines `into_ssl` and `Ssl::setup_connect` for convenience. The domain is used for SNI and hostname verification.

```rust
pub fn setup_connect<S>( self, domain: &str, stream: S, ) -> Result<MidHandshakeSslStream<S>, ErrorStack>
where S: Read + Write,
```

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

### SSL Configuration Methods

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

Examples of configuring specific SSL properties such as verification depth and custom verify callbacks using the underlying SslRef methods.

```rust
let mut ssl = config.into_ssl("example.com").unwrap();
ssl.set_verify_depth(3);
ssl.set_verify(SslVerifyMode::PEER);
```

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

### fn as_rchunks

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

Splits a slice into N-element arrays starting from the end.

```APIDOC
## [METHOD] as_rchunks<const N: usize>

### Description
Splits the slice into a slice of `N`-element arrays starting from the end, returning the remainder and the chunks.

### Panics
- Panics if `N` is zero.

### Response
- **(&[T], &[[T; N]])** - A tuple containing the remainder slice and the slice of arrays.
```

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

### Slice Starts With Prefix

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/hash/struct.DigestBytes.html

Checks if a slice begins with a specified prefix.

```APIDOC
## GET /slice/starts_with

### Description
Checks if a slice starts with the given `needle` slice.

### Method
GET

### Endpoint
`/slice/starts_with`

### Parameters
#### Query Parameters
- **needle** (array[T]) - Required - The slice to check as a prefix.

### Request Example
```json
{
  "needle": [10, 40]
}
```

### Response
#### Success Response (200)
- **result** (boolean) - True if the slice starts with the `needle`, false otherwise.

#### Response Example
```json
{
  "result": true
}
```
```

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

### Initialize SslContext Builder

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslContext.html

Demonstrates how to create a new builder for an SslContext using a specified SslMethod. This is the primary entry point for configuring TLS settings.

```rust
pub fn builder(method: SslMethod) -> Result<SslContextBuilder, ErrorStack>
```

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

### GET /Box/Iterator/next

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxPrivateKeyMethodFinish.html?search=std%3A%3Avec

Advances the iterator contained within the Box and returns the next value.

```APIDOC
## GET /Box/Iterator/next

### Description
Advances the iterator stored within the Box and returns the next element in the sequence. If the iterator is exhausted, it returns None.

### Method
GET

### Endpoint
/Box/Iterator/next

### Response
#### Success Response (200)
- **item** (Option<Item>) - The next element of the iterator or None if exhausted.

#### Response Example
{
  "item": 1
}
```

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

### Constructing X509 Names with X509NameBuilder

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509NameBuilder.html

Demonstrates how to initialize an X509NameBuilder, add entries using text or NID, and finalize the construction to produce an X509Name object.

```rust
use pingora_boringssl::x509::X509NameBuilder;
use openssl::nid::Nid;

let mut builder = X509NameBuilder::new()?;
builder.append_entry_by_text("CN", "example.com")?;
builder.append_entry_by_nid(Nid::COUNTRYNAME, "US")?;

let name = builder.build();
```

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

### Create and configure an X509 certificate store in Rust

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

Demonstrates how to generate a self-signed X509 certificate using RSA keys and add it to an X509Store. This process involves using X509StoreBuilder to construct the store, which is then used for certificate verification.

```rust
use boring::x509::store::{X509StoreBuilder, X509Store};
use boring::x509::{X509, X509Name};
use boring::asn1::Asn1Time;
use boring::pkey::PKey;
use boring::hash::MessageDigest;
use boring::rsa::Rsa;
use boring::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();
let mut builder = X509::builder().unwrap();

// Sep 27th, 2016
let sample_time = Asn1Time::from_unix(1474934400).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();
```

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

### Pin<Ptr>::as_ref

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxPrivateKeyMethodFuture.html?search=u32+-%3E+bool

Gets a shared reference to the pinned value this `Pin` points to.

```APIDOC
## GET /websites/rs_pingora-boringssl_0_8_0/as_ref

### Description
Gets a shared reference to the pinned value this `Pin` points to. This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`. It is safe because, as part of the contract of `Pin::new_unchecked`, the pointee cannot move after `Pin<Pointer<T>>` got created. “Malicious” implementations of `Pointer::Deref` are likewise ruled out by the contract of `Pin::new_unchecked`.

### Method
GET

### Endpoint
`/websites/rs_pingora-boringssl_0_8_0/as_ref`

### Parameters
#### Query Parameters
- **Ptr** (Pointer) - Required - The type of the pointer.

#### Request Body
None

### Response
#### Success Response (200)
- **Pin<&T>** (Pin) - A shared reference to the pinned value.
```

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

### Configure and Initiate TLS Connection

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

Demonstrates how to use ConnectConfiguration to set TLS parameters and initiate a connection on a stream. The builder pattern allows for chaining configuration methods before calling connect.

```rust
let mut config = ConnectConfiguration::new();
config.set_use_server_name_indication(true);
config.set_verify_hostname(true);

let stream = TcpStream::connect("example.com:443").unwrap();
let ssl_stream = config.connect("example.com", stream).unwrap();
```

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

### GET /buffer/status

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxGetSessionFinish.html?search=u32+-%3E+bool

Retrieves information about the current state of the mutable buffer, such as remaining capacity.

```APIDOC
## GET /buffer/status

### Description
Returns information about the buffer's remaining capacity and readiness for further writes.

### Method
GET

### Response
#### Success Response (200)
- **remaining_mut** (number) - The number of bytes that can be written.
- **has_remaining_mut** (boolean) - Whether there is space available.
```

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

### GET /buffer/metadata

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxCustomVerifyFinish.html?search=std%3A%3Avec

Retrieves information about the current state of the mutable buffer, such as remaining capacity.

```APIDOC
## GET /buffer/metadata

### Description
Returns the remaining capacity of the buffer or checks if space is available.

### Method
GET

### Response
#### Success Response (200)
- **remaining_mut** (integer) - The number of bytes that can be written.
- **has_remaining_mut** (boolean) - True if there is space available.
```

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

### Constructing X509Name using X509NameBuilder

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509NameBuilder.html?search=std%3A%3Avec

Demonstrates how to instantiate an X509NameBuilder, add entries using text or NID, and finalize the construction to produce an X509Name object.

```rust
use pingora_boringssl::x509::X509NameBuilder;

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

// Add entries by text
builder.append_entry_by_text("CN", "example.com")?;

// Add entries by NID
builder.append_entry_by_nid(Nid::COUNTRYNAME, "US")?;

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

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

### Create and Configure KeyUsage Extension in Rust

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/extension/struct.KeyUsage.html?search=u32+-%3E+bool

Demonstrates how to create a new KeyUsage extension, set various key usage flags (like digital signature, non-repudiation, etc.), mark it as critical, and finally build it into an X509Extension object. This is useful for defining the permitted cryptographic operations for a certificate.

```rust
use pingora_boringssl::x509::extension::KeyUsage;

// Create a new KeyUsage extension
let mut key_usage = KeyUsage::new();

// Set specific key usage flags
key_usage.digital_signature();
key_usage.key_encipherment();

// Mark the extension as critical
key_usage.critical();

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

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

### GET /slice/element_offset

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

Calculates the index of an element reference using pointer arithmetic.

```APIDOC
## GET /slice/element_offset

### Description
Returns the index that an element reference points to within the slice. Does not perform value comparison.

### Parameters
#### Query Parameters
- **element** (T) - Required - The reference to the element to locate.

### Response
#### Success Response (200)
- **index** (Option<usize>) - The index of the element, or None if the reference is unaligned or invalid.
```

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

### Context Options Management

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/struct.SslConnectorBuilder.html?search=u32+-%3E+bool

Methods for setting, getting, and clearing SSL context options.

```APIDOC
## POST /set_options

### Description
Enables specific options for the context.

### Method
POST

### Parameters
- **option** (SslOptions) - Required - The options to enable.

## GET /options

### Description
Returns the currently configured options for the context.

### Method
GET

### Response
- **options** (SslOptions) - The current set of options.
```

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

### Pin<Ptr> Implementations

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/ssl/type.BoxPrivateKeyMethodFuture.html?search=u32+-%3E+bool

Provides documentation for the implementations of Pin<Ptr>, including methods for constructing and unwrapping Pin instances.

```APIDOC
## Implementations for Pin<Ptr>

### impl<Ptr> Pin<Ptr>
where Ptr: Deref, <Ptr as Deref>::Target: Unpin

#### pub const fn new(pointer: Ptr) -> Pin<Ptr>

##### Description
Constructs a new `Pin<Ptr>` around a pointer to some data of a type that implements `Unpin`. Unlike `Pin::new_unchecked`, this method is safe because the pointer `Ptr` dereferences to an `Unpin` type, which cancels the pinning guarantees.

##### Examples
```rust
use std::pin::Pin;

let mut val: u8 = 5;

// Since `val` doesn't care about being moved, we can safely create a "facade" `Pin`
// which will allow `val` to participate in `Pin`-bound apis  without checking that
// pinning guarantees are actually upheld.
let mut pinned: Pin<&mut u8> = Pin::new(&mut val);
```

#### pub const fn into_inner(pin: Pin<Ptr>) -> Ptr

##### Description
Unwraps this `Pin<Ptr>`, returning the underlying pointer. Doing this operation safely requires that the data pointed at by this pinning pointer implements `Unpin` so that we can ignore the pinning invariants when unwrapping it.

##### Examples
```rust
use std::pin::Pin;

let mut val: u8 = 5;
let pinned: Pin<&mut u8> = Pin::new(&mut val);

// Unwrap the pin to get the underlying mutable reference to the value. We can do
// this because `val` doesn't care about being moved, so the `Pin` was just
// a "facade" anyway.
let r = Pin::into_inner(pinned);
assert_eq!(*r, 5);
```

### impl<Ptr> Pin<Ptr>
where Ptr: Deref

#### pub const unsafe fn new_unchecked(pointer: Ptr) -> Pin<Ptr>

##### Description
Constructs a new `Pin<Ptr>` around a reference to some data of a type that may or may not implement `Unpin`. If `pointer` dereferences to an `Unpin` type, `Pin::new` should be used instead.
```

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

### GET /slice/first_chunk

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

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

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

### Response
#### Success Response (200)
- **chunk** (Array<T, N>) - The first N elements.

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

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

### Manage Protocol Versions and Extensions

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

Functions to configure minimum/maximum protocol versions, ALPN protocols, and extension permutation settings.

```rust
pub fn set_min_proto_version(&mut self, version: Option<SslVersion>) -> Result<(), ErrorStack>
pub fn set_max_proto_version(&mut self, version: Option<SslVersion>) -> Result<(), ErrorStack>
pub fn set_alpn_protos(&mut self, protocols: &[u8]) -> Result<(), ErrorStack>
pub fn set_permute_extensions(&mut self, enabled: bool)
```

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

### Configure SSL Session Parameters

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

Methods for setting custom verification callbacks, temporary DH/ECDH keys, ALPN protocols, and extension permutation settings.

```rust
pub fn set_custom_verify_callback<F>(&mut self, mode: SslVerifyMode, callback: F) where F: Fn(&mut SslRef) -> Result<(), SslVerifyError> + 'static + Sync + Send;
pub fn set_tmp_dh(&mut self, dh: &DhRef<Params>) -> Result<(), ErrorStack>;
pub fn set_tmp_ecdh(&mut self, key: &EcKeyRef<Params>) -> Result<(), ErrorStack>;
pub fn set_permute_extensions(&mut self, enabled: bool);
pub fn set_alpn_protos(&mut self, protocols: &[u8]) -> Result<(), ErrorStack>;
```

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

### Manage Protocol Versions

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

Methods for getting and setting minimum and maximum supported TLS protocol versions.

```rust
pub fn set_min_proto_version(&mut self, version: Option<SslVersion>) -> Result<(), ErrorStack>;
pub fn set_max_proto_version(&mut self, version: Option<SslVersion>) -> Result<(), ErrorStack>;
pub fn min_proto_version(&mut self) -> Option<SslVersion>;
pub fn max_proto_version(&self) -> Option<SslVersion>;
```

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

### X509ReqBuilder Methods

Source: https://docs.rs/pingora-boringssl/0.8.0/pingora_boringssl/x509/struct.X509ReqBuilder.html

Methods for initializing, configuring, and signing X.509 certificate requests.

```APIDOC
## Rust Struct: X509ReqBuilder

### Description
A builder used to construct an `X509Req` object, corresponding to `X509_REQ` in BoringSSL.

### Methods

- **new()** -> Result<X509ReqBuilder, ErrorStack>
  - Creates a new instance of the builder.

- **set_version(version: i32)** -> Result<(), ErrorStack>
  - Sets the numerical version field of the request.

- **set_subject_name(subject_name: &X509NameRef)** -> Result<(), ErrorStack>
  - Sets the issuer/subject name for the request.

- **set_pubkey<T>(key: &PKeyRef<T>)** -> Result<(), ErrorStack>
  - Sets the public key associated with the request.

- **add_extensions(extensions: &StackRef<X509Extension>)** -> Result<(), ErrorStack>
  - Adds extension fields to the certificate request.

- **sign<T>(key: &PKeyRef<T>, hash: MessageDigest)** -> Result<(), ErrorStack>
  - Signs the request using a private key and a specified message digest.

- **build()** -> X509Req
  - Finalizes the builder and returns the `X509Req` object.

### Request Example (Usage)
```rust
let mut builder = X509ReqBuilder::new()?;
builder.set_version(0)?;
builder.set_subject_name(&name)?;
builder.set_pubkey(&pkey)?;
builder.sign(&priv_key, MessageDigest::sha256())?;
let req = builder.build();
```
```
Tokens:
Raw