Ed25519 Dalek

https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/
Admin
A Rust implementation of ed25519 key generation, signing, and verification, providing cryptographic...
Tokens:50,272
Snippets:642
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### FromIterator Implementation Examples

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Examples showing how FromIterator collects Results, stopping at the first Err encountered.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

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

### Batch Verification Example

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/fn.verify_batch.html

Demonstrates how to generate multiple keys and signatures, then verify them in a single batch operation.

```rust
use ed25519_dalek::{
    verify_batch, SigningKey, VerifyingKey, Signer, Signature,
};
use rand::rngs::OsRng;

let mut csprng = OsRng;
let signing_keys: Vec<_> = (0..64).map(|_| SigningKey::generate(&mut csprng)).collect();
let msg: &[u8] = b"They're good dogs Brant";
let messages: Vec<_> = (0..64).map(|_| msg).collect();
let signatures:  Vec<_> = signing_keys.iter().map(|key| key.sign(&msg)).collect();
let verifying_keys: Vec<_> = signing_keys.iter().map(|key| key.verifying_key()).collect();

let result = verify_batch(&messages, &signatures, &verifying_keys);
assert!(result.is_ok());
```

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

### Basic Iterator Collection Example

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/type.Result.html

Demonstrates collecting an iterator into a vector.

```rust
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

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

### Example PEM Encoded Private Key

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/index.html

An example of the ASCII-based PEM encoding format used for cryptographic keys.

```text
-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIBftnHPp22SewYmmEoMcX8VwI4IHwaqd+9LFPj/15eqF
-----END PRIVATE KEY-----
```

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

### IntoIterator Implementation Examples

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Demonstrates converting a Result into an iterator that yields the contained value if Ok, or nothing if Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

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

### Derive Sequence for SPKI struct

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/index.html

Shows an example of a struct using the Sequence derive macro for an X.509 SubjectPublicKeyInfo structure.

```rust
/// X.509 `SubjectPublicKeyInfo` (SPKI)
#[derive(Copy, Clone, Debug, Eq, PartialEq, Sequence)]
pub struct SubjectPublicKeyInfo<'a> {
    /// X.509 `AlgorithmIdentifier`
    pub algorithm: AlgorithmIdentifier<'a>,

    /// Public key data
    pub subject_public_key: BitStringRef<'a>,
}
```

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

### Result::cloned Implementation

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Examples of using the cloned method on Result references.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

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

### Result::transpose Implementation

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Example of transposing a Result of an Option.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

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

### Result::copied Implementation

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Examples of using the copied method on Result references.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

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

### Result::flatten Implementation

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Examples of flattening nested Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

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

### Representing an OID

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/index.html

Example of an OID string identifying the rsaEncryption algorithm.

```text
1.2.840.113549.1.1.1
```

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

### Unwrap Unchecked Examples

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Demonstrates the use of unwrap_unchecked, which returns the contained Ok value without checking for Err. Note that calling this on an Err is undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked(); } // Undefined behavior!
```

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

### Identify PKCS#8 PEM format

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/index.html

PEM-encoded PKCS#8 keys start with this header.

```text
-----BEGIN PRIVATE KEY-----
```

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

### Chain fallible operations with and_then

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Use and_then to chain operations that return a Result. The first example demonstrates basic usage, while the second shows file system metadata access.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Unwrap Err Unchecked Examples

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Demonstrates the use of unwrap_err_unchecked, which returns the contained Err value without checking for Ok. Calling this on an Ok is undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

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

### Enable Serde support

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/index.html

Build the crate with the serde feature to enable serialization support.

```bash
$ cargo build --features="serde"
```

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

### Decoder::remaining_len

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/struct.Decoder.html

Gets the remaining decoded length.

```APIDOC
## pub fn remaining_len(&self) -> usize

### Description
Returns the number of bytes remaining to be decoded after Base64 processing.
```

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

### Context Usage

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.Context.html

Demonstrates how to create a context using SigningKey or VerifyingKey and use it for signing or verifying digests.

```APIDOC
## Context Usage

### Description
Contexts are domain separator strings used to isolate uses of the Ed25519ph algorithm. They are created via `SigningKey::with_context` or `VerifyingKey::with_context`.

### Example
```rust
use ed25519_dalek::{Signature, SigningKey, VerifyingKey, Sha512};
use ed25519_dalek::{DigestSigner, DigestVerifier};

let context_str = b"Local Channel 3";
let prehashed_message = Sha512::default().chain_update(b"Stay tuned for more news at 7");

