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
|
//! For accessing keys over the network.
//!
//! Currently, this module provides access to keyservers providing the [HKP] protocol.
//!
//! [HKP]: https://tools.ietf.org/html/draft-shaw-openpgp-hkp-00
//!
//! # Example
//!
//! We provide a very reasonable default key server backed by
//! `hkps.pool.sks-keyservers.net`, the subset of the [SKS keyserver]
//! network that uses https to protect integrity and confidentiality
//! of the communication with the client:
//!
//! [SKS keyserver]: https://www.sks-keyservers.net/overview-of-pools.php#pool_hkps
//!
//! ```c, no-run
//! #include <sequoia.h>
//!
//! sq_context_t ctx;
//! pgp_keyid_t id;
//! sq_keyserver_t ks;
//! pgp_tpk_t tpk;
//!
//! ctx = sq_context_new ("org.sequoia-pgp.example", NULL);
//! ks = sq_keyserver_sks_pool (ctx);
//! id = pgp_keyid_from_bytes ((uint8_t *) "\x24\x7F\x6D\xAB\xC8\x49\x14\xFE");
//! tpk = sq_keyserver_get (ctx, ks, id);
//! ```
use libc::{uint8_t, c_char, size_t};
use native_tls::Certificate;
use std::ptr;
use std::slice;
extern crate sequoia_openpgp as openpgp;
use sequoia_net::KeyServer;
use super::error::Status;
use super::core::Context;
use ::openpgp::keyid::KeyID;
use ::openpgp::tpk::TPK;
use ::RefRaw;
use MoveResultIntoRaw;
use Maybe;
/// Returns a handle for the given URI.
///
/// `uri` is a UTF-8 encoded value of a keyserver URI,
/// e.g. `hkps://examle.org`.
///
/// Returns `NULL` on errors.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_new(ctx: *mut Context,
uri: *const c_char) -> *mut KeyServer {
let ctx = ffi_param_ref_mut!(ctx);
ffi_make_fry_from_ctx!(ctx);
let uri = ffi_param_cstr!(uri).to_string_lossy();
ffi_try_box!(KeyServer::new(&ctx.c, &uri))
}
/// Returns a handle for the given URI.
///
/// `uri` is a UTF-8 encoded value of a keyserver URI,
/// e.g. `hkps://examle.org`. `cert` is a DER encoded certificate of
/// size `len` used to authenticate the server.
///
/// Returns `NULL` on errors.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_with_cert(ctx: *mut Context,
uri: *const c_char,
cert: *const uint8_t,
len: size_t) -> *mut KeyServer {
let ctx = ffi_param_ref_mut!(ctx);
ffi_make_fry_from_ctx!(ctx);
let uri = ffi_param_cstr!(uri).to_string_lossy();
if cert.is_null() {
return ptr::null_mut();
}
let cert = unsafe {
slice::from_raw_parts(cert, len as usize)
};
let cert = ffi_try!(Certificate::from_der(cert)
.map_err(|e| ::failure::Error::from(e)));
ffi_try_box!(KeyServer::with_cert(&ctx.c, &uri, cert))
}
/// Returns a handle for the SKS keyserver pool.
///
/// The pool `hkps://hkps.pool.sks-keyservers.net` provides HKP
/// services over https. It is authenticated using a certificate
/// included in this library. It is a good default choice.
///
/// Returns `NULL` on errors.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_sks_pool(ctx: *mut Context)
-> *mut KeyServer {
let ctx = ffi_param_ref_mut!(ctx);
ffi_make_fry_from_ctx!(ctx);
ffi_try_box!(KeyServer::sks_pool(&ctx.c))
}
/// Frees a keyserver object.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_free(ks: Option<&mut KeyServer>) {
ffi_free!(ks)
}
/// Retrieves the key with the given `keyid`.
///
/// Returns `NULL` on errors.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_get(ctx: *mut Context,
ks: *mut KeyServer,
id: *const KeyID)
-> Maybe<TPK> {
let ctx = ffi_param_ref_mut!(ctx);
ffi_make_fry_from_ctx!(ctx);
let ks = ffi_param_ref_mut!(ks);
let id = id.ref_raw();
ks.get(&id).move_into_raw(Some(ctx.errp()))
}
/// Sends the given key to the server.
///
/// Returns != 0 on errors.
#[::ffi_catch_abort] #[no_mangle]
pub extern "system" fn sq_keyserver_send(ctx: *mut Context,
ks: *mut KeyServer,
tpk: *const TPK)
-> Status {
let ctx = ffi_param_ref_mut!(ctx);
ffi_make_fry_from_ctx!(ctx);
let ks = ffi_param_ref_mut!(ks);
let tpk = tpk.ref_raw();
ffi_try_status!(ks.send(tpk))
}
|
