OpenSSL

https://docs.rs/openssl/latest/openssl
Admin
OpenSSL is a Rust crate providing safe bindings to the OpenSSL cryptography library, supporting...
Tokens:1,357,346
Snippets:12,693
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### trim_ascii_start example

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

Example for the trim_ascii_start method from the Deref target [u8], showing how to remove leading ASCII whitespace.

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

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

### get() example

Source: https://docs.rs/openssl/latest/openssl/string/struct.OpensslString.html

Example for the `get` method from `Deref<Target = str>`. Returns a subslice of the string, returning `None` on invalid indices.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### X509StoreBuilder and X509Store Usage Example

Source: https://docs.rs/openssl/latest/openssl/x509/store/index.html?search=u32+-%3E+bool

Example demonstrating how to create an X509 certificate store using X509StoreBuilder and X509Store, including generating a certificate and adding it to the store.

```APIDOC
## X509StoreBuilder and X509Store Usage Example

### Description
This example demonstrates how to create an X509 certificate store using `X509StoreBuilder` and `X509Store`. It generates an RSA key, creates a self-signed certificate, and adds it to the store.

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

### Notes
- `X509StoreBuilder::new()` creates a new builder.
- `add_cert` adds a certificate to the store.
- `build` finalizes the store.
```

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

### len() example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows how to get the number of elements in a slice using `len()`. The example asserts that the length of `[1, 2, 3]` is 3.

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

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

### X509StoreContextRef::init

Source: https://docs.rs/openssl/latest/openssl/x509/struct.X509StoreContext.html?search=

Initializes the context with a certificate, chain, and store, then calls a closure with the prepared context.

```APIDOC
## X509StoreContextRef::init

### Description
Initializes this context with the given certificate, certificates chain and certificate store. After initializing the context, the `with_context` closure is called with the prepared context. As long as the closure is running, the context stays initialized and can be used to e.g. verify a certificate. The context will be cleaned up, after the closure finished. This corresponds to `X509_STORE_CTX_init` before calling `with_context` and to `X509_STORE_CTX_cleanup` after calling `with_context`.

### Method
`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>`

### Parameters
- `trust` (`&X509StoreRef`) - The certificate store with the trusted certificates.
- `cert` (`&X509Ref`) - The certificate that should be verified.
- `cert_chain` (`&StackRef<X509>`) - The certificates chain.
- `with_context` (`F`) - The closure that is called with the initialized context.

### Return Value
- `Result<T, ErrorStack>` - The result of the closure, or an error.

```

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

### init<F, T>(&mut self, trust: &X509StoreRef, cert: &X509Ref, cert_chain: &StackRef<X509>, with_context: F) -> Result<T, ErrorStack>

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

Initializes this context with the given certificate, certificates chain and certificate store. After initializing the context, the with_context closure is called with the prepared context. As long as the closure is running, the context stays initialized and can be used to e.g. verify a certificate. The context will be cleaned up, after the closure finished. This corresponds to X509_STORE_CTX_init before calling with_context and to X509_STORE_CTX_cleanup after calling with_context.

```APIDOC
## init<F, T>(&mut self, trust: &X509StoreRef, cert: &X509Ref, cert_chain: &StackRef<X509>, with_context: F) -> Result<T, ErrorStack>

### Description
Initializes this context with the given certificate, certificates chain and certificate store. After initializing the context, the `with_context` closure is called with the prepared context. As long as the closure is running, the context stays initialized and can be used to e.g. verify a certificate. The context will be cleaned up, after the closure finished. This corresponds to `X509_STORE_CTX_init` before calling `with_context` and to `X509_STORE_CTX_cleanup` after calling `with_context`.

### Method
`init`

### Parameters
- **trust** (`&X509StoreRef`) - Required - The certificate store with the trusted certificates.
- **cert** (`&X509Ref`) - Required - The certificate that should be verified.
- **cert_chain** (`&StackRef<X509>`) - Required - The certificates chain.
- **with_context** (`F`) - Required - The closure that is called with the initialized context.

### Returns
- `Result<T, ErrorStack>` - The result of the closure.

```

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

### Get integer representation of a Nid

Source: https://docs.rs/openssl/latest/openssl/nid/struct.Nid.html

Shows how to use Nid::as_raw() to get the integer value of a Nid. The example asserts that Nid::AES_256_GCM.as_raw() equals 901.

```rust
use openssl::nid::Nid;

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

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

### pub fn starts_with<P>(&self, pat: P) -> bool

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

Documentation for the `starts_with` method on string slices.

```APIDOC
## `pub fn starts_with<P>(&self, pat: P) -> bool`

