Struct EcKey 

pub struct EcKey<T>(/* private fields */);

Public and optional private key on the given curve.

Implementations

impl EcKey<Params>

pub fn from_curve_name(nid: Nid) -> Result<EcKey<Params>, ErrorStack>

Constructs an EcKey corresponding to a known curve.

It will not have an associated public or private key. This kind of key is primarily useful to be provided to the set_tmp_ecdh methods on Ssl and SslContextBuilder.

This corresponds to EC_KEY_new_by_curve_name.

pub fn from_group(group: &EcGroupRef) -> Result<EcKey<Params>, ErrorStack>

Constructs an EcKey corresponding to a curve.

This corresponds to EC_KEY_set_group.

impl EcKey<Public>

pub fn from_public_key( group: &EcGroupRef, public_key: &EcPointRef, ) -> Result<EcKey<Public>, ErrorStack>

Constructs an EcKey from the specified group with the associated EcPoint: public_key.

This will only have the associated public_key.

Example

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

This corresponds to EC_KEY_set_public_key.

pub fn from_public_key_affine_coordinates( group: &EcGroupRef, x: &BigNumRef, y: &BigNumRef, ) -> Result<EcKey<Public>, ErrorStack>

Constructs a public key from its affine coordinates.

This corresponds to EC_KEY_set_public_key_affine_coordinates.

pub fn public_key_from_pem(pem: &[u8]) -> Result<EcKey<Public>, ErrorStack>

Decodes a PEM-encoded SubjectPublicKeyInfo structure containing a EC key.

The input should have a header of -----BEGIN PUBLIC KEY-----.

This corresponds to PEM_read_bio_EC_PUBKEY.

pub fn public_key_from_der(der: &[u8]) -> Result<EcKey<Public>, ErrorStack>

Decodes a DER-encoded SubjectPublicKeyInfo structure containing a EC key.

This corresponds to d2i_EC_PUBKEY.

impl EcKey<Private>

pub fn generate(group: &EcGroupRef) -> Result<EcKey<Private>, ErrorStack>

Generates a new public/private key pair on the specified curve.

Examples

use openssl::bn::BigNumContext;
use openssl::nid::Nid;
use openssl::ec::{EcGroup, EcKey, PointConversionForm};

let nid = Nid::X9_62_PRIME256V1; // NIST P-256 curve
let group = EcGroup::from_curve_name(nid)?;
let key = EcKey::generate(&group)?;

let mut ctx = BigNumContext::new()?;

let public_key = &key.public_key().to_bytes(
    &group,
    PointConversionForm::COMPRESSED,
    &mut ctx,
)?;
assert_eq!(public_key.len(), 33);
assert_ne!(public_key[0], 0x04);

let private_key = key.private_key().to_vec();
assert!(private_key.len() >= 31);

This corresponds to EC_KEY_generate_key.

pub fn from_private_components( group: &EcGroupRef, private_number: &BigNumRef, public_key: &EcPointRef, ) -> Result<EcKey<Private>, ErrorStack>

Constructs an public/private key pair given a curve, a private key and a public key point.

This corresponds to EC_KEY_set_private_key.

pub fn private_key_from_pem(pem: &[u8]) -> Result<EcKey<Private>, ErrorStack>

Deserializes a private key from a PEM-encoded ECPrivateKey structure.

The input should have a header of -----BEGIN EC PRIVATE KEY-----.

This corresponds to PEM_read_bio_ECPrivateKey.

pub fn private_key_from_pem_passphrase( pem: &[u8], passphrase: &[u8], ) -> Result<EcKey<Private>, ErrorStack>

Deserializes a private key from a PEM-encoded encrypted ECPrivateKey structure.

The input should have a header of -----BEGIN EC PRIVATE KEY-----.

This corresponds to PEM_read_bio_ECPrivateKey.

pub fn private_key_from_pem_callback<F>( pem: &[u8], callback: F, ) -> Result<EcKey<Private>, ErrorStack>

where F: FnOnce(&mut [u8]) -> Result<usize, ErrorStack>,

