Add Some more elliptic curve functionality

openssl-sys/src/lib.rs

@@ -26,6 +26,9 @@ pub enum BN_GENCB {}
 pub enum CONF {}
 pub enum COMP_METHOD {}
 pub enum EC_KEY {}
+pub enum EC_GROUP {}
+pub enum EC_METHOD {}
+pub enum EC_POINT {}
 pub enum ENGINE {}
 pub enum EVP_CIPHER_CTX {}
 pub enum EVP_MD {}
@@ -1372,8 +1375,30 @@ extern {
     pub fn DH_get_2048_256() -> *mut DH;
 
     pub fn EC_KEY_new_by_curve_name(nid: c_int) -> *mut EC_KEY;
+    pub fn EC_KEY_get0_group(key: *const EC_KEY) -> *const EC_GROUP;
+    pub fn EC_KEY_get0_public_key(key: *const EC_KEY) -> *const EC_POINT;
+    pub fn EC_KEY_get0_private_key(key: *const EC_KEY) -> *const BIGNUM;
     pub fn EC_KEY_free(key: *mut EC_KEY);
 
+    pub fn EC_GFp_simple_method() -> *const EC_METHOD;
+    pub fn EC_GFp_mont_method() -> *const EC_METHOD;
+    pub fn EC_GFp_nist_method() -> *const EC_METHOD;
+    pub fn EC_GFp_nistp224_method() -> *const EC_METHOD;
+    pub fn EC_GFp_nistp256_method() -> *const EC_METHOD;
+    pub fn EC_GFp_nistp521_method() -> *const EC_METHOD;
+
+    pub fn EC_GF2m_simple_method() -> *const EC_METHOD;
+
+    pub fn EC_GROUP_new(meth: *const EC_METHOD) -> *mut EC_GROUP;
+    pub fn EC_GROUP_new_curve_GFp(p: *const BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> *mut EC_GROUP;
+    pub fn EC_GROUP_new_curve_GF2m(p: *const BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> *mut EC_GROUP;
+    pub fn EC_GROUP_new_by_curve_name(nid: c_int) -> *mut EC_GROUP;
+    pub fn EC_GROUP_get_curve_GFp(group: *const EC_GROUP, p: *mut BIGNUM, a: *mut BIGNUM, b: *mut BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_GROUP_get_curve_GF2m(group: *const EC_GROUP, p: *mut BIGNUM, a: *mut BIGNUM, b: *mut BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_GROUP_free(group: *mut EC_GROUP);
+
+    pub fn EC_POINT_free(point: *mut EC_POINT);
+
     pub fn ERR_get_error() -> c_ulong;
     pub fn ERR_lib_error_string(err: c_ulong) -> *const c_char;
     pub fn ERR_func_error_string(err: c_ulong) -> *const c_char;

openssl/src/ec_key.rs

@@ -2,15 +2,115 @@ use ffi;
 use std::ptr;
 
 use {cvt, cvt_p, init};
+use bn::{BigNumRef, BigNumContextRef};
 use error::ErrorStack;
 use nid::Nid;
 use types::OpenSslTypeRef;
 
+type_!(EcGroup, EcGroupRef, ffi::EC_GROUP, ffi::EC_GROUP_free);
+
+impl EcGroup {
+    /// Returns the group of a standard named curve.
+    pub fn from_curve_name(nid: Nid) -> Result<EcGroup, ErrorStack> {
+        unsafe {
+            init();
+            cvt_p(ffi::EC_GROUP_new_by_curve_name(nid.as_raw())).map(EcGroup)
+        }
+    }
+
+    /// Constructs a curve over a prime field from its components.
+    pub fn from_components_gfp(p: &BigNumRef,
+                               a: &BigNumRef,
+                               b: &BigNumRef,
+                               ctx: &mut BigNumContextRef)
+                               -> Result<EcGroup, ErrorStack> {
+        unsafe {
+            cvt_p(ffi::EC_GROUP_new_curve_GFp(p.as_ptr(), a.as_ptr(), b.as_ptr(), ctx.as_ptr()))
+                .map(EcGroup)
+        }
+    }
+
+    /// Constructs a curve over a binary field from its components.
+    pub fn from_components_gf2m(p: &BigNumRef,
+                                a: &BigNumRef,
+                                b: &BigNumRef,
+                                ctx: &mut BigNumContextRef)
+                                -> Result<EcGroup, ErrorStack> {
+        unsafe {
+            cvt_p(ffi::EC_GROUP_new_curve_GF2m(p.as_ptr(), a.as_ptr(), b.as_ptr(), ctx.as_ptr()))
+                .map(EcGroup)
+        }
+    }
+
+    /// Places the components of a curve over a prime field in the provided `BigNum`s.
+    pub fn components_gfp(&self,
+                          p: &mut BigNumRef,
+                          a: &mut BigNumRef,
+                          b: &mut BigNumRef,
+                          ctx: &mut BigNumContextRef)
+                          -> Result<(), ErrorStack> {
+        unsafe {
+            cvt(ffi::EC_GROUP_get_curve_GFp(self.as_ptr(),
+                                            p.as_ptr(),
+                                            a.as_ptr(),
+                                            b.as_ptr(),
+                                            ctx.as_ptr()))
+                .map(|_| ())
+        }
+    }
+
+    /// Places the components of a curve over a binary field in the provided `BigNum`s.
+    pub fn components_gf2m(&self,
+                           p: &mut BigNumRef,
+                           a: &mut BigNumRef,
+                           b: &mut BigNumRef,
+                           ctx: &mut BigNumContextRef)
+                           -> Result<(), ErrorStack> {
+        unsafe {
+            cvt(ffi::EC_GROUP_get_curve_GF2m(self.as_ptr(),
+                                             p.as_ptr(),
+                                             a.as_ptr(),
+                                             b.as_ptr(),
+                                             ctx.as_ptr()))
+                .map(|_| ())
+        }
+    }
+}
+
+type_!(EcPoint, EcPointRef, ffi::EC_POINT, ffi::EC_POINT_free);
+
 type_!(EcKey, EcKeyRef, ffi::EC_KEY, ffi::EC_KEY_free);
 
 impl EcKeyRef {
     private_key_to_pem!(ffi::PEM_write_bio_ECPrivateKey);
     private_key_to_der!(ffi::i2d_ECPrivateKey);
+
+    pub fn group(&self) -> &EcGroupRef {
+        unsafe {
+            let ptr = ffi::EC_KEY_get0_group(self.as_ptr());
+            assert!(!ptr.is_null());
+            EcGroupRef::from_ptr(ptr as *mut _)
+        }
+    }
+
+    pub fn public_key(&self) -> &EcPointRef {
+        unsafe {
+            let ptr = ffi::EC_KEY_get0_public_key(self.as_ptr());
+            assert!(!ptr.is_null());
+            EcPointRef::from_ptr(ptr as *mut _)
+        }
+    }
+
+    pub fn private_key(&self) -> Option<&BigNumRef> {
+        unsafe {
+            let ptr = ffi::EC_KEY_get0_private_key(self.as_ptr());
+            if ptr.is_null() {
+                None
+            } else {
+                Some(BigNumRef::from_ptr(ptr as *mut _))
+            }
+        }
+    }
 }
 
 impl EcKey {
@@ -27,11 +127,23 @@ impl EcKey {
 
 #[cfg(test)]
 mod test {
+    use bn::{BigNum, BigNumContext};
     use nid;
     use super::*;
 
     #[test]
-    fn new_by_curve_name() {
+    fn key_new_by_curve_name() {
         EcKey::new_by_curve_name(nid::X9_62_PRIME256V1).unwrap();
     }
+
+    #[test]
+    fn round_trip_prime256v1() {
+        let group = EcGroup::from_curve_name(nid::X9_62_PRIME256V1).unwrap();
+        let mut p = BigNum::new().unwrap();
+        let mut a = BigNum::new().unwrap();
+        let mut b = BigNum::new().unwrap();
+        let mut ctx = BigNumContext::new().unwrap();
+        group.components_gfp(&mut p, &mut a, &mut b, &mut ctx).unwrap();
+        EcGroup::from_components_gfp(&p, &a, &b, &mut ctx).unwrap();
+    }
 }