// Signer
let signing_context = signing_key.with_context(context_str).unwrap();
let signature = signing_context.sign_digest(prehashed_message.clone());

// Verifier
let verifying_context = verifying_key.with_context(context_str).unwrap();
let verified: bool = verifying_context
    .verify_digest(prehashed_message, &signature)
    .is_ok();
```
```

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

### Constructing a VerifyingKey from bytes

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.VerifyingKey.html

Demonstrates how to create a VerifyingKey instance from a byte array using from_bytes.

```rust
use ed25519_dalek::VerifyingKey;
use ed25519_dalek::PUBLIC_KEY_LENGTH;
use ed25519_dalek::SignatureError;

let public_key_bytes: [u8; PUBLIC_KEY_LENGTH] = [
   215,  90, 152,   1, 130, 177,  10, 183, 213,  75, 254, 211, 201, 100,   7,  58,
    14, 225, 114, 243, 218, 166,  35,  37, 175,   2,  26, 104, 247,   7,   81, 26];

let public_key = VerifyingKey::from_bytes(&public_key_bytes)?;
```

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

### Using Context for Signing and Verification

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.Context.html

Demonstrates creating a context for signing and verifying messages using Ed25519ph.

```rust
use ed25519_dalek::{Signature, SigningKey, VerifyingKey, Sha512};
use ed25519_dalek::{DigestSigner, DigestVerifier};

let context_str = b"Local Channel 3";
let prehashed_message = Sha512::default().chain_update(b"Stay tuned for more news at 7");

// Signer
let signing_context = signing_key.with_context(context_str).unwrap();
let signature = signing_context.sign_digest(prehashed_message.clone());

// Verifier
let verifying_context = verifying_key.with_context(context_str).unwrap();
let verified: bool = verifying_context
    .verify_digest(prehashed_message, &signature)
    .is_ok();
```

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

### TryFrom Conversions

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.VerifyingKey.html

Methods for creating a VerifyingKey from various byte representations or PKCS#8 structures.

```APIDOC
## TryFrom Conversions

### Description
VerifyingKey supports conversion from byte slices and PKCS#8 encoded public keys (requires `pkcs8` feature).

### Methods
- **try_from(bytes: &[u8]) -> Result<Self, Error>**
- **try_from(pkcs8_key: &PublicKeyBytes) -> Result<Self, Error>**
- **try_from(pkcs8_key: PublicKeyBytes) -> Result<Self, Error>**
- **try_from(public_key: SubjectPublicKeyInfoRef<'_>) -> Result<Self, Error>**
```

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

### Construct SigningKey from bytes

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.SigningKey.html

Demonstrates creating a SigningKey instance from a byte array representing a secret key.

```rust
use ed25519_dalek::SigningKey;
use ed25519_dalek::SECRET_KEY_LENGTH;
use ed25519_dalek::SignatureError;

let secret_key_bytes: [u8; SECRET_KEY_LENGTH] = [
   157, 097, 177, 157, 239, 253, 090, 096,
   186, 132, 074, 244, 146, 236, 044, 196,
   068, 073, 197, 105, 123, 050, 105, 025,
   112, 059, 172, 003, 028, 174, 127, 096, ];

let signing_key: SigningKey = SigningKey::from_bytes(&secret_key_bytes);
assert_eq!(signing_key.to_bytes(), secret_key_bytes);
```

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

### Create Result References

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/type.Result.html

Use as_ref() to create a Result containing references to the original values.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Ia5String::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.Ia5String.html

Creates a new instance of an IA5String from the provided input.

```APIDOC
## pub fn new<T>(input: &T) -> Result<Ia5String, Error>

### Description
Creates a new `IA5String` instance from the provided input.

### Parameters
- **input** (&T) - Required - The input data to convert into an IA5String. Must implement AsRef<[u8]>.

### Returns
- **Result<Ia5String, Error>** - Returns the new Ia5String on success, or an Error if the input is invalid.
```

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

### PrivateKeyInfo::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/struct.PrivateKeyInfo.html

Creates a new PKCS#8 PrivateKeyInfo message with default attributes and public key.

```APIDOC
## pub fn new(algorithm: AlgorithmIdentifier<AnyRef<'a>>, private_key: &'a [u8]) -> PrivateKeyInfo<'a>

### Description
Creates a new PKCS#8 `PrivateKeyInfo` message. This is a helper method which initializes `attributes` and `public_key` to `None`.

### Parameters
- **algorithm** (AlgorithmIdentifier<AnyRef<'a>>) - Required - X.509 AlgorithmIdentifier for the private key type.
- **private_key** (&'a [u8]) - Required - Private key data.
```

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

