path: root/secret/src/lib.rs

//! Handling secret keys.

extern crate capnp;
#[macro_use]
extern crate capnp_rpc;
#[macro_use]
extern crate failure;
extern crate futures;
extern crate rusqlite;
extern crate time;
extern crate tokio_core;
extern crate tokio_io;

use capnp::capability::Promise;
use capnp_rpc::rpc_twoparty_capnp::Side;
use futures::Future;
use std::cell::RefCell;
use std::fmt;
use std::io;
use std::rc::Rc;
use tokio_core::reactor::Core;

extern crate openpgp;
#[allow(unused_imports)]
#[macro_use]
extern crate sequoia_core;
use sequoia_core as core;
extern crate sequoia_net;
use sequoia_net as net;

/// Macros managing requests and responses.
#[macro_use] mod macros;

use openpgp::Fingerprint;
use openpgp::tpk::TPK;
use core::Context;
use net::ipc;

#[allow(dead_code)] pub /*XXX*/ mod secret_protocol_capnp;
use secret_protocol_capnp::node;

/// Dummy TSK implementation.
pub struct TSK(TPK);

impl TSK {
    pub fn new(tpk: TPK) -> TSK {
        TSK(tpk)
    }

    pub fn from_bytes(b: &[u8]) -> Result<TSK> {
        TPK::from_bytes(b).map(|x| TSK(x))
    }

    pub fn serialize<W: io::Write>(&self, o: &mut W) -> Result<()> {
        self.0.serialize(o)
    }

    pub fn tpk(&self) -> TPK {
        self.0.clone()
    }

    pub fn fingerprint(&self) -> Fingerprint {
        self.0.fingerprint()
    }
}

trait SecretKeyObject {
    fn fingerprint(&self) -> &Fingerprint;
    fn tpk(&self) -> Result<TPK>;
    fn unlock(&self, passphrase: &str) -> Result<()>;
    fn lock(&self) -> Result<()>;
    fn decrypt(&self, sk: &[u8]) -> Result<Vec<u8>>;
}

/// Storage backend.
mod backend;

/// Returns the service descriptor.
#[doc(hidden)]
pub fn descriptor(c: &Context) -> ipc::Descriptor {
    ipc::Descriptor::new(
        c,
        c.home().join("S.secret"),
        c.lib().join("secret-store"),
        backend::factory,
    )
}

/// A secret key object.
pub struct Key {
    core: Rc<RefCell<Core>>,
    fp: Fingerprint,
    key: node::key::Client,
}

impl fmt::Debug for Key {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Key {{ {} }}", self.fp)
    }
}

impl Key {
    fn connect(c: &Context) -> Result<(Core, node::Client)> {
        let descriptor = descriptor(c);
        let core = Core::new()?;
        let handle = core.handle();

        let mut rpc_system
            = match descriptor.connect_with_policy(&handle,
                                                   core::IPCPolicy::External) {
                Ok(r) => r,
                Err(e) => return Err(e.into()),
            };

        let client: node::Client = rpc_system.bootstrap(Side::Server);
        handle.spawn(rpc_system.map_err(|_e| ()));

        Ok((core, client))
    }

    pub fn open(c: &Context, fp: &Fingerprint) -> Result<Self> {
        let (mut core, client) = Self::connect(c)?;

        let mut request = client.open_request();
        request.get().set_fingerprint(&fp.to_hex());

        let key = make_request!(&mut core, request)?;
        Ok(Self::new(Rc::new(RefCell::new(core)), fp, key))
    }

    fn new(core: Rc<RefCell<Core>>, fp: &Fingerprint,
           key: node::key::Client) -> Self {
        Key{core: core, fp: fp.clone(), key: key}
    }

    pub fn import(c: &Context, tsk: &TSK) -> Result<Key> {
        let mut blob = vec![];
        tsk.serialize(&mut blob)?;
        let (mut core, client) = Self::connect(c)?;
        let mut request = client.import_request();
        request.get().set_key(&blob);
        let key = make_request!(core, request)?;
        Ok(Self::new(Rc::new(RefCell::new(core)), &tsk.fingerprint(), key))
    }

    /// Lists all keys.
    pub fn list(c: &Context) -> Result<KeyIter> {
        let (mut core, client) = Self::connect(c)?;
        let request = client.iter_request();
        let iter = make_request!(&mut core, request)?;
        Ok(KeyIter{core: Rc::new(RefCell::new(core)), iter: iter})
    }
}

impl SecretKeyObject for Key {
    /// Returns the fingerprint.
    fn fingerprint(&self) -> &Fingerprint {
        &self.fp
    }

    /// Returns the TPK.
    fn tpk(&self) -> Result<TPK> {
        make_request_map!(self.core.borrow_mut(),
                          self.key.tpk_request(),
                          |tpk| TPK::from_bytes(tpk).map_err(|e| e.into()))
    }

    /// Unlocks this secret key.
    fn unlock(&self, passphrase: &str) -> Result<()> {
        let mut request = self.key.unlock_request();
        request.get().set_passphrase(passphrase.into());
        make_request_map!(self.core.borrow_mut(), request,
                          |_| Ok(()))
    }

    /// Locks this secret key.
    fn lock(&self) -> Result<()> {
        make_request_map!(self.core.borrow_mut(),
                          self.key.lock_request(),
                          |_| Ok(()))
    }