# Struct ring::signature::Ed25519KeyPair [−] [src]

    pub struct Ed25519KeyPair { /* fields omitted */ }

An Ed25519 key pair, for signing.

## Methods

### `impl<'a> Ed25519KeyPair`
[src]

#### `fn generate_pkcs8(rng: &SecureRandom) -> Result<[u8; 85], Unspecified>`

Generates a new key pair and returns the key pair serialized as a PKCS#8 document.

The PKCS#8 document will be a v2 `OneAsymmetricKey` with the public key, as described in RFC 5958 Section 2. See also https://tools.ietf.org/html/draft-ietf-curdle-pkix-04.

#### `fn from_pkcs8(input: Input) -> Result<Ed25519KeyPair, Unspecified>`

Constructs an Ed25519 key pair by parsing an unencrypted PKCS#8 v2 Ed25519 private key.

The input must be in PKCS#8 v2 format, and in particular it must contain the public key in addition to the private key. `from_pkcs8()` will verify that the public key and the private key are consistent with each other.

If you need to parse PKCS#8 v1 files (without the public key) then use `Ed25519KeyPair::from_pkcs8_maybe_unchecked()` instead.

#### `fn from_pkcs8_maybe_unchecked(
input: Input
) -> Result<Ed25519KeyPair, Unspecified>`

Constructs an Ed25519 key pair by parsing an unencrypted PKCS#8 v1 or v2 Ed25519 private key.

It is recommended to use `Ed25519KeyPair::from_pkcs8()`, which accepts only PKCS#8 v2 files that contain the public key. `from_pkcs8_maybe_unchecked()` parses PKCS#2 files exactly like `from_pkcs8()`. It also accepts v1 files. PKCS#8 v1 files do not contain the public key, so when a v1 file is parsed the public key will be computed from the private key, and there will be no consistency check between the public key and the private key.

PKCS#8 v2 files are parsed exactly like `Ed25519KeyPair::from_pkcs8()`.

#### `fn from_seed_and_public_key(
seed: Input,
public_key: Input
) -> Result<Ed25519KeyPair, Unspecified>`

Constructs an Ed25519 key pair from the private key seed `seed` and its public key `public_key`.

It is recommended to use `Ed25519KeyPair::from_pkcs8()` instead.

The private and public keys will be verified to be consistent with each other. This helps avoid misuse of the key (e.g. accidentally swapping the private key and public key, or using the wrong private key for the public key). This also detects any corruption of the public or private key.

#### `fn from_seed_unchecked(seed: Input) -> Result<Ed25519KeyPair, Unspecified>`

Constructs a Ed25519 key pair from the private key seed `seed`.

It is recommended to use `Ed25519KeyPair::from_pkcs8()` instead. When that is not practical, it is recommended to use `Ed25519KeyPair::from_seed_and_public_key()` instead.

Since the public key is not given, the public key will be computed from the private key. It is not possible to detect misuse or corruption of the private key since the public key isn't given as input.

#### `fn public_key_bytes(&'a self) -> &'a [u8]`

Returns a reference to the little-endian-encoded public key bytes.

#### `fn sign(&self, msg: &[u8]) -> Signature`

Returns the signature of the message `msg`.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)