### Using an OID as AlgorithmIdentifier parameters

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/index.html

Demonstrates how to construct an AlgorithmIdentifier by parsing ObjectIdentifiers and assigning one as the parameters.

```rust
use spki::{AlgorithmIdentifier, ObjectIdentifier};

let alg_oid = "1.2.840.10045.2.1".parse::<ObjectIdentifier>().unwrap();
let params_oid = "1.2.840.10045.3.1.7".parse::<ObjectIdentifier>().unwrap();

let alg_id = AlgorithmIdentifier {
    oid: alg_oid,
    parameters: Some(params_oid)
};
```

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

### Sign a prehashed message

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.SigningKey.html

Demonstrates how to generate a SigningKey, create a SHA-512 digest of a message, and sign it with an optional context.

```rust
use ed25519_dalek::Digest;
use ed25519_dalek::SigningKey;
use ed25519_dalek::Signature;
use sha2::Sha512;
use rand::rngs::OsRng;

let mut csprng = OsRng;
let signing_key: SigningKey = SigningKey::generate(&mut csprng);
let message: &[u8] = b"All I want is to pet all of the dogs.";

// Create a hash digest object which we'll feed the message into:
let mut prehashed: Sha512 = Sha512::new();

prehashed.update(message);
```

```rust
let context: &[u8] = b"Ed25519DalekSignPrehashedDoctest";

let sig: Signature = signing_key.sign_prehashed(prehashed, Some(context))?;
```

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

### Serialize and deserialize with Serde

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/index.html

Use Serde-compatible formats like bincode to serialize and deserialize keys and signatures.

```rust
use bincode::serialize;

let encoded_verifying_key: Vec<u8> = serialize(&verifying_key).unwrap();
let encoded_signature: Vec<u8> = serialize(&signature).unwrap();
```

```rust
use bincode::deserialize;

let message: &[u8] = b"This is a test of the tsunami alert system.";
let decoded_verifying_key: VerifyingKey = deserialize(&encoded_verifying_key).unwrap();
let decoded_signature: Signature = deserialize(&encoded_signature).unwrap();

let verified: bool = decoded_verifying_key.verify(&message, &decoded_signature).is_ok();

assert!(verified);
```

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

### fn try_from(bytes: &[u8]) -> Result<SigningKey, SignatureError>

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.SigningKey.html

Converts a byte slice into a SigningKey instance.

```APIDOC
## fn try_from(bytes: &[u8]) -> Result<SigningKey, SignatureError>

### Description
Performs the conversion from a byte slice to a SigningKey.

### Parameters
- **bytes** (&[u8]) - Required - The byte slice to convert into a SigningKey.

### Returns
- **Result<SigningKey, SignatureError>** - Returns the SigningKey on success, or a SignatureError if the conversion fails.
```

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

### Ia5StringRef::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.Ia5StringRef.html

Creates a new IA5String reference from the provided input data.

```APIDOC
## pub fn new<T>(input: &'a T) -> Result<Ia5StringRef<'a>, Error>

### Description
Creates a new `IA5String` reference from the provided input. The input must implement `AsRef<[u8]>`.

### Parameters
- **input** (&T) - Required - The input data to borrow from.
```

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

### VideotexStringRef::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.VideotexStringRef.html

Creates a new ASN.1 VideotexString from the provided input.

```APIDOC
## pub fn new<T>(input: &'a T) -> Result<VideotexStringRef<'a>, Error>

### Description
Creates a new ASN.1 `VideotexString` instance. This method borrows from the input data.

### Parameters
- **input** (T: AsRef<[u8]> + ?Sized) - Required - The input data to be represented as a VideotexString.

### Returns
- **Result<VideotexStringRef<'a>, Error>** - Returns a new `VideotexStringRef` on success, or an `Error` if the input is invalid.
```

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

### PemReader::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.PemReader.html

Creates a new PEM reader which decodes data on-the-fly using default 64-character line wrapping.

```APIDOC
## pub fn new(pem: &'i [u8]) -> Result<PemReader<'i>, Error>

### Description
Create a new PEM reader which decodes data on-the-fly. Uses the default 64-character line wrapping.

### Parameters
- **pem** (&[u8]) - Required - The PEM-encoded input data.
```

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

### Decoder::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/struct.Decoder.html

