rust: link to certificate C-bindings

rust/examples/dhtnode.rs

@@ -20,6 +20,7 @@ extern crate opendht;
 use std::{ thread, time };
 
 use opendht::{ InfoHash, DhtRunner, DhtRunnerConfig, Value };
+use opendht::crypto::*;
 
 fn main() {
     println!("{}", InfoHash::random());
@@ -28,10 +29,18 @@ fn main() {
     println!("{}", InfoHash::get("alice"));
     println!("{}", InfoHash::get("alice").is_zero());
 
+
     let mut dht = DhtRunner::new();
-    let config = DhtRunnerConfig::new();
+    let mut config = DhtRunnerConfig::new();
+    //// If you want to inject a certificate, uncomment the following lines and previous mut.
+    //// Note: you can generate a certificate with
+    //// openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes -keyout example.key -out example.crt -subj /CN=example.com
+    //let cert = DhtCertificate::import("example.crt").ok().expect("Invalid cert file");
+    //let pk = PrivateKey::import("example.key", "");
+    //config.set_identity(cert, pk);
     dht.run_config(1412, config);
     dht.bootstrap("bootstrap.jami.net", 4222);
+    println!("Current node id: {}", dht.node_id());
 
     let /* mut */ data = 42;
     let mut get_cb = |v: Box<Value>| {

rust/src/crypto.rs

@@ -18,8 +18,11 @@
 
 #![allow(dead_code)]
 
-use crate::ffi::*;
+pub use crate::ffi::*;
 use std::ffi::CString;
+use std::io;
+use std::io::prelude::*;
+use std::fs::File;
 
 impl PublicKey {
     pub fn new() -> Box<PublicKey> {
@@ -112,3 +115,57 @@ impl Drop for PrivateKey {
         }
     }
 }
+
+impl DhtCertificate {
+    pub fn import(file: &str) -> io::Result<Box<DhtCertificate>> {
+        let mut f = File::open(file)?;
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer)?;
+        unsafe {
+            Ok(Box::from_raw(dht_certificate_import((&*buffer).as_ptr(), buffer.len())))
+        }
+    }
+
+    pub fn id(&self) -> InfoHash {
+        unsafe {
+            dht_certificate_get_id(&*self)
+        }
+    }
+
+    pub fn long_id(&self) -> PkId {
+        unsafe {
+            dht_certificate_get_long_id(&*self)
+        }
+    }
+
+    pub fn publickey(&self) -> Box<PublicKey> {
+        unsafe {
+            Box::from_raw(dht_certificate_get_publickey(&*self))
+        }
+    }
+}
+
+impl Drop for DhtCertificate {
+    fn drop(&mut self) {
+        unsafe {
+            dht_certificate_delete(&mut *self)
+        }
+    }
+}
+
+impl DhtIdentity {
+    pub fn generate(common_name: &str, ca: Box<DhtIdentity>) -> DhtIdentity {
+        let common_name = CString::new(common_name).unwrap();
+        unsafe {
+            dht_identity_generate(common_name.as_ptr(), &*ca)
+        }
+    }
+}
+
+impl Drop for DhtIdentity {
+    fn drop(&mut self) {
+        unsafe {
+            dht_identity_delete(&mut *self)
+        }
+    }
+}
\ No newline at end of file

rust/src/dhtrunner.rs

@@ -39,7 +39,7 @@ impl DhtRunnerConfig {
                     persist_path: ptr::null(),
                 },
                 id: DhtIdentity {
-                    privkey: ptr::null_mut(),
+                    privatekey: ptr::null_mut(),
                     certificate: ptr::null_mut(),
                 },
             },
@@ -51,7 +51,7 @@ impl DhtRunnerConfig {
             peer_publish: false,
             server_ca: ptr::null_mut(),
             client_identity: DhtIdentity {
-                privkey: ptr::null_mut(),
+                privatekey: ptr::null_mut(),
                 certificate: ptr::null_mut(),
             },
         });
@@ -73,6 +73,11 @@ impl DhtRunnerConfig {
         self.push_token = CString::new(push_token).unwrap().as_ptr();
     }
 
+    pub fn set_identity(&mut self, certificate: Box<DhtCertificate>, privatekey: Box<PrivateKey>) {
+        self.dht_config.id.privatekey = Box::into_raw(privatekey);
+        self.dht_config.id.certificate = Box::into_raw(certificate);
+    }
+
 }
 
 impl DhtNodeConfig

rust/src/ffi.rs

@@ -98,7 +98,7 @@ pub struct DhtCertificate
 #[repr(C)]
 pub struct DhtIdentity
 {
-    pub privkey: *mut PrivateKey,
+    pub privatekey: *mut PrivateKey,
     pub certificate: *mut DhtCertificate,
 }
 
@@ -162,6 +162,16 @@ extern {
     pub fn dht_privatekey_get_publickey(pk: *const PrivateKey) -> *mut PublicKey;
     pub fn dht_privatekey_delete(pk: *mut PrivateKey);
 
+    // dht::crypto::Certificate
+    pub fn dht_certificate_import(dat: *const u8, dat_size: size_t) -> *mut DhtCertificate;
+    pub fn dht_certificate_get_id(cert: *const DhtCertificate) -> InfoHash;
+    pub fn dht_certificate_get_long_id(cert: *const DhtCertificate) -> PkId;
+    pub fn dht_certificate_get_publickey(cert: *const DhtCertificate) -> *mut PublicKey;
+    pub fn dht_certificate_delete(cert: *mut DhtCertificate);
+
+    pub fn dht_identity_generate(common_name: *const c_char, ca: *const DhtIdentity) -> DhtIdentity;
+    pub fn dht_identity_delete(ca: *mut DhtIdentity);
+
     // dht::OpToken
     pub fn dht_op_token_delete(token: *mut OpToken);