diff --git a/src/lib.rs b/src/lib.rs index f91a80d..7e24d0c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -230,18 +230,16 @@ pub struct SecretKey(Box); impl Default for SecretKey { fn default() -> Self { let mut fr = Fr::zero(); - SecretKey::try_from_mut(&mut fr) - .unwrap_or_else(|e| panic!("Failed to create default `SecretKey`: {}", e)) + SecretKey::from_mut(&mut fr) } } /// Creates a random `SecretKey` from a given RNG. If you do not need to specify your own RNG, you -/// should use `SecretKey::random()` or `SecretKey::try_random()` as your constructor instead. +/// should use `SecretKey::random()` as your constructor instead. impl Rand for SecretKey { fn rand(rng: &mut R) -> Self { let mut fr = Fr::rand(rng); - SecretKey::try_from_mut(&mut fr) - .unwrap_or_else(|e| panic!("Failed to create random `SecretKey`: {}", e)) + SecretKey::from_mut(&mut fr) } } @@ -249,16 +247,11 @@ impl Rand for SecretKey { impl Clone for SecretKey { fn clone(&self) -> Self { let mut fr = *self.0; - SecretKey::try_from_mut(&mut fr) - .unwrap_or_else(|e| panic!("Failed to clone `SecretKey`: {}", e)) + SecretKey::from_mut(&mut fr) } } /// Zeroes out and unlocks the memory allocated from the `SecretKey`'s field element. -/// -/// # Panics -/// -/// Panics if we fail to unlock the memory containing the field element. impl Drop for SecretKey { fn drop(&mut self) { self.zero_secret(); @@ -288,54 +281,25 @@ impl SecretKey { /// *WARNING* this constructor will overwrite the referenced `Fr` element with zeros after it /// has been copied onto the heap. pub fn from_mut(fr: &mut Fr) -> Self { - SecretKey::try_from_mut(fr) - .unwrap_or_else(|e| panic!("Falied to create `SecretKey`: {}", e)) - } - - /// Creates a new `SecretKey` from a mutable reference to a field element. This constructor - /// takes a reference to avoid any unnecessary stack copying/moving of secrets (i.e. the field - /// element). The field element is copied bytewise onto the heap, the resulting `Box` is - /// stored in the returned `SecretKey`. - /// - /// This constructor is identical to `SecretKey::from_mut()` in every way except that this - /// constructor will return an `Err` where `SecretKey::from_mut()` would panic. - /// - /// *WARNING* this constructor will overwrite the referenced `Fr` element with zeros after it - /// has been copied onto the heap. - pub fn try_from_mut(fr: &mut Fr) -> Result { let fr_ptr = fr as *mut Fr; let mut boxed_fr = Box::new(Fr::zero()); unsafe { copy_nonoverlapping(fr_ptr, &mut *boxed_fr as *mut Fr, 1); } clear_fr(fr_ptr); - let sk = SecretKey(boxed_fr); - Ok(sk) + SecretKey(boxed_fr) } /// Creates a new random instance of `SecretKey`. If you want to use/define your own random /// number generator, you should use the constructor: `SecretKey::rand()`. If you do not need - /// to specify your own RNG, you should use the `SecretKey::random()` and - /// `SecretKey::try_random()` constructors, which use + /// to specify your own RNG, you should use the `SecretKey::random()` constructor, which uses /// [`rand::thead_rng()`](https://docs.rs/rand/0.4.3/rand/fn.thread_rng.html) internally as - /// their RNG. + /// its RNG. pub fn random() -> Self { let mut rng = rand::thread_rng(); SecretKey::rand(&mut rng) } - /// Creates a new random instance of `SecretKey`. If you want to use/define your own random - /// number generator, you should use the constructor: `SecretKey::rand()`. If you do not need - /// to specify your own RNG, you should use the `SecretKey::random()` and - /// `SecretKey::try_random()` constructors, which use - /// [`rand::thead_rng()`](https://docs.rs/rand/0.4.3/rand/fn.thread_rng.html) internally as - /// their RNG. - pub fn try_random() -> Result { - let mut rng = rand::thread_rng(); - let mut fr = Fr::rand(&mut rng); - SecretKey::try_from_mut(&mut fr) - } - /// Returns the matching public key. pub fn public_key(&self) -> PublicKey { PublicKey(G1Affine::one().mul(*self.0)) @@ -390,21 +354,7 @@ impl SecretKeyShare { /// *WARNING* this constructor will overwrite the pointed to `Fr` element with zeros once it /// has been copied into a new `SecretKeyShare`. pub fn from_mut(fr: &mut Fr) -> Self { - match SecretKey::try_from_mut(fr) { - Ok(sk) => SecretKeyShare(sk), - Err(e) => panic!( - "Failed to create `SecretKeyShare` from field element: {}", - e - ), - } - } - - /// Creates a new `SecretKeyShare` from a mutable reference to a field element. This - /// constructor takes a reference to avoid any unnecessary stack copying/moving of secrets - /// field elements. The field element will be copied bytewise onto the heap, the resulting - /// `Box` is stored in the `SecretKey` which is then wrapped in a `SecretKeyShare`. - pub fn try_from_mut(fr: &mut Fr) -> Result { - SecretKey::try_from_mut(fr).map(SecretKeyShare) + SecretKeyShare(SecretKey::from_mut(fr)) } /// Returns the matching public key share. @@ -559,6 +509,10 @@ impl SecretKeySet { /// Creates a set of secret key shares, where any `threshold + 1` of them can collaboratively /// sign and decrypt. This constuctor is identical to the `SecretKey::try_random()` in every /// way except that this constructor panics if the other returns an error. + /// + /// # Panic + /// + /// Panics if the `threshold` is too large for the coefficients to fit into a `Vec`. pub fn random(threshold: usize, rng: &mut R) -> Self { SecretKeySet::try_random(threshold, rng) .unwrap_or_else(|e| panic!("Failed to create random `SecretKeySet`: {}", e)) @@ -577,20 +531,10 @@ impl SecretKeySet { self.poly.degree() } - /// Returns the `i`-th secret key share. This method is identical to the - /// `.try_secret_key_share()` in every way except that this method panics if - /// where `.try_secret_key_share()` would return an `Err`. + /// Returns the `i`-th secret key share. pub fn secret_key_share(&self, i: T) -> SecretKeyShare { - self.try_secret_key_share(i) - .unwrap_or_else(|e| panic!("Failed to create `SecretKeyShare`: {}", e)) - } - - /// Returns the `i`-th secret key share. This method is identical to the method - /// `.secret_key_share()` in every way except that this method returns an `Err` if - /// where `.secret_key_share()` would panic. - pub fn try_secret_key_share(&self, i: T) -> Result { let mut fr = self.poly.evaluate(into_fr_plus_1(i)); - SecretKeyShare::try_from_mut(&mut fr) + SecretKeyShare::from_mut(&mut fr) } /// Returns the corresponding public key set. That information can be shared publicly. diff --git a/src/poly.rs b/src/poly.rs index 37680ed..84bc77e 100644 --- a/src/poly.rs +++ b/src/poly.rs @@ -41,8 +41,7 @@ pub struct Poly { /// Creates a new `Poly` with the same coefficients as another polynomial. impl Clone for Poly { fn clone(&self) -> Self { - Poly::try_from(self.coeff.clone()) - .unwrap_or_else(|e| panic!("Failed to clone `Poly`: {}", e)) + Poly::from(self.coeff.clone()) } } @@ -177,8 +176,7 @@ impl<'a, B: Borrow> ops::Mul for &'a Poly { coeffs[i + j].add_assign(&*tmp); } } - Poly::try_from(coeffs) - .unwrap_or_else(|e| panic!("Failed to create a new `Poly` during muliplication: {}", e)) + Poly::from(coeffs) } } @@ -265,8 +263,8 @@ impl Drop for Poly { /// Creates a new `Poly` instance from a vector of prime field elements representing the /// coefficients of the polynomial. impl From> for Poly { - fn from(coeffs: Vec) -> Self { - Poly::try_from(coeffs).unwrap_or_else(|e| panic!("Failed to create `Poly`: {}", e)) + fn from(coeff: Vec) -> Self { + Poly { coeff } } } @@ -279,16 +277,11 @@ impl ContainsSecret for Poly { } impl Poly { - /// Creates a new `Poly` instance from a vector of prime field elements representing the - /// coefficients of the polynomial. - pub fn try_from(coeff: Vec) -> Result { - let poly = Poly { coeff }; - Ok(poly) - } - - /// Creates a random polynomial. This constructor is identical to the `Poly::try_random()` - /// constructor in every way except that this constructor will panic where `random` would - /// return an error. + /// Creates a random polynomial. + /// + /// # Panics + /// + /// Panics if the `degree` is too large for the coefficients to fit into a `Vec`. pub fn random(degree: usize, rng: &mut R) -> Self { Poly::try_random(degree, rng) .unwrap_or_else(|e| panic!("Failed to create random `Poly`: {}", e)) @@ -302,7 +295,7 @@ impl Poly { return Err(Error::DegreeTooHigh); } let coeff: Vec = (0..=degree).map(|_| rng.gen()).collect(); - Poly::try_from(coeff) + Ok(Poly::from(coeff)) } /// Returns the polynomial with constant value `0`. @@ -315,19 +308,9 @@ impl Poly { self.coeff.iter().all(|coeff| coeff.is_zero()) } - /// Returns the polynomial with constant value `1`. This constructor is identical to - /// `Poly::try_one()` in every way except that this constructor panics where `Poly::try_one()` - /// would return an `Err`. + /// Returns the polynomial with constant value `1`. pub fn one() -> Self { - Poly::try_one() - .unwrap_or_else(|e| panic!("Failed to create constant `Poly` of value 1: {}", e)) - } - - /// Returns the polynomial with constant value `1`. This constructor is identical to - /// `Poly::one()` in every way except that this constructor returns `Err` if where `Poly::one()` - /// would panic. - pub fn try_one() -> Result { - Poly::try_constant(Fr::one()) + Poly::constant(Fr::one()) } /// Returns the polynomial with constant value `c`. @@ -336,69 +319,28 @@ impl Poly { // overwrite that portion of memory with zeros once we have copied the element onto the // heap as part of the vector of polynomial coefficients. let fr_ptr = &c as *const Fr; - let poly = Poly::try_from(vec![c]) - .unwrap_or_else(|e| panic!("Failed to create constant `Poly`: {}", e)); + let poly = Poly::from(vec![c]); clear_fr(fr_ptr); poly } - /// Returns the polynomial with constant value `c`. This constructor is identical to - /// `Poly::constant()` in every way except that this constructor returns an `Err` where - /// `constant` would panic. - pub fn try_constant(c: Fr) -> Result { - // We create a raw pointer to the field element within this method's stack frame so we can - // overwrite that portion of memory with zeros once we have copied the element onto the - // heap as part of polynomials `coeff` vector. - let fr_ptr = &c as *const Fr; - let res = Poly::try_from(vec![c]); - clear_fr(fr_ptr); - res - } - /// Returns the identity function, i.e. the polynomial "`x`". pub fn identity() -> Self { Poly::monomial(1) } - /// Returns the identity function, i.e. the polynomial `x`. - pub fn try_identity() -> Result { - Poly::try_monomial(1) - } - /// Returns the (monic) monomial: `x.pow(degree)`. pub fn monomial(degree: usize) -> Self { - Poly::try_monomial(degree).unwrap_or_else(|e| { - panic!( - "Failed to create monomial `Poly` of degree {}: {}", - degree, e - ) - }) - } - - /// Returns the (monic) monomial: `x.pow(degree)`. - pub fn try_monomial(degree: usize) -> Result { let coeff: Vec = iter::repeat(Fr::zero()) .take(degree) .chain(iter::once(Fr::one())) .collect(); - Poly::try_from(coeff) + Poly::from(coeff) } /// Returns the unique polynomial `f` of degree `samples.len() - 1` with the given values /// `(x, f(x))`. pub fn interpolate(samples_repr: I) -> Self - where - I: IntoIterator, - T: IntoFr, - U: IntoFr, - { - Poly::try_interpolate(samples_repr) - .unwrap_or_else(|e| panic!("Failed to interpolate `Poly`: {}", e)) - } - - /// Returns the unique polynomial `f` of degree `samples.len() - 1` with the given values - /// `(x, f(x))`. - pub fn try_interpolate(samples_repr: I) -> Result where I: IntoIterator, T: IntoFr, @@ -445,16 +387,16 @@ impl Poly { /// Returns the unique polynomial `f` of degree `samples.len() - 1` with the given values /// `(x, f(x))`. - fn compute_interpolation(samples: &[(Fr, Fr)]) -> Result { + fn compute_interpolation(samples: &[(Fr, Fr)]) -> Self { if samples.is_empty() { - return Ok(Poly::zero()); + return Poly::zero(); } // Interpolates on the first `i` samples. - let mut poly = Poly::try_constant(samples[0].1)?; + let mut poly = Poly::constant(samples[0].1); let mut minus_s0 = samples[0].0; minus_s0.negate(); // Is zero on the first `i` samples. - let mut base = Poly::try_from(vec![minus_s0, Fr::one()])?; + let mut base = Poly::from(vec![minus_s0, Fr::one()]); // We update `base` so that it is always zero on all previous samples, and `poly` so that // it has the correct values on the previous samples. @@ -471,9 +413,9 @@ impl Poly { // Finally, multiply `base` by X - x, so that it is zero at `x`, too, now. let mut minus_x = *x; minus_x.negate(); - base *= Poly::try_from(vec![minus_x, Fr::one()])?; + base *= Poly::from(vec![minus_x, Fr::one()]); } - Ok(poly) + poly } /// Generates a non-redacted debug string. This method differs from @@ -603,6 +545,10 @@ impl ContainsSecret for BivarPoly { } impl BivarPoly { /// Creates a random polynomial. + /// + /// # Panics + /// + /// Panics if the degree is too high for the coefficients to fit into a `Vec`. pub fn random(degree: usize, rng: &mut R) -> Self { BivarPoly::try_random(degree, rng).unwrap_or_else(|e| { panic!( @@ -649,12 +595,6 @@ impl BivarPoly { /// Returns the `x`-th row, as a univariate polynomial. pub fn row(&self, x: T) -> Poly { - self.try_row(x) - .unwrap_or_else(|e| panic!("Failed to create `Poly` from row of `BivarPoly: {}`", e)) - } - - /// Returns the `x`-th row, as a univariate polynomial. - pub fn try_row(&self, x: T) -> Result { let x_pow = self.powers(x); let coeff: Vec = (0..=self.degree) .map(|i| { @@ -668,7 +608,7 @@ impl BivarPoly { } result }).collect(); - Poly::try_from(coeff) + Poly::from(coeff) } /// Returns the corresponding commitment. That information can be shared publicly. diff --git a/src/secret.rs b/src/secret.rs index 6c4f2fe..02ccafa 100644 --- a/src/secret.rs +++ b/src/secret.rs @@ -7,8 +7,6 @@ use std::ops::{Deref, DerefMut}; use memsec::memzero; use Fr; -use error::Result; - lazy_static! { /// The size in bytes of a single field element. pub(crate) static ref FR_SIZE: usize = size_of::(); @@ -89,10 +87,6 @@ where T: DerefMut, { pub(crate) fn new(x: T) -> Self { - Safe::try_new(x).unwrap_or_else(|e| panic!("Failed to create `Safe`: {}", e)) - } - - pub(crate) fn try_new(x: T) -> Result { - Ok(Safe(x)) + Safe(x) } }