Creates a new PEM Decoder with default 64-character line wrapping.

```APIDOC
## pub fn new(pem: &'i [u8]) -> Result<Decoder<'i>, Error>

### Description
Creates a new PEM Decoder instance using the default 64-character line wrapping settings.

### Parameters
- **pem** (&[u8]) - Required - The PEM-encoded input data.
```

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

### Encoder::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/struct.Encoder.html

Creates a new PEM Encoder with default 64-character line wrapping.

```APIDOC
## Encoder::new(type_label: &str, line_ending: LineEnding, out: &mut [u8])

### Description
Creates a new PEM Encoder with the default options which writes output into the provided buffer. Uses the default 64-character line wrapping.
```

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

### Context Constants and Methods

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.Context.html

Accessing the maximum context length and borrowing key/value data.

```rust
pub const MAX_LENGTH: usize = 255usize
```

```rust
pub fn key(&self) -> &'k K
```

```rust
pub fn value(&self) -> &'v [u8] ⓘ
```

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

### Deriving Zeroize and ZeroizeOnDrop

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/zeroize/index.html

Shows how to automatically implement Zeroize and ensure memory is cleared when the struct goes out of scope.

```rust
use zeroize::{Zeroize, ZeroizeOnDrop};

// This struct will be zeroized on drop
#[derive(Zeroize, ZeroizeOnDrop)]
struct MyStruct([u8; 32]);
```

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

### PrintableString::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.PrintableString.html

Creates a new ASN.1 PrintableString instance from the provided input.

```APIDOC
## pub fn new<T>(input: &T) -> Result<PrintableString, Error>

### Description
Creates a new ASN.1 `PrintableString` from the provided input. The input must implement `AsRef<[u8]>`.

### Parameters
- **input** (&T) - Required - The input data to convert into a PrintableString.
```

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

### PKCS#8 Serialization Methods

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/struct.KeypairBytes.html

Methods for serializing KeypairBytes into DER or PEM formats, or writing them directly to files.

```APIDOC
## fn to_pkcs8_der(&self) -> Result<SecretDocument, Error>
Serialize a `SecretDocument` containing a PKCS#8-encoded private key.

## fn to_pkcs8_pem(&self, line_ending: LineEnding) -> Result<Zeroizing<String>, Error>
Serialize this private key as PEM-encoded PKCS#8 with the given `LineEnding`.

## fn write_pkcs8_der_file(&self, path: impl AsRef<Path>) -> Result<(), Error>
Write ASN.1 DER-encoded PKCS#8 private key to the given path.

## fn write_pkcs8_pem_file(&self, path: impl AsRef<Path>, line_ending: LineEnding) -> Result<(), Error>
Write ASN.1 DER-encoded PKCS#8 private key to the given path.
```

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

### Serialize and deserialize keys

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/index.html

Convert keys and signatures to and from byte arrays using to_bytes and from_bytes.

```rust
use ed25519_dalek::{PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, KEYPAIR_LENGTH, SIGNATURE_LENGTH};

let verifying_key_bytes: [u8; PUBLIC_KEY_LENGTH] = signing_key.verifying_key().to_bytes();
let secret_key_bytes: [u8; SECRET_KEY_LENGTH] = signing_key.to_bytes();
let signing_key_bytes:    [u8; KEYPAIR_LENGTH]    = signing_key.to_keypair_bytes();
let signature_bytes:  [u8; SIGNATURE_LENGTH]  = signature.to_bytes();
```

```rust
let verifying_key: VerifyingKey = VerifyingKey::from_bytes(&verifying_key_bytes)?;
let signing_key: SigningKey = SigningKey::from_bytes(&signing_key_bytes);
let signature: Signature = Signature::try_from(&signature_bytes[..])?;
```

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

### SliceWriter::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.SliceWriter.html

Creates a new SliceWriter instance using the provided mutable byte slice as the backing buffer.

```APIDOC
### pub fn new(bytes: &'a mut [u8]) -> SliceWriter<'a>

Creates a new encoder with the given byte slice as a backing buffer.
```

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

### Header::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.Header.html

Creates a new Header from a Tag and a specified length.

```APIDOC
## pub fn new(tag: Tag, length: impl TryInto<Length>) -> Result<Header, Error>

### Description
Creates a new `Header` from a `Tag` and a specified length. Returns an error if the length exceeds the limits of `Length`.
```

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

### expect

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/type.Result.html

Returns the contained Ok value, consuming the self value, or panics if Err.

