Merge pull request #130 from elichai/symbols

Implemented context create/destroy in rust

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.14.1 - 2019-07-14
+
+* Implemented FFI functions: `secp256k1_context_create` and `secp256k1_context_destroy` in rust.
+
 # 0.14.0 - 2019-07-08
 
 * [Feature-gate endormorphism optimization](https://github.com/rust-bitcoin/rust-secp256k1/pull/120)

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "secp256k1"
-version = "0.14.0"
+version = "0.14.1"
 authors = [ "Dawid Ciężarkiewicz <dpc@ucore.info>",
             "Andrew Poelstra <apoelstra@wpsoftware.net>" ]
 license = "CC0-1.0"

src/ffi.rs

@@ -16,7 +16,7 @@
 //! # FFI bindings
 //! Direct bindings to the underlying C library functions. These should
 //! not be needed for most users.
-use core::{mem, hash};
+use core::{mem, hash, slice};
 use types::*;
 
 /// Flag for context to enable no precomputation
@@ -260,6 +260,50 @@ extern "C" {
 }
 
 
+#[cfg(feature = "std")]
+#[no_mangle]
+/// A reimplementation of the C function `secp256k1_context_create` in rust.
+///
+/// This function allocates memory, the pointer should be deallocated using `secp256k1_context_destroy`
+/// A failure to do so will result in a memory leak.
+///
+/// This will create a secp256k1 raw context.
+// Returns: a newly created context object.
+//  In:      flags: which parts of the context to initialize.
+pub unsafe extern "C" fn secp256k1_context_create(flags: c_uint) -> *mut Context {
+    assert!(mem::align_of::<usize>() >= mem::align_of::<u8>());
+    assert_eq!(mem::size_of::<usize>(), mem::size_of::<&usize>());
+
+    let word_size = mem::size_of::<usize>();
+    let n_words = (secp256k1_context_preallocated_size(flags) + word_size - 1) / word_size;
+
+    let buf = vec![0usize; n_words + 1].into_boxed_slice();
+    let ptr = Box::into_raw(buf) as *mut usize;
+    ::core::ptr::write(ptr, n_words);
+    let ptr: *mut usize = ptr.offset(1);
+
+    secp256k1_context_preallocated_create(ptr as *mut c_void, flags)
+}
+
+#[cfg(feature = "std")]
+#[no_mangle]
+/// A reimplementation of the C function `secp256k1_context_destroy` in rust.
+///
+/// This function destroys and deallcates the context created by `secp256k1_context_create`.
+///
+/// The pointer shouldn't be used after passing to this function, consider it as passing it to `free()`.
+///
+pub unsafe extern "C" fn secp256k1_context_destroy(ctx: *mut Context) {
+    secp256k1_context_preallocated_destroy(ctx);
+    let ctx: *mut usize = ctx as *mut usize;
+
+    let n_words_ptr: *mut usize = ctx.offset(-1);
+    let n_words: usize = ::core::ptr::read(n_words_ptr);
+    let slice: &mut [usize] = slice::from_raw_parts_mut(n_words_ptr , n_words+1);
+    let _ = Box::from_raw(slice as *mut [usize]);
+}
+
+
 #[no_mangle]
 /// **This function is an override for the C function, this is the an edited version of the original description:**
 ///
@@ -280,7 +324,7 @@ extern "C" {
 /// See also secp256k1_default_error_callback_fn.
 ///
 pub unsafe extern "C" fn secp256k1_default_illegal_callback_fn(message: *const c_char, _data: *mut c_void) {
-    use core::{str, slice};
+    use core::str;
     let msg_slice = slice::from_raw_parts(message as *const u8, strlen(message));
     let msg = str::from_utf8_unchecked(msg_slice);
     panic!("[libsecp256k1] illegal argument. {}", msg);
@@ -302,7 +346,7 @@ pub unsafe extern "C" fn secp256k1_default_illegal_callback_fn(message: *const c
 /// See also secp256k1_default_illegal_callback_fn.
 ///
 pub unsafe extern "C" fn secp256k1_default_error_callback_fn(message: *const c_char, _data: *mut c_void) {
-    use core::{str, slice};
+    use core::str;
     let msg_slice = slice::from_raw_parts(message as *const u8, strlen(message));
     let msg = str::from_utf8_unchecked(msg_slice);
     panic!("[libsecp256k1] internal consistency check failed {}", msg);

src/lib.rs

@@ -681,12 +681,15 @@ fn from_hex(hex: &str, target: &mut [u8]) -> Result<usize, ()> {
 mod tests {
     use rand::{RngCore, thread_rng};
     use std::str::FromStr;
+    use std::marker::PhantomData;
 
     use key::{SecretKey, PublicKey};
     use super::from_hex;
     use super::constants;
     use super::{Secp256k1, Signature, Message};
     use super::Error::{InvalidMessage, IncorrectSignature, InvalidSignature};
+    use ffi;
+    use context::*;
 
     macro_rules! hex {
         ($hex:expr) => ({
@@ -696,6 +699,35 @@ mod tests {
         });
     }
 
+
+    #[test]
+    fn test_manual_create_destroy() {
+        let ctx_full = unsafe { ffi::secp256k1_context_create(AllPreallocated::FLAGS) };
+        let ctx_sign = unsafe { ffi::secp256k1_context_create(SignOnlyPreallocated::FLAGS) };
+        let ctx_vrfy = unsafe { ffi::secp256k1_context_create(VerifyOnlyPreallocated::FLAGS) };
+
+        let buf: *mut [u8] = &mut [0u8;0] as _;
+        let full: Secp256k1<AllPreallocated> = Secp256k1{ctx: ctx_full, phantom: PhantomData, buf};
+        let sign: Secp256k1<SignOnlyPreallocated> = Secp256k1{ctx: ctx_sign, phantom: PhantomData, buf};
+        let vrfy: Secp256k1<VerifyOnlyPreallocated> = Secp256k1{ctx: ctx_vrfy, phantom: PhantomData, buf};
+
+        let (sk, pk) = full.generate_keypair(&mut thread_rng());
+        let msg = Message::from_slice(&[2u8; 32]).unwrap();
+        // Try signing
+        assert_eq!(sign.sign(&msg, &sk), full.sign(&msg, &sk));
+        let sig = full.sign(&msg, &sk);
+
+        // Try verifying
+        assert!(vrfy.verify(&msg, &sig, &pk).is_ok());
+        assert!(full.verify(&msg, &sig, &pk).is_ok());
+
+        drop(full);drop(sign);drop(vrfy);
+
+        unsafe { ffi::secp256k1_context_destroy(ctx_vrfy) };
+        unsafe { ffi::secp256k1_context_destroy(ctx_sign) };
+        unsafe { ffi::secp256k1_context_destroy(ctx_full) };
+    }
+
     #[test]
     fn test_preallocation() {
         let mut buf_ful = vec![0u8; Secp256k1::preallocate_size()];