### Description
Returns `true` if the given pattern matches a prefix of this string slice. Returns `false` if it does not. The pattern can be a `&str`, in which case this function will return true if the `&str` is a prefix of this string slice. The pattern can also be a `char`, a slice of `char`s, or a function or closure that determines if a character matches. These will only be checked against the first character of this string slice. Look at the second example below regarding behavior for slices of `char`s.

### Method
`starts_with`

### Parameters
- **self** (`&str`) - The string slice to check.
- **pat** (`P`) - The pattern to match. Can be a `&str`, `char`, a slice of `char`s, or a function or closure.

### Returns
- **bool** - `true` if the pattern matches a prefix, `false` otherwise.

### Examples
```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```
```

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

### utf8_chunks iterator output example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows the expected output of an iterator over UTF-8 chunks, yielding Range values with start and end indices. The example is from the documentation of the utf8_chunks method.

```rust
assert_eq!(iter.next(), Some(Range { start: 0, end: 0 }));
assert_eq!(iter.next(), Some(Range { start: 1, end: 3 }));
assert_eq!(iter.next(), Some(Range { start: 4, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 5, end: 6 }));
```

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

### substr_range example

Source: https://docs.rs/openssl/latest/openssl/string/struct.OpensslString.html

Shows how to use `substr_range` to get the range of each substring from a split iterator.

```rust
use core::range::Range;

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(Range { start: 0, end: 1 }));
assert_eq!(iter.next(), Some(Range { start: 3, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 6, end: 7 }));
assert_eq!(iter.next(), Some(Range { start: 9, end: 10 }));
```

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

### BasicConstraints

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

Example demonstrating how to create a BasicConstraints extension and build it into an X509Extension.

```APIDOC
## BasicConstraints

### Description
An extension which indicates whether a certificate is a CA certificate. It can be configured to be critical, set the CA flag, and set the path length constraint.

### Usage
```rust
use openssl::x509::extension::BasicConstraints;
use openssl::x509::X509Extension;

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

let extension: X509Extension = bc.build().unwrap();
```

### Methods
- `new()` - Creates a new `BasicConstraints` builder.
- `critical()` - Marks the extension as critical.
- `ca()` - Sets the CA flag.
- `pathlen(len: u32)` - Sets the path length constraint.
- `build()` - Builds the `X509Extension` from the configured constraints. Returns a `Result<X509Extension, ErrorStack>`.
```

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

### split_off from index 2

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

Example for split_off removing a slice starting with the third element.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

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

### Example: Construct EcKey from public key

Source: https://docs.rs/openssl/latest/openssl/ec/struct.EcKey.html?search=std%3A%3Avec

Shows how to create an EcKey from a public key point using from_public_key. Requires a BigNumContext and an EcGroup. The example includes a placeholder for obtaining public key bytes.

```rust
use openssl::bn::BigNumContext;
use openssl::ec::*;
use openssl::nid::Nid;
use openssl::pkey::PKey;

let group = EcGroup::from_curve_name(Nid::SECP384R1)?;
let mut ctx = BigNumContext::new()?;

// get bytes from somewhere
let public_key = // ...

// create an EcKey from the binary form of a EcPoint
let point = EcPoint::from_bytes(&group, &public_key, &mut ctx)?;
let key = EcKey::from_public_key(&group, &point)?;
key.check_key()?;
```

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

### first() example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows how to get the first element of a slice using `first()`. The example asserts that the first element of `[10, 40, 30]` is `Some(&10)` and that an empty slice returns `None`.

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

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

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

### sign_init

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

Prepares the context for signing using the private key. This corresponds to `EVP_PKEY_sign_init`.

```APIDOC
## sign_init

### Description
Prepares the context for signing using the private key. This corresponds to `EVP_PKEY_sign_init`.

### Method
sign_init

### Signature
`pub fn sign_init(&mut self) -> Result<(), ErrorStack>`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Ok(()) on success, or an error.
```

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

### init

Source: https://docs.rs/openssl/latest/openssl/x509/struct.X509StoreContextRef.html

Initializes the context with a certificate, chain, and store, then invokes a closure with the prepared context.

```APIDOC
## 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>

### Description
Initializes this context with the given certificate, certificates chain and certificate store. After initializing the context, the `with_context` closure is called with the prepared context. As long as the closure is running, the context stays initialized and can be used to e.g. verify a certificate. The context will be cleaned up, after the closure finished.

### Method
N/A (Rust method)

### Endpoint
N/A

### Parameters
- **trust** (`&X509StoreRef`) - Required - The certificate store with the trusted certificates.
- **cert** (`&X509Ref`) - Required - The certificate that should be verified.
- **cert_chain** (`&StackRef<X509>`) - Required - The certificates chain.
- **with_context** (`F`) - Required - The closure that is called with the initialized context.