```APIDOC
## pub fn expect(self, msg: &str) -> T

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.
```

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

### fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError>

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.VerifyingKey.html

Verifies a signature on a message using the public key associated with this VerifyingKey instance.

```APIDOC
## fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError>

### Description
Verify a signature on a message with this keypair's public key.

### Parameters
- **message** (&[u8]) - The message data to verify.
- **signature** (&Signature) - The signature to verify against the message.

### Returns
- **Result<(), SignatureError>** - Returns `Ok(())` if the signature is valid, and `Err` otherwise.
```

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

### PrivateKeyInfo::version

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/struct.PrivateKeyInfo.html

Retrieves the PKCS#8 version of the structure.

```APIDOC
## pub fn version(&self) -> Version

### Description
Get the PKCS#8 `Version` for this structure. Returns `Version::V1` if `public_key` is `None`, and `Version::V2` if `public_key` is `Some`.
```

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

### Convert Result to Option

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/type.Result.html

Use ok() to convert a Result to an Option, discarding the error.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

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

### Parsing and Conversion

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/struct.KeypairBytes.html

Methods for parsing KeypairBytes from strings or bytes, and converting to other key types.

```APIDOC
## fn from_str(pem: &str) -> Result<KeypairBytes, Error>
Parses a PEM-encoded string to return a `KeypairBytes` value.

## fn try_from(der_bytes: &[u8]) -> Result<KeypairBytes, Error>
Performs the conversion from DER-encoded bytes to `KeypairBytes`.

## fn try_from(keypair: &KeypairBytes) -> Result<PublicKeyBytes, Error>
Converts `KeypairBytes` to `PublicKeyBytes`.

## fn try_from(pkcs8_key: &KeypairBytes) -> Result<SigningKey>
Converts `KeypairBytes` to `SigningKey`.
```

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

### read_pkcs8_pem_file

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/trait.DecodePrivateKey.html

Load a PKCS#8 private key from a PEM-encoded file.

```APIDOC
## fn read_pkcs8_pem_file(path: impl AsRef<Path>) -> Result<Self, Error>

### Description
Load PKCS#8 private key from a PEM-encoded file on the local filesystem.
```

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

### TryFrom<SystemTime> for DateTime

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.DateTime.html

Converts a SystemTime object into a DateTime structure, returning an Error if the conversion fails.

```APIDOC
## fn try_from(time: SystemTime) -> Result<DateTime, Error>

### Description
Performs the conversion from a standard SystemTime to a DateTime structure.

### Parameters
- **time** (SystemTime) - Required - The system time to convert.

### Returns
- **Result<DateTime, Error>** - Returns the converted DateTime or an Error if the conversion is not possible.
```

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

### fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError>

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.SigningKey.html

Verifies a signature on a message using the public key associated with this SigningKey.

```APIDOC
## fn verify(&self, message: &[u8], signature: &Signature) -> Result<(), SignatureError>

### Description
Verify a signature on a message with this signing key’s public key.

### Parameters
- **message** (&[u8]) - Required - The message to verify.
- **signature** (&Signature) - Required - The signature to check against the message.

### Returns
- **Result<(), SignatureError>** - Returns Ok(()) if the signature is valid, or a SignatureError if verification fails.
```

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

### Generate a SigningKey

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/index.html

Requires the rand_core feature. Uses the operating system's CSPRNG to generate a new signing key.

```rust
// $ cargo add ed25519_dalek --features rand_core
use rand::rngs::OsRng;
use ed25519_dalek::SigningKey;
use ed25519_dalek::Signature;

let mut csprng = OsRng;
let signing_key: SigningKey = SigningKey::generate(&mut csprng);
```

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

### Derive Sequence for struct

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/index.html

Demonstrates how to use the Sequence derive macro to encode and decode an ASN.1 structure.

```rust
use der::{asn1::{AnyRef, ObjectIdentifier}, Encode, Decode, Sequence};

/// X.509 `AlgorithmIdentifier` (same as above)
#[derive(Copy, Clone, Debug, Eq, PartialEq, Sequence)] // NOTE: added `Sequence`
pub struct AlgorithmIdentifier<'a> {
    /// This field contains an ASN.1 `OBJECT IDENTIFIER`, a.k.a. OID.
    pub algorithm: ObjectIdentifier,

    /// This field is `OPTIONAL` and contains the ASN.1 `ANY` type, which
    /// in this example allows arbitrary algorithm-defined parameters.
    pub parameters: Option<AnyRef<'a>>
}

// Example parameters value: OID for the NIST P-256 elliptic curve.
let parameters_oid = "1.2.840.10045.3.1.7".parse::<ObjectIdentifier>().unwrap();

let algorithm_identifier = AlgorithmIdentifier {
    // OID for `id-ecPublicKey`, if you're curious
    algorithm: "1.2.840.10045.2.1".parse().unwrap(),

    // `Any<'a>` impls `From<&'a ObjectIdentifier>`, allowing OID constants to
    // be directly converted to an `AnyRef` type for this use case.
    parameters: Some(AnyRef::from(&parameters_oid))
};

// Encode
let der_encoded_algorithm_identifier = algorithm_identifier.to_der().unwrap();

// Decode
let decoded_algorithm_identifier = AlgorithmIdentifier::from_der(
    &der_encoded_algorithm_identifier
).unwrap();

assert_eq!(algorithm_identifier, decoded_algorithm_identifier);
```

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

### Derive Zeroize Macro Usage

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/zeroize/derive.Zeroize.html

Basic syntax for applying the Zeroize derive macro and its associated attributes.

```rust
#[derive(Zeroize)]
{
    // Attributes available to this derive:
    #[zeroize]
}
```

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

### Provide default values with unwrap_or

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Returns the contained Ok value or a provided default value if the result is an Err.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### Decode and Encode PEM Documents

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/index.html

Demonstrates how to decode a PEM-encoded string into its label and data components, and how to re-encode those components back into a PEM string.

```rust
/// Example PEM document
/// NOTE: do not actually put private key literals into your source code!!!
let example_pem = "\
-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIBftnHPp22SewYmmEoMcX8VwI4IHwaqd+9LFPj/15eqF
-----END PRIVATE KEY-----
";

// Decode PEM
let (type_label, data) = pem_rfc7468::decode_vec(example_pem.as_bytes())?;
assert_eq!(type_label, "PRIVATE KEY");
assert_eq!(
   data,
   &[
       48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32, 23, 237, 156, 115, 233, 219,
       100, 158, 193, 137, 166, 18, 131, 28, 95, 197, 112, 35, 130, 7, 193, 170, 157, 251,
       210, 197, 62, 63, 245, 229, 234, 133
   ]
);

// Encode PEM
use pem_rfc7468::LineEnding;
let encoded_pem = pem_rfc7468::encode_string(type_label, LineEnding::default(), &data)?;
assert_eq!(&encoded_pem, example_pem);
```

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

### LineEnding::default

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/enum.LineEnding.html

Returns the default line ending for the current operating system.

```APIDOC
## pub fn default() -> LineEnding

### Description
Provides the appropriate LineEnding variant based on the host operating system.

### Returns
- **LineEnding** - The default LineEnding variant.
```

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

### Using Zeroizing for automatic memory cleanup

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/zeroize/index.html

Wraps a value to ensure its contents are zeroed out when the wrapper is dropped. Requires the zeroize crate.

```rust
use zeroize::Zeroizing;

fn use_secret() {
    let mut secret = Zeroizing::new([0u8; 5]);

    // Set the air shield password
    // Protip (again): don't embed secrets in your source code.
    secret.copy_from_slice(&[1, 2, 3, 4, 5]);
    assert_eq!(secret.as_ref(), &[1, 2, 3, 4, 5]);

    // The contents of `secret` will be automatically zeroized on drop
}
```

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

### read_pkcs8_der_file

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/trait.DecodePrivateKey.html

Load a PKCS#8 private key from an ASN.1 DER-encoded file.

```APIDOC
## fn read_pkcs8_der_file(path: impl AsRef<Path>) -> Result<Self, Error>

### Description
Load PKCS#8 private key from an ASN.1 DER-encoded file on the local filesystem (binary format).
```

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

### Implement PemLabel for SubjectPublicKeyInfo

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/trait.PemLabel.html

Implementation of the PemLabel trait for SubjectPublicKeyInfo with the label set to PUBLIC KEY.

```rust
impl<Params, Key> PemLabel for SubjectPublicKeyInfo<Params, Key> {
    const PEM_LABEL: &'static str = "PUBLIC KEY"
}
```

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

### PemWriter::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.PemWriter.html

Creates a new PEM writer that outputs into the provided buffer with a specified type label and line ending.

```APIDOC
## pub fn new(type_label: &'static str, line_ending: LineEnding, out: &'w mut [u8]) -> Result<PemWriter<'w>, Error>

### Description
Creates a new PEM writer which outputs into the provided buffer. Uses the default 64-character line wrapping.
```

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

### Unwrap Result or Default

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Returns the Ok value or the default value of the type if the result is an Err.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### Implement PemLabel for PrivateKeyInfo

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/trait.PemLabel.html

Implementation of the PemLabel trait for PrivateKeyInfo with the label set to PRIVATE KEY.

```rust
impl PemLabel for PrivateKeyInfo<'_> {
    const PEM_LABEL: &'static str = "PRIVATE KEY"
}
```

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

### Context Definition

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.Context.html

The definition of the Context struct.

```rust
pub struct Context<'k, 'v, K> { /* private fields */ }
```

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

### Any Struct Definition

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.Any.html

The definition of the Any struct, which is available only when the pkcs8 feature is enabled.

```rust
pub struct Any { /* private fields */ }
```

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

### Chain Result with And

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Returns the provided result if the current result is Ok, otherwise returns the Err.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));

let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Create a new Utf8StringRef

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.Utf8StringRef.html

Creates a new ASN.1 UTF8String from the provided input.

```rust
pub fn new<T>(input: &'a T) -> Result<Utf8StringRef<'a>, Error>
where T: AsRef<[u8]> + ?Sized,
```

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

### read_public_key_pem_file

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/trait.DecodePublicKey.html

Load a public key object from a PEM-encoded file.

```APIDOC
## fn read_public_key_pem_file(path: impl AsRef<Path>) -> Result<Self, Error>

### Description
Load public key object from a PEM-encoded file on the local filesystem.

### Parameters
- **path** (impl AsRef<Path>) - Required - The filesystem path to the PEM file.
```

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

### Return alternative result with or

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Returns the provided result if the current result is an Err, otherwise returns the Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```

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

### pub fn encode_string(label: &str, line_ending: LineEnding, input: &[u8]) -> Result<String, Error>

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/fn.encode_string.html

Encodes a byte slice into a PEM-formatted string using the specified label and line ending configuration. This function requires the 'pkcs8' crate feature to be enabled.

```APIDOC
## Function: encode_string

### Description
Encodes a PEM document according to RFC 7468’s “Strict” grammar, returning the result as a `String`.

### Signature
`pub fn encode_string(label: &str, line_ending: LineEnding, input: &[u8]) -> Result<String, Error>`

### Parameters
- **label** (&str) - The PEM label to use for the document.
- **line_ending** (LineEnding) - The line ending convention to apply.
- **input** (&[u8]) - The raw byte data to be encoded.

### Returns
- **Result<String, Error>** - Returns the PEM-encoded string on success, or an error if encoding fails.

### Requirements
- **Feature Flag**: `pkcs8`
```

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

### Zeroizing::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/zeroize/struct.Zeroizing.html

Creates a new Zeroizing wrapper around a value that implements the Zeroize trait.

```APIDOC
## pub fn new(value: Z) -> Zeroizing<Z>

### Description
Wraps a value of type Z (where Z implements Zeroize) into a Zeroizing container. This ensures that the value is automatically zeroized when the container goes out of scope.

### Parameters
- **value** (Z) - The sensitive value to be wrapped and protected.

### Returns
- **Zeroizing<Z>** - A new instance of the Zeroizing wrapper.
```

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

### UtcTime Conversion Methods

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/asn1/struct.UtcTime.html

Methods for converting between UtcTime and various date/time representations.

```rust
pub fn from_date_time(datetime: DateTime) -> Result<UtcTime, Error>
```

```rust
pub fn to_date_time(&self) -> DateTime
```

```rust
pub fn from_unix_duration(unix_duration: Duration) -> Result<UtcTime, Error>
```

```rust
pub fn to_unix_duration(&self) -> Duration
```

```rust
pub fn from_system_time(time: SystemTime) -> Result<UtcTime, Error>
```

```rust
pub fn to_system_time(&self) -> SystemTime
```

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

### Accessing BASE64_WRAP_WIDTH

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/constant.BASE64_WRAP_WIDTH.html

The constant defines the 64-character line width requirement for RFC 7468-compliant PEM files. It is only available when the 'pkcs8' feature is enabled.

```rust
pub const BASE64_WRAP_WIDTH: usize = 64; // 64usize
```

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

### Into Ok Value

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Returns the Ok value without panicking, used for infallible Result types.

```rust

fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

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

### Zeroing sensitive data

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/zeroize/index.html

