openssl/
ecdsa.rs

Help
1//! Low level Elliptic Curve Digital Signature Algorithm (ECDSA) functions.
2
3use cfg_if::cfg_if;
4use foreign_types::{ForeignType, ForeignTypeRef};
5use libc::c_int;
6use std::mem;
7use std::ptr;
8
9use crate::bn::{BigNum, BigNumRef};
10use crate::ec::EcKeyRef;
11use crate::error::ErrorStack;
12use crate::pkey::{HasPrivate, HasPublic};
13use crate::util::ForeignTypeRefExt;
14use crate::{cvt_n, cvt_p, LenType};
15use openssl_macros::corresponds;
16
17foreign_type_and_impl_send_sync! {
18    type CType = ffi::ECDSA_SIG;
19    fn drop = ffi::ECDSA_SIG_free;
20
21    /// A low level interface to ECDSA.
22    pub struct EcdsaSig;
23    /// A reference to an [`EcdsaSig`].
24    pub struct EcdsaSigRef;
25}
26
27impl EcdsaSig {
28    /// Computes a digital signature of the hash value `data` using the private EC key eckey.
29    #[corresponds(ECDSA_do_sign)]
30    pub fn sign<T>(data: &[u8], eckey: &EcKeyRef<T>) -> Result<EcdsaSig, ErrorStack>
31    where
32        T: HasPrivate,
33    {
34        unsafe {
35            assert!(data.len() <= c_int::MAX as usize);
36            let sig = cvt_p(ffi::ECDSA_do_sign(
37                data.as_ptr(),
38                data.len() as LenType,
39                eckey.as_ptr(),
40            ))?;
41            Ok(EcdsaSig::from_ptr(sig))
42        }
43    }
44
45    /// Returns a new `EcdsaSig` by setting the `r` and `s` values associated with an ECDSA signature.
46    #[corresponds(ECDSA_SIG_set0)]
47    pub fn from_private_components(r: BigNum, s: BigNum) -> Result<EcdsaSig, ErrorStack> {
48        unsafe {
49            let sig = cvt_p(ffi::ECDSA_SIG_new())?;
50            ECDSA_SIG_set0(sig, r.as_ptr(), s.as_ptr());
51            mem::forget((r, s));
52            Ok(EcdsaSig::from_ptr(sig))
53        }
54    }
55
56    from_der! {
57        /// Decodes a DER-encoded ECDSA signature.
58        #[corresponds(d2i_ECDSA_SIG)]
59        from_der,
60        EcdsaSig,
61        ffi::d2i_ECDSA_SIG
62    }
63}
64
65impl EcdsaSigRef {
66    to_der! {
67        /// Serializes the ECDSA signature into a DER-encoded ECDSASignature structure.
68        #[corresponds(i2d_ECDSA_SIG)]
69        to_der,
70        ffi::i2d_ECDSA_SIG
71    }
72
73    /// Verifies if the signature is a valid ECDSA signature using the given public key.
74    #[corresponds(ECDSA_do_verify)]
75    pub fn verify<T>(&self, data: &[u8], eckey: &EcKeyRef<T>) -> Result<bool, ErrorStack>
76    where
77        T: HasPublic,
78    {
79        unsafe {
80            assert!(data.len() <= c_int::MAX as usize);
81            cvt_n(ffi::ECDSA_do_verify(
82                data.as_ptr(),
83                data.len() as LenType,
84                self.as_ptr(),
85                eckey.as_ptr(),
86            ))
87            .map(|x| x == 1)
88        }
89    }
90
91    /// Returns internal component: `r` of an `EcdsaSig`. (See X9.62 or FIPS 186-2)
92    #[corresponds(ECDSA_SIG_get0)]
93    pub fn r(&self) -> &BigNumRef {
94        unsafe {
95            let mut r = ptr::null();
96            ECDSA_SIG_get0(self.as_ptr(), &mut r, ptr::null_mut());
97            BigNumRef::from_const_ptr(r)
98        }
99    }
100
101    /// Returns internal components: `s` of an `EcdsaSig`. (See X9.62 or FIPS 186-2)
102    #[corresponds(ECDSA_SIG_get0)]
103    pub fn s(&self) -> &BigNumRef {
104        unsafe {
105            let mut s = ptr::null();
106            ECDSA_SIG_get0(self.as_ptr(), ptr::null_mut(), &mut s);
107            BigNumRef::from_const_ptr(s)
108        }
109    }
110}
111
112cfg_if! {
113    if #[cfg(any(ossl110, libressl273, boringssl, awslc))] {
114        use ffi::{ECDSA_SIG_set0, ECDSA_SIG_get0};
115    } else {
116        #[allow(bad_style)]
117        unsafe fn ECDSA_SIG_set0(
118            sig: *mut ffi::ECDSA_SIG,
119            r: *mut ffi::BIGNUM,
120            s: *mut ffi::BIGNUM,
121        ) -> c_int {
122            if r.is_null() || s.is_null() {
123                return 0;
124            }
125            ffi::BN_clear_free((*sig).r);
126            ffi::BN_clear_free((*sig).s);
127            (*sig).r = r;
128            (*sig).s = s;
129            1
130        }
131
132        #[allow(bad_style)]
133        unsafe fn ECDSA_SIG_get0(
134            sig: *const ffi::ECDSA_SIG,
135            pr: *mut *const ffi::BIGNUM,
136            ps: *mut *const ffi::BIGNUM)
137        {
138            if !pr.is_null() {
139                (*pr) = (*sig).r;
140            }
141            if !ps.is_null() {
142                (*ps) = (*sig).s;
143            }
144        }
145    }
146}
147
148#[cfg(test)]
149mod test {
150    use super::*;
151    use crate::ec::EcGroup;
152    use crate::ec::EcKey;
153    use crate::nid::Nid;
154    use crate::pkey::{Private, Public};
155
156    fn get_public_key(group: &EcGroup, x: &EcKey<Private>) -> Result<EcKey<Public>, ErrorStack> {
157        EcKey::from_public_key(group, x.public_key())
158    }
159
160    #[test]
161    #[cfg_attr(osslconf = "OPENSSL_NO_EC", ignore)]
162    fn sign_and_verify() {
163        let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
164        let private_key = EcKey::generate(&group).unwrap();
165        let public_key = get_public_key(&group, &private_key).unwrap();
166
167        let private_key2 = EcKey::generate(&group).unwrap();
168        let public_key2 = get_public_key(&group, &private_key2).unwrap();
169
170        let data = String::from("hello");
171        let res = EcdsaSig::sign(data.as_bytes(), &private_key).unwrap();
172
173        // Signature can be verified using the correct data & correct public key
174        let verification = res.verify(data.as_bytes(), &public_key).unwrap();
175        assert!(verification);
176
177        // Signature will not be verified using the incorrect data but the correct public key
178        let verification2 = res
179            .verify(String::from("hello2").as_bytes(), &public_key)
180            .unwrap();
181        assert!(!verification2);
182
183        // Signature will not be verified using the correct data but the incorrect public key
184        let verification3 = res.verify(data.as_bytes(), &public_key2).unwrap();
185        assert!(!verification3);
186    }
187
188    #[test]
189    #[cfg_attr(osslconf = "OPENSSL_NO_EC", ignore)]
190    fn check_private_components() {
191        let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
192        let private_key = EcKey::generate(&group).unwrap();
193        let public_key = get_public_key(&group, &private_key).unwrap();
194        let data = String::from("hello");
195        let res = EcdsaSig::sign(data.as_bytes(), &private_key).unwrap();
196
197        let verification = res.verify(data.as_bytes(), &public_key).unwrap();
198        assert!(verification);
199
200        let r = res.r().to_owned().unwrap();
201        let s = res.s().to_owned().unwrap();
202
203        let res2 = EcdsaSig::from_private_components(r, s).unwrap();
204        let verification2 = res2.verify(data.as_bytes(), &public_key).unwrap();
205        assert!(verification2);
206    }
207
208    #[test]
209    #[cfg_attr(osslconf = "OPENSSL_NO_EC", ignore)]
210    fn serialize_deserialize() {
211        let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
212        let private_key = EcKey::generate(&group).unwrap();
213        let public_key = get_public_key(&group, &private_key).unwrap();
214
215        let data = String::from("hello");
216        let res = EcdsaSig::sign(data.as_bytes(), &private_key).unwrap();
217
218        let der = res.to_der().unwrap();
219        let sig = EcdsaSig::from_der(&der).unwrap();
220
221        let verification = sig.verify(data.as_bytes(), &public_key).unwrap();
222        assert!(verification);
223    }
224}
openssl/ecdsa.rs

openssl/
ecdsa.rs
