libsignal-protocol 0.1.0

An idiomatic high-level interface to the libsignal-protocol-c crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::{
    errors::FromInternalErrorCode,
    keys::{PrivateKey, PublicKey},
    raw_ptr::Raw,
};
use failure::Error;
use std::{
    fmt::{self, Debug, Formatter},
    ptr,
};

/// A public-private key pair.
#[derive(Clone)]
pub struct KeyPair {
    pub(crate) raw: Raw<sys::ec_key_pair>,
}

impl KeyPair {
    /// Create a new [`KeyPair`] from its public and private keys.
    pub fn new(
        public_key: &PublicKey,
        private_key: &PrivateKey,
    ) -> Result<KeyPair, Error> {
        unsafe {
            let mut raw = ptr::null_mut();
            sys::ec_key_pair_create(
                &mut raw,
                public_key.raw.as_ptr(),
                private_key.raw.as_ptr(),
            )
            .into_result()?;

            Ok(KeyPair {
                raw: Raw::from_ptr(raw),
            })
        }
    }

    /// Get the public key.
    pub fn public(&self) -> PublicKey {
        unsafe {
            let raw = sys::ec_key_pair_get_public(self.raw.as_ptr());
            assert!(!raw.is_null());

            PublicKey {
                raw: Raw::copied_from(raw),
            }
        }
    }

    /// Get the private key.
    pub fn private(&self) -> PrivateKey {
        unsafe {
            let raw = sys::ec_key_pair_get_private(self.raw.as_ptr());
            assert!(!raw.is_null());

            PrivateKey {
                raw: Raw::copied_from(raw),
            }
        }
    }
}

impl Debug for KeyPair {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_struct("KeyPair")
            .field("public", &self.public())
            .field("private", &"<elided>")
            .finish()
    }
}