Deserializes a private key from a PEM-encoded encrypted ECPrivateKey structure.

The callback should fill the password into the provided buffer and return its length.

The input should have a header of -----BEGIN EC PRIVATE KEY-----.

This corresponds to PEM_read_bio_ECPrivateKey.

pub fn private_key_from_der(der: &[u8]) -> Result<EcKey<Private>, ErrorStack>

Decodes a DER-encoded elliptic curve private key structure.

This corresponds to d2i_ECPrivateKey.

Methods from Deref<Target = EcKeyRef<T>>

pub fn private_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>

Serializes the private key to a PEM-encoded ECPrivateKey structure.

The output will have a header of -----BEGIN EC PRIVATE KEY-----.

This corresponds to PEM_write_bio_ECPrivateKey.

pub fn private_key_to_pem_passphrase( &self, cipher: Cipher, passphrase: &[u8], ) -> Result<Vec<u8>, ErrorStack>

Serializes the private key to a PEM-encoded encrypted ECPrivateKey structure.

The output will have a header of -----BEGIN EC PRIVATE KEY-----.

This corresponds to PEM_write_bio_ECPrivateKey.

pub fn private_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>

Serializes the private key into a DER-encoded ECPrivateKey structure.

This corresponds to i2d_ECPrivateKey.

pub fn private_key(&self) -> &BigNumRef

Returns the private key value.

This corresponds to EC_KEY_get0_private_key.

pub fn public_key(&self) -> &EcPointRef

Returns the public key.

This corresponds to EC_KEY_get0_public_key.

pub fn public_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>

Serializes the public key into a PEM-encoded SubjectPublicKeyInfo structure.

The output will have a header of -----BEGIN PUBLIC KEY-----.

This corresponds to PEM_write_bio_EC_PUBKEY.

pub fn public_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>

Serializes the public key into a DER-encoded SubjectPublicKeyInfo structure.

This corresponds to i2d_EC_PUBKEY.

pub fn group(&self) -> &EcGroupRef

Returns the key’s group.

This corresponds to EC_KEY_get0_group.

pub fn check_key(&self) -> Result<(), ErrorStack>

Checks the key for validity.

This corresponds to EC_KEY_check_key.

Trait Implementations

impl<T> AsRef<EcKeyRef<T>> for EcKey<T>

fn as_ref(&self) -> &EcKeyRef<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Borrow<EcKeyRef<T>> for EcKey<T>

fn borrow(&self) -> &EcKeyRef<T>

Immutably borrows from an owned value.

impl<T> Clone for EcKey<T>

fn clone(&self) -> EcKey<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for EcKey<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Deref for EcKey<T>

type Target = EcKeyRef<T>

The resulting type after dereferencing.

fn deref(&self) -> &EcKeyRef<T>

Dereferences the value.

impl<T> DerefMut for EcKey<T>

fn deref_mut(&mut self) -> &mut EcKeyRef<T>

Mutably dereferences the value.

impl<T> Drop for EcKey<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> ForeignType for EcKey<T>

type CType = EC_KEY

The raw C type.

type Ref = EcKeyRef<T>

The type representing a reference to this type.

unsafe fn from_ptr(ptr: *mut EC_KEY) -> EcKey<T>

Constructs an instance of this type from its raw type.

fn as_ptr(&self) -> *mut EC_KEY

Returns a raw pointer to the wrapped value.

impl<T> TryFrom<EcKey<T>> for PKey<T>

type Error = ErrorStack

The type returned in the event of a conversion error.

fn try_from(ec_key: EcKey<T>) -> Result<PKey<T>, ErrorStack>

Performs the conversion.

impl<T> TryFrom<PKey<T>> for EcKey<T>

type Error = ErrorStack

The type returned in the event of a conversion error.

fn try_from(pkey: PKey<T>) -> Result<EcKey<T>, ErrorStack>

Performs the conversion.

impl<T> Send for EcKey<T>

impl<T> Sync for EcKey<T>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes