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
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::ffi::{CStr, CString};
use std::ptr;
use std::result;
use std::str::Utf8Error;

use ffi;
use libc::c_int;

use Result;
use sexp::SExpression;
use mpi::ec::{Curve, Curves};

ffi_enum_wrapper! {
    pub enum Algorithm: c_int {
        Rsa        = ffi::GCRY_PK_RSA,
        RsaEncrypt = ffi::GCRY_PK_RSA_E,
        RsaSign    = ffi::GCRY_PK_RSA_S,
        ElgEncrypt = ffi::GCRY_PK_ELG_E,
        Dsa        = ffi::GCRY_PK_DSA,
        Ecc        = ffi::GCRY_PK_ECC,
        Elg        = ffi::GCRY_PK_ELG,
        Ecdsa      = ffi::GCRY_PK_ECDSA,
        Ecdh       = ffi::GCRY_PK_ECDH,
        Eddsa      = ffi::GCRY_PK_EDDSA,
    }
}

impl Algorithm {
    #[inline]
    pub fn from_name<S: Into<String>>(name: S) -> Option<Algorithm> {
        let name = try_opt!(CString::new(name.into()).ok());
        let result = unsafe { ffi::gcry_pk_map_name(name.as_ptr()) };
        if result != 0 {
            unsafe { Some(Algorithm::from_raw(result)) }
        } else {
            None
        }
    }

    #[inline]
    pub fn is_available(&self) -> bool {
        let _ = ::get_token();
        unsafe { ffi::gcry_pk_test_algo(self.raw()) == 0 }
    }

    #[inline]
    pub fn name(&self) -> result::Result<&'static str, Option<Utf8Error>> {
        self.name_raw()
            .map_or(Err(None), |s| s.to_str().map_err(Some))
    }

    #[inline]
    pub fn name_raw(&self) -> Option<&'static CStr> {
        unsafe {
            ffi::gcry_pk_algo_name(self.raw())
                .as_ref()
                .map(|s| CStr::from_ptr(s))
        }
    }
}

#[inline]
pub fn num_bits(key: &SExpression) -> Option<usize> {
    unsafe {
        let result = ffi::gcry_pk_get_nbits(key.as_raw());
        if result != 0 {
            Some(result as usize)
        } else {
            None
        }
    }
}

#[inline]
pub fn key_grip(key: &SExpression) -> Option<[u8; 20]> {
    unsafe {
        let mut buffer = [0u8; 20];
        if !ffi::gcry_pk_get_keygrip(key.as_raw(), buffer.as_mut_ptr()).is_null() {
            Some(buffer)
        } else {
            None
        }
    }
}

#[inline]
pub fn curve(key: &SExpression) -> Option<Curve> {
    Curves::from(key).next()
}

#[inline]
pub fn test_key(key: &SExpression) -> Result<()> {
    unsafe {
        return_err!(ffi::gcry_pk_testkey(key.as_raw()));
        Ok(())
    }
}

#[inline]
pub fn generate_key(config: &SExpression) -> Result<SExpression> {
    unsafe {
        let mut result: ffi::gcry_sexp_t = ptr::null_mut();
        return_err!(ffi::gcry_pk_genkey(&mut result, config.as_raw()));
        Ok(SExpression::from_raw(result))
    }
}

#[inline]
pub fn encrypt(key: &SExpression, data: &SExpression) -> Result<SExpression> {
    unsafe {
        let mut result: ffi::gcry_sexp_t = ptr::null_mut();
        return_err!(ffi::gcry_pk_encrypt(
            &mut result,
            data.as_raw(),
            key.as_raw()
        ));
        Ok(SExpression::from_raw(result))
    }
}

#[inline]
pub fn decrypt(key: &SExpression, data: &SExpression) -> Result<SExpression> {
    unsafe {
        let mut result: ffi::gcry_sexp_t = ptr::null_mut();
        return_err!(ffi::gcry_pk_decrypt(
            &mut result,
            data.as_raw(),
            key.as_raw()
        ));
        Ok(SExpression::from_raw(result))
    }
}

#[inline]
pub fn sign(key: &SExpression, data: &SExpression) -> Result<SExpression> {
    unsafe {
        let mut result: ffi::gcry_sexp_t = ptr::null_mut();
        return_err!(ffi::gcry_pk_sign(&mut result, data.as_raw(), key.as_raw()));
        Ok(SExpression::from_raw(result))
    }
}

#[inline]
pub fn verify(key: &SExpression, data: &SExpression, sig: &SExpression) -> Result<()> {
    unsafe {
        return_err!(ffi::gcry_pk_verify(
            sig.as_raw(),
            data.as_raw(),
            key.as_raw()
        ));
        Ok(())
    }
}