### Returns
- `Result<T, ErrorStack>` - The result of the closure, or an error if initialization fails.

### Notes
This corresponds to `X509_STORE_CTX_init` before calling `with_context` and to `X509_STORE_CTX_cleanup` after calling `with_context`.
```

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

### first_mut() example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows how to get a mutable reference to the first element using `first_mut()`. The example modifies the first element and asserts the result. It also shows that an empty slice returns `None`.

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

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

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

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

### keygen_init

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

Prepares the context for key generation. This corresponds to `EVP_PKEY_keygen_init`.

```APIDOC
## keygen_init

### Description
Prepares the context for key generation. This corresponds to `EVP_PKEY_keygen_init`.

### Method
keygen_init

### Signature
`pub fn keygen_init(&mut self) -> Result<(), ErrorStack>`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Ok(()) on success, or an error.
```

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

### get: element or subslice

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows the `get` method, which returns a reference to an element or subslice depending on the index type. The example covers a position, a range, an out-of-bounds position, and an out-of-bounds range, all returning `Option`.

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

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

### X509StoreContext::new

Source: https://docs.rs/openssl/latest/openssl/x509/struct.X509StoreContext.html?search=

Creates a new `X509StoreContext` instance.

```APIDOC
## X509StoreContext::new

### Description
Creates a new `X509StoreContext` instance. This corresponds to `X509_STORE_CTX_new`.

### Method
`pub fn new() -> Result<X509StoreContext, ErrorStack>`

### Parameters
None.

### Return Value
- `Result<X509StoreContext, ErrorStack>` - The new context, or an error.

```

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

### starts_with: check if slice starts with a prefix

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Use to check if a slice starts with a given prefix. Returns true if the needle is a prefix or equal to the slice. The example asserts various true and false cases.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

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

### init

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

Initializes the OpenSSL library.

```APIDOC
## init

### Description
Initializes the OpenSSL library.

### Function
`init`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Success or error
```

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

### get example

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

Returns a reference to an element or subslice depending on the index type. Returns None if out of bounds.

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

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

### str::get example

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

Shows how to use the `get` method to safely retrieve a subslice of a string, returning `None` for invalid indices. The example demonstrates valid and invalid ranges, including out-of-bounds and non-boundary indices.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### X509StoreBuilder::new

Source: https://docs.rs/openssl/latest/openssl/x509/store/index.html?search=

Creates a new X509StoreBuilder instance for constructing an X509Store.

```APIDOC
## X509StoreBuilder::new

### Description
Creates a new builder for constructing an X509 certificate store.

### Method
new

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

### Parameters
None

### Returns
- **Result<X509StoreBuilder, ErrorStack>** - A new builder instance or an error.

### Example
```rust
use openssl::x509::store::X509StoreBuilder;
let builder = X509StoreBuilder::new().unwrap();
```
```

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

### as_chunks: split slice into N-element chunks from start

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Splits a slice into N-element chunks from the start, returning a remainder shorter than N. The example shows a slice of length 5 split into 2-element chunks with a remainder of one element.

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

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

### verify_init

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

Prepares the context for signature verification using the public key. This corresponds to `EVP_PKEY_verify_init`.

```APIDOC
## verify_init

### Description
Prepares the context for signature verification using the public key. This corresponds to `EVP_PKEY_verify_init`.

### Method
verify_init

### Signature
`pub fn verify_init(&mut self) -> Result<(), ErrorStack>`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Ok(()) on success, or an error.
```

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

### as_rchunks: split slice into N-element chunks from end

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Splits a slice into N-element chunks starting from the end, returning a remainder shorter than N. The example shows a slice of length 5 split into 2-element chunks with a remainder of one element at the start.

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

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

### Key wrapping and unwrapping example

Source: https://docs.rs/openssl/latest/openssl/aes/index.html

Demonstrates wrapping and unwrapping a key using wrap_key and unwrap_key functions with AesKey. The example uses a key encryption key (KEK) and a key to wrap, then verifies the unwrapped key matches the original.

```rust
use openssl::aes::{AesKey, unwrap_key, wrap_key};

let kek = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
let key_to_wrap = b"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF";

let enc_key = AesKey::new_encrypt(kek).unwrap();
let mut ciphertext = [0u8; 24];
wrap_key(&enc_key, None, &mut ciphertext, &key_to_wrap[..]).unwrap();
let dec_key = AesKey::new_decrypt(kek).unwrap();
let mut orig_key = [0u8; 16];
unwrap_key(&dec_key, None, &mut orig_key, &ciphertext[..]).unwrap();

assert_eq!(&orig_key[..], &key_to_wrap[..]);
```

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

### Iterator Range Assertions

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

Example assertions for an iterator that yields Range values, showing expected start and end indices for consecutive next() calls.

```rust
assert_eq!(iter.next(), Some(Range { start: 0, end: 0 }));
assert_eq!(iter.next(), Some(Range { start: 1, end: 3 }));
assert_eq!(iter.next(), Some(Range { start: 4, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 5, end: 6 }));
```

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

### paramgen_init

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

Prepares the context for key parameter generation. This corresponds to `EVP_PKEY_paramgen_init`.

```APIDOC
## paramgen_init

### Description
Prepares the context for key parameter generation. This corresponds to `EVP_PKEY_paramgen_init`.

### Method
paramgen_init

### Signature
`pub fn paramgen_init(&mut self) -> Result<(), ErrorStack>`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Ok(()) on success, or an error.
```

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

### first_chunk::<N>() example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Shows how to get the first N items of a slice as an array using `first_chunk::<N>()`. The example asserts that a slice of length 3 returns `Some(&[10, 40])` for N=2, a slice of length 1 returns `None` for N=2, and an empty slice returns `Some(&[])` for N=0.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

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

### starts_with

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html?search=

Documentation for the `starts_with` method on slices.

```APIDOC
## `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.

### Signature
```rust
pub fn starts_with(&self, needle: &[T]) -> bool
where
    T: PartialEq,
```

### Parameters
- `needle` (&[T]) - Required - The slice to check as a prefix.

### Return Value
Returns `bool` - `true` if `needle` is a prefix or equal to the slice, `false` otherwise.

### Example
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```
```

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

### Conf::new

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

Documentation for the Conf::new constructor, which creates a configuration parser.

```APIDOC
## Conf::new

### Description
Creates a new configuration parser. This corresponds to the OpenSSL `NCONF_new` function.

### Method
`Conf::new`

### Signature
`pub fn new(method: ConfMethod) -> Result<Conf, ErrorStack>`

### Parameters
- **method** (`ConfMethod`) - Required - The configuration method to use.

### Return Value
- `Result<Conf, ErrorStack>` - A `Conf` instance on success, or an `ErrorStack` on failure.

### Example
```rust
use openssl::conf::{Conf, ConfMethod};

let conf = Conf::new(ConfMethod::default());
```
```

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

### strip_prefix examples

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

Shows usage of str::strip_prefix. Returns Some with the remainder if the string starts with the prefix, otherwise None. The pattern can be a &str, char, slice of chars, or closure.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

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

### split with separators at start/end

Source: https://docs.rs/openssl/latest/openssl/string/struct.OpensslString.html

Shows that separators at the start or end of a string are neighbored by empty strings. The example splits "010" on "0".

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

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

### encrypt_init

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

Prepares the context for encryption using the public key. This corresponds to `EVP_PKEY_encrypt_init`.

```APIDOC
## encrypt_init

### Description
Prepares the context for encryption using the public key. This corresponds to `EVP_PKEY_encrypt_init`.

### Method
encrypt_init

### Signature
`pub fn encrypt_init(&mut self) -> Result<(), ErrorStack>`

### Parameters
None

### Returns
- `Result<(), ErrorStack>` - Ok(()) on success, or an error.
```

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

### rchunks example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Returns an iterator over chunks of chunk_size elements starting from the end. The last chunk may be shorter if chunk_size does not divide the length. Panics if chunk_size is zero.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

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

### PKey::from_rsa

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

Example demonstrating how to generate an RSA key pair and convert it to a PKey using the openssl crate.

```APIDOC
## [Rust] PKey::from_rsa

### Description
Creates a `PKey` from an RSA key. This is a constructor method that wraps an RSA key into a generic public/private key object.

### Method
`PKey::from_rsa(rsa: Rsa) -> Result<PKey<Private>, Error>`

### Parameters
- **rsa** (`Rsa`) - Required - The RSA key to wrap.

### Returns
- `Result<PKey<Private>, Error>` - The resulting key or an error.

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

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

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

### PkeyCtx::sign_init

Source: https://docs.rs/openssl/latest/openssl/pkey_ctx/index.html

Initializes the context for signing operations. Must be called before signing data.

```APIDOC
## PkeyCtx::sign_init

### Description
Initializes the context for signing operations. Must be called before signing data.

### Method
Initialization

### Returns
- **Result<()>** - Ok on success, or an error.

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

let key = Rsa::generate(4096).unwrap();
let key = PKey::from_rsa(key).unwrap();
let mut ctx = PkeyCtx::new(&key).unwrap();
ctx.sign_init().unwrap();
```
```

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

### array_windows example

Source: https://docs.rs/openssl/latest/openssl/hash/struct.DigestBytes.html

Returns an iterator over overlapping windows of N elements starting at the beginning. If N is greater than the slice length, no windows are returned. Panics if N is zero.

```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());
```
Tokens:
Raw