impl TryFrom and From[u8; 32] for CompressedRistretto, MontgomeryPoin…

…t, CompressedEdwardsY and Scalar

src/edwards.rs

@@ -330,6 +330,12 @@ impl Default for CompressedEdwardsY {
     }
 }
 
+impl From<[u8; 32]> for CompressedEdwardsY {
+    fn from(bytes: [u8; 32]) -> Self {
+        CompressedEdwardsY(bytes)
+    }
+}
+
 impl TryFrom<&[u8]> for CompressedEdwardsY {
     type Error = CurveError;
 

src/montgomery.rs

@@ -111,6 +111,12 @@ impl ValidityCheck for MontgomeryPoint {
     }
 }
 
+impl From<[u8; 32]> for MontgomeryPoint {
+    fn from(bytes: [u8; 32]) -> Self {
+        MontgomeryPoint(bytes)
+    }
+}
+
 impl TryFrom<&[u8]> for MontgomeryPoint {
     type Error = CurveError;
 

src/ristretto.rs

@@ -233,6 +233,12 @@ impl TryFrom<&[u8]> for CompressedRistretto {
     }
 }
 
+impl From<[u8; 32]> for CompressedRistretto {
+    fn from(bytes: [u8; 32]) -> Self {
+        CompressedRistretto(bytes)
+    }
+}
+
 impl CompressedRistretto {
     /// Copy the bytes of this `CompressedRistretto`.
     pub fn to_bytes(&self) -> [u8; 32] {

src/scalar.rs

@@ -140,6 +140,7 @@
 
 use core::borrow::Borrow;
 use core::cmp::{Eq, PartialEq};
+use core::convert::TryFrom;
 use core::fmt::Debug;
 use core::iter::{Product, Sum};
 use core::ops::Index;
@@ -148,6 +149,8 @@ use core::ops::{Add, AddAssign};
 use core::ops::{Mul, MulAssign};
 use core::ops::{Sub, SubAssign};
 
+use errors::{CurveError, InternalError};
+
 #[allow(unused_imports)]
 use prelude::*;
 
@@ -242,11 +245,7 @@ impl Scalar {
     /// require specific bit-patterns when performing scalar
     /// multiplication.
     pub fn from_bits(bytes: [u8; 32]) -> Scalar {
-        let mut s = Scalar{bytes: bytes};
-        // Ensure that s < 2^255 by masking the high bit
-        s.bytes[31] &= 0b0111_1111;
-
-        s
+        Scalar::from(bytes)
     }
 }
 
@@ -459,6 +458,33 @@ impl Default for Scalar {
     }
 }
 
+impl TryFrom<&[u8]> for Scalar {
+    type Error = CurveError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        if bytes.len() != 32 {
+            return Err(CurveError(
+                InternalError::BytesLengthError{name: "Scalar", length: 32}));
+        }
+
+        let mut s_bytes = [0x00u8; 32];
+        s_bytes.copy_from_slice(bytes);
+
+        Ok(Scalar::from(s_bytes))
+    }
+}
+
+impl From<[u8; 32]> for Scalar {
+    fn from(bytes: [u8; 32]) -> Self {
+        let mut s = Scalar{bytes: bytes};
+
+        // Ensure that s < 2^255 by masking the high bit
+        s.bytes[31] &= 0b0111_1111;
+
+        s
+    }
+}
+
 impl From<u8> for Scalar {
     fn from(x: u8) -> Scalar {
         let mut s_bytes = [0u8; 32];