Add Some more elliptic curve functionality (b2de3604) · Commits · Public Repositories / Rust Openssl

openssl-sys/src/lib.rs

+25 −0

Original line number	Diff line number	Diff line
		@@ -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

+113 −1

Original line number	Diff line number	Diff line
		@@ -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();
		}
		}