Demonstrates the basic usage of the Zeroize trait to clear a buffer containing sensitive information.

```rust
use zeroize::Zeroize;

// Protip: don't embed secrets in your source code.
// This is just an example.
let mut secret = b"Air shield password: 1,2,3,4,5".to_vec();
// [ ... ] open the air shield here

// Now that we're done using the secret, zero it out.
secret.zeroize();
```

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

### Result::is_ok_and Implementation

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/oid/type.Result.html

Checking if a Result is Ok and matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

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

### PrivateKeyInfo Struct Definition

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/struct.PrivateKeyInfo.html

The structure definition for PrivateKeyInfo, requiring the pkcs8 crate feature.

```rust
pub struct PrivateKeyInfo<'a> {
    pub algorithm: AlgorithmIdentifier<AnyRef<'a>>,
    pub private_key: &'a [u8],
    pub public_key: Option<&'a [u8]>,
}
```

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

### Encoder::new_wrapped

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/pem/struct.Encoder.html

Creates a new PEM Encoder with a custom line width.

```APIDOC
## Encoder::new_wrapped(type_label: &str, line_width: usize, line_ending: LineEnding, out: &mut [u8])

### Description
Creates a new PEM Encoder which wraps at the given line width. Note that per RFC7468 § 2, encoding PEM with any other wrap width besides 64 is technically non-compliant.
```

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

### SliceReader::new

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/pkcs8/spki/der/struct.SliceReader.html

Creates a new instance of SliceReader for the provided byte slice.

```APIDOC
## pub fn new(bytes: &'a [u8]) -> Result<SliceReader<'a>, Error>

### Description
Creates a new slice reader for the given byte slice.

### Parameters
- **bytes** (&[u8]) - Required - The byte slice to be read.
```

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

### verify

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.SigningKey.html

Verifies a signature on a message using the signing key's public key.

```APIDOC
## pub fn verify( &self, message: &[u8], signature: &Signature, ) -> Result<(), SignatureError>

### Description
Verify a signature on a message with this signing key’s public key.

### Parameters
- **message** (&[u8]) - Required - The message to verify.
- **signature** (&Signature) - Required - The signature to verify.
```

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

### Signature Methods

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/struct.Signature.html

Methods for constructing and interacting with Ed25519 signatures.

```APIDOC
## Signature Construction and Access

### from_bytes
`pub fn from_bytes(bytes: &[u8; 64]) -> Signature`
Parses an Ed25519 signature from a 64-byte array.

### from_components
`pub fn from_components(R: [u8; 32], s: [u8; 32]) -> Signature`
Parses an Ed25519 signature from its R and s components.

### from_slice
`pub fn from_slice(bytes: &[u8]) -> Result<Signature, Error>`
Parses an Ed25519 signature from a byte slice, returning an error if the slice is not 64 bytes.

### r_bytes
`pub fn r_bytes(&self) -> &[u8; 32]`
Returns the bytes for the R component of the signature.

### s_bytes
`pub fn s_bytes(&self) -> &[u8; 32]`
Returns the bytes for the s component of the signature.

### to_bytes
`pub fn to_bytes(&self) -> [u8; 64]`
Returns the inner byte array of the signature.

### to_vec
`pub fn to_vec(&self) -> Vec<u8>`
Converts the signature into a byte vector.
```

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

### Constructing ExpandedSecretKey

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/hazmat/struct.ExpandedSecretKey.html

Methods for creating an ExpandedSecretKey from byte arrays or slices.

```rust
pub fn from_bytes(bytes: &[u8; 64]) -> Self
```

```rust
pub fn from_slice(bytes: &[u8]) -> Result<Self, SignatureError>
```

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

### fn verify(&self, msg: &[u8], signature: &S) -> Result<(), Error>

Source: https://docs.rs/ed25519-dalek/2.2.0/ed25519_dalek/trait.Verifier.html

Verifies that the provided signature for a given message bytestring is authentic using the implementing type (e.g., a public key).

```APIDOC
## fn verify(&self, msg: &[u8], signature: &S) -> Result<(), Error>

### Description
Verifies that the provided signature for a given message bytestring is authentic. Returns an Error if the signature is inauthentic, or () if verification succeeds.

### Parameters
- **msg** (&[u8]) - The message bytestring to verify.
- **signature** (&S) - The signature to verify against the message.

### Returns
- **Result<(), Error>** - Returns Ok(()) if the signature is valid, or an Error if it is inauthentic.
```
Tokens:
Raw