use super::*;
use core::ops::{Deref, DerefMut};
pub const SHA1_HASH_SIZE: usize = 20;
pub const SHA256_HASH_SIZE: usize = 32;
pub const SHA384_HASH_SIZE: usize = 48;
pub const SM3_HASH_SIZE: usize = 32;
pub type ShaHandle = *mut c_void;
pub type CMacHandle = *mut c_void;
pub type HMacHandle = *mut c_void;
pub type AesHandle = *mut c_void;
pub type EccHandle = *mut c_void;
pub type Sm3Handle = *mut c_void;
pub type Sm4Handle = *mut c_void;
impl_enum! {
#[repr(u8)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EcResult {
Valid = 0x00, CompositeBase = 0x01, ComplicatedBase = 0x02, IsZeroDiscriminant = 0x03, CompositeOrder = 0x04, InvalidOrder = 0x05, IsWeakMov = 0x06, IsWeakSsa = 0x07, IsSuperSingular = 0x08, InvalidPrivateKey = 0x09, InvalidPublicKey = 0x0A, InvalidKeyPair = 0x0B, PointOutOfGroup = 0x0C, PointIsAtInfinity = 0x0D, PointIsNotValid = 0x0E, PointIsEqual = 0x0F, PointIsNotEqual = 0x10, InvalidSignature = 0x11, }
}
impl EcResult {
#[inline]
pub fn is_valid(&self) -> bool {
*self == EcResult::Valid
}
}
pub type Key128bit = [u8; KEY_128BIT_SIZE];
impl_struct! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Sha1Hash {
pub hash: [u8; SHA1_HASH_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Sha256Hash {
pub hash: [u8; SHA256_HASH_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Sm3Hash {
pub hash: [u8; SM3_HASH_SIZE],
}
}
impl_copy_clone! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Sha384Hash {
pub hash: [u8; SHA384_HASH_SIZE],
}
}
macro_rules! impl_hash_eq {
($($i:ident;)*) => {$(
impl PartialEq<[u8; core::mem::size_of::<$i>()]> for $i {
#[inline]
fn eq(&self, other: &[u8; core::mem::size_of::<$i>()]) -> bool {
self.hash.eq(other)
}
}
impl PartialEq<[u8]> for $i {
#[inline]
fn eq(&self, other: &[u8]) -> bool {
self.hash.eq(other)
}
}
)*}
}
impl_hash_eq! {
Sha1Hash;
Sha256Hash;
Sha384Hash;
Sm3Hash;
}
impl_struct_default! {
Sha384Hash; }
impl_struct_ContiguousMemory! {
Sha384Hash;
}
impl_asref_array! {
Sha1Hash;
Sha256Hash;
Sha384Hash;
Sm3Hash;
}
impl_asmut_array! {
Sha1Hash;
Sha256Hash;
Sha384Hash;
Sm3Hash;
}
impl_from_array! {
Sha1Hash;
Sha256Hash;
Sha384Hash;
Sm3Hash;
}
impl_unsafe_marker_for! {
BytewiseEquality,
Sha1Hash Sha256Hash Sha384Hash Sm3Hash
}
macro_rules! impl_hash_deref {
($($i:ident;)*) => {$(
impl Deref for $i {
type Target = [u8];
#[inline]
fn deref(&self) -> &Self::Target {
&self.hash[..]
}
}
impl DerefMut for $i {
#[inline]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.hash[..]
}
}
impl $i {
pub fn as_slice(&self) -> &[u8] {
self
}
pub fn as_mut_slice(&mut self) -> &[u8] {
self
}
}
)*}
}
impl_hash_deref! {
Sha1Hash;
Sha256Hash;
Sha384Hash;
Sm3Hash;
}
pub const KEY_128BIT_SIZE: usize = 16;
pub const KEY_256BIT_SIZE: usize = 32;
pub const MAC_128BIT_SIZE: usize = 16;
pub const MAC_256BIT_SIZE: usize = 32;
pub const ECP256_KEY_SIZE: usize = 32;
pub const NISTP_ECP256_KEY_SIZE: usize = ECP256_KEY_SIZE / 4;
pub const RSA3072_KEY_SIZE: usize = 384;
pub const RSA3072_PRI_EXP_SIZE: usize = 384;
pub const RSA3072_PUB_EXP_SIZE: usize = 4;
pub const RSA2048_KEY_SIZE: usize = 256;
pub const RSA2048_PRI_EXP_SIZE: usize = 256;
pub const RSA2048_PUB_EXP_SIZE: usize = 4;
pub const AESGCM_IV_SIZE: usize = 12;
pub const AESCCM_IV_SIZE: usize = 12;
pub const AESCBC_IV_SIZE: usize = 16;
pub const AESCTR_CTR_SIZE: usize = 16;
pub const SM4CCM_IV_SIZE: usize = 12;
pub const SM4CBC_IV_SIZE: usize = 16;
pub const SM4CTR_CTR_SIZE: usize = 16;
pub type Key256bit = [u8; KEY_256BIT_SIZE];
pub type Mac128bit = [u8; MAC_128BIT_SIZE];
pub type Mac256bit = [u8; MAC_256BIT_SIZE];
impl_struct! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Ec256SharedKey {
pub s: [u8; ECP256_KEY_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Ec256PrivateKey {
pub r: [u8; ECP256_KEY_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Ec256PublicKey {
pub gx: [u8; ECP256_KEY_SIZE],
pub gy: [u8; ECP256_KEY_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Ec256Signature {
pub x: [u32; NISTP_ECP256_KEY_SIZE],
pub y: [u32; NISTP_ECP256_KEY_SIZE],
}
}
impl_asref_array! {
Ec256SharedKey;
Ec256PrivateKey;
Ec256PublicKey;
Ec256Signature;
}
impl_asmut_array! {
Ec256SharedKey;
Ec256PrivateKey;
Ec256PublicKey;
Ec256Signature;
}
impl_from_array! {
Ec256SharedKey;
Ec256PrivateKey;
Ec256PublicKey;
Ec256Signature;
}
impl_unsafe_marker_for! {
BytewiseEquality,
Ec256PrivateKey Ec256SharedKey Ec256PublicKey Ec256Signature
}
pub type RsaKey = *mut c_void;
impl_enum! {
#[repr(u32)]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum RsaKeyType {
PrivateKey = 0, PublicKey = 1, }
}
impl_enum! {
#[repr(u32)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RsaResult {
Valid = 0, InvalidSignature = 1, }
}
impl RsaResult {
#[inline]
pub fn is_valid(&self) -> bool {
*self == RsaResult::Valid
}
}
impl_copy_clone! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa3072Param {
pub n: [u8; RSA3072_KEY_SIZE],
pub d: [u8; RSA3072_PRI_EXP_SIZE],
pub e: [u8; RSA3072_PUB_EXP_SIZE],
pub p: [u8; RSA3072_KEY_SIZE / 2],
pub q: [u8; RSA3072_KEY_SIZE / 2],
pub dmp1: [u8; RSA3072_KEY_SIZE / 2],
pub dmq1: [u8; RSA3072_KEY_SIZE / 2],
pub iqmp: [u8; RSA3072_KEY_SIZE / 2],
}
}
impl_struct_default! {
Rsa3072Param; }
impl_struct_ContiguousMemory! {
Rsa3072Param;
}
impl_unsafe_marker_for! {BytewiseEquality, Rsa3072Param}
impl_asref_array! {
Rsa3072Param;
}
impl_asmut_array! {
Rsa3072Param;
}
impl_from_array! {
Rsa3072Param;
}
impl_copy_clone! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa3072PubKey {
pub modulus: [u8; RSA3072_KEY_SIZE],
pub exponent: [u8; RSA3072_PUB_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa3072PrivKey {
pub modulus: [u8; RSA3072_KEY_SIZE],
pub exponent: [u8; RSA3072_PRI_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa3072Key {
pub modulus: [u8; RSA3072_KEY_SIZE],
pub d: [u8; RSA3072_PRI_EXP_SIZE],
pub e: [u8; RSA3072_PUB_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa3072Signature {
pub signature: [u8; RSA3072_KEY_SIZE],
}
}
impl From<(Rsa3072PrivKey, Rsa3072PubKey)> for Rsa3072Key {
#[inline]
fn from(key_pair: (Rsa3072PrivKey, Rsa3072PubKey)) -> Rsa3072Key {
Rsa3072Key {
modulus: key_pair.0.modulus,
d: key_pair.0.exponent,
e: key_pair.1.exponent,
}
}
}
impl From<Rsa3072Key> for (Rsa3072PrivKey, Rsa3072PubKey) {
#[inline]
fn from(key_pair: Rsa3072Key) -> (Rsa3072PrivKey, Rsa3072PubKey) {
(
Rsa3072PrivKey {
modulus: key_pair.modulus,
exponent: key_pair.d,
},
Rsa3072PubKey {
modulus: key_pair.modulus,
exponent: key_pair.e,
},
)
}
}
impl_struct_default! {
Rsa3072PubKey; Rsa3072PrivKey; Rsa3072Key; Rsa3072Signature; }
impl_struct_ContiguousMemory! {
Rsa3072PubKey;
Rsa3072PrivKey;
Rsa3072Key;
Rsa3072Signature;
}
impl_unsafe_marker_for! {BytewiseEquality,
Rsa3072PubKey Rsa3072PrivKey Rsa3072Key Rsa3072Signature}
impl_asref_array! {
Rsa3072PubKey;
Rsa3072PrivKey;
Rsa3072Key;
Rsa3072Signature;
}
impl_asmut_array! {
Rsa3072PubKey;
Rsa3072PrivKey;
Rsa3072Key;
Rsa3072Signature;
}
impl_from_array! {
Rsa3072PubKey;
Rsa3072PrivKey;
Rsa3072Key;
Rsa3072Signature;
}
impl_copy_clone! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa2048Param {
pub n: [u8; RSA2048_KEY_SIZE],
pub d: [u8; RSA2048_PRI_EXP_SIZE],
pub e: [u8; RSA2048_PUB_EXP_SIZE],
pub p: [u8; RSA2048_KEY_SIZE / 2],
pub q: [u8; RSA2048_KEY_SIZE / 2],
pub dmp1: [u8; RSA2048_KEY_SIZE / 2],
pub dmq1: [u8; RSA2048_KEY_SIZE / 2],
pub iqmp: [u8; RSA2048_KEY_SIZE / 2],
}
}
impl_struct_default! {
Rsa2048Param; }
impl_struct_ContiguousMemory! {
Rsa2048Param;
}
impl_unsafe_marker_for! {BytewiseEquality, Rsa2048Param}
impl_asref_array! {
Rsa2048Param;
}
impl_asmut_array! {
Rsa2048Param;
}
impl_from_array! {
Rsa2048Param;
}
impl_copy_clone! {
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa2048PubKey {
pub modulus: [u8; RSA2048_KEY_SIZE],
pub exponent: [u8; RSA2048_PUB_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa2048PrivKey {
pub modulus: [u8; RSA2048_KEY_SIZE],
pub exponent: [u8; RSA2048_PRI_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa2048Key {
pub modulus: [u8; RSA2048_KEY_SIZE],
pub d: [u8; RSA2048_PRI_EXP_SIZE],
pub e: [u8; RSA2048_PUB_EXP_SIZE],
}
#[repr(C)]
#[derive(Debug, Eq, PartialEq)]
pub struct Rsa2048Signature {
pub signature: [u8; RSA2048_KEY_SIZE],
}
}
impl From<(Rsa2048PrivKey, Rsa2048PubKey)> for Rsa2048Key {
#[inline]
fn from(key_pair: (Rsa2048PrivKey, Rsa2048PubKey)) -> Rsa2048Key {
Rsa2048Key {
modulus: key_pair.0.modulus,
d: key_pair.0.exponent,
e: key_pair.1.exponent,
}
}
}
impl From<Rsa2048Key> for (Rsa2048PrivKey, Rsa2048PubKey) {
#[inline]
fn from(key_pair: Rsa2048Key) -> (Rsa2048PrivKey, Rsa2048PubKey) {
(
Rsa2048PrivKey {
modulus: key_pair.modulus,
exponent: key_pair.d,
},
Rsa2048PubKey {
modulus: key_pair.modulus,
exponent: key_pair.e,
},
)
}
}
impl_struct_default! {
Rsa2048PubKey; Rsa2048PrivKey; Rsa2048Key; Rsa2048Signature; }
impl_struct_ContiguousMemory! {
Rsa2048PubKey;
Rsa2048PrivKey;
Rsa2048Key;
Rsa2048Signature;
}
impl_unsafe_marker_for! {BytewiseEquality,
Rsa2048PubKey Rsa2048PrivKey Rsa2048Key Rsa2048Signature}
impl_asref_array! {
Rsa2048PubKey;
Rsa2048PrivKey;
Rsa2048Key;
Rsa2048Signature;
}
impl_asmut_array! {
Rsa2048PubKey;
Rsa2048PrivKey;
Rsa2048Key;
Rsa2048Signature;
}
impl_from_array! {
Rsa2048PubKey;
Rsa2048PrivKey;
Rsa2048Key;
Rsa2048Signature;
}
#[repr(C, align(32))]
#[derive(Clone, Copy, Default)]
pub struct AlignKey128bit {
_pad: [u8; 16],
pub key: Key128bit,
}
impl From<Key128bit> for AlignKey128bit {
fn from(key: Key128bit) -> AlignKey128bit {
AlignKey128bit { _pad: [0; 16], key }
}
}
impl From<&Key128bit> for AlignKey128bit {
fn from(key: &Key128bit) -> AlignKey128bit {
AlignKey128bit {
_pad: [0; 16],
key: *key,
}
}
}
impl AsRef<[u8; KEY_128BIT_SIZE]> for AlignKey128bit {
#[inline]
fn as_ref(&self) -> &[u8; KEY_128BIT_SIZE] {
&self.key
}
}
impl AsMut<[u8; KEY_128BIT_SIZE]> for AlignKey128bit {
#[inline]
fn as_mut(&mut self) -> &mut [u8; KEY_128BIT_SIZE] {
&mut self.key
}
}
impl PartialEq for AlignKey128bit {
fn eq(&self, other: &AlignKey128bit) -> bool {
self.key.eq(&other.key)
}
}
impl Eq for AlignKey128bit {}
impl fmt::Debug for AlignKey128bit {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignKey128bit")
.field("key", &self.key)
.finish()
}
}
#[repr(C, align(64))]
#[derive(Clone, Copy, Default)]
pub struct AlignKey256bit {
_pad1: [u8; 8],
pub key: Key256bit,
_pad2: [u8; 24],
}
impl From<Key256bit> for AlignKey256bit {
#[inline]
fn from(key: Key256bit) -> AlignKey256bit {
AlignKey256bit {
_pad1: [0; 8],
key,
_pad2: [0; 24],
}
}
}
impl From<&Key256bit> for AlignKey256bit {
#[inline]
fn from(key: &Key256bit) -> AlignKey256bit {
AlignKey256bit {
_pad1: [0; 8],
key: *key,
_pad2: [0; 24],
}
}
}
impl AsRef<[u8; KEY_256BIT_SIZE]> for AlignKey256bit {
#[inline]
fn as_ref(&self) -> &[u8; KEY_256BIT_SIZE] {
&self.key
}
}
impl AsMut<[u8; KEY_256BIT_SIZE]> for AlignKey256bit {
#[inline]
fn as_mut(&mut self) -> &mut [u8; KEY_256BIT_SIZE] {
&mut self.key
}
}
impl PartialEq for AlignKey256bit {
#[inline]
fn eq(&self, other: &AlignKey256bit) -> bool {
self.key.eq(&other.key)
}
}
impl Eq for AlignKey256bit {}
impl fmt::Debug for AlignKey256bit {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignKey256bit")
.field("key", &self.key)
.finish()
}
}
#[repr(C, align(32))]
#[derive(Clone, Copy, Default)]
pub struct AlignMac128bit {
_pad: [u8; 16],
pub mac: Mac128bit,
}
impl From<Mac128bit> for AlignMac128bit {
#[inline]
fn from(mac: Mac128bit) -> AlignMac128bit {
AlignMac128bit { _pad: [0; 16], mac }
}
}
impl From<&Mac128bit> for AlignMac128bit {
#[inline]
fn from(mac: &Mac128bit) -> AlignMac128bit {
AlignMac128bit {
_pad: [0; 16],
mac: *mac,
}
}
}
impl AsRef<[u8; MAC_128BIT_SIZE]> for AlignMac128bit {
#[inline]
fn as_ref(&self) -> &[u8; MAC_128BIT_SIZE] {
&self.mac
}
}
impl AsMut<[u8; MAC_128BIT_SIZE]> for AlignMac128bit {
#[inline]
fn as_mut(&mut self) -> &mut [u8; MAC_128BIT_SIZE] {
&mut self.mac
}
}
impl PartialEq for AlignMac128bit {
#[inline]
fn eq(&self, other: &AlignMac128bit) -> bool {
self.mac.eq(&other.mac)
}
}
impl Eq for AlignMac128bit {}
impl fmt::Debug for AlignMac128bit {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignMac128bit")
.field("mac", &self.mac)
.finish()
}
}
#[repr(C, align(64))]
#[derive(Clone, Copy, Default)]
pub struct AlignMac256bit {
_pad1: [u8; 8],
pub mac: Mac256bit,
_pad2: [u8; 24],
}
impl From<Mac256bit> for AlignMac256bit {
fn from(mac: Mac256bit) -> AlignMac256bit {
AlignMac256bit {
_pad1: [0; 8],
mac,
_pad2: [0; 24],
}
}
}
impl From<&Mac256bit> for AlignMac256bit {
#[inline]
fn from(mac: &Mac256bit) -> AlignMac256bit {
AlignMac256bit {
_pad1: [0; 8],
mac: *mac,
_pad2: [0; 24],
}
}
}
impl AsRef<[u8; MAC_256BIT_SIZE]> for AlignMac256bit {
#[inline]
fn as_ref(&self) -> &[u8; MAC_256BIT_SIZE] {
&self.mac
}
}
impl AsMut<[u8; MAC_256BIT_SIZE]> for AlignMac256bit {
#[inline]
fn as_mut(&mut self) -> &mut [u8; MAC_256BIT_SIZE] {
&mut self.mac
}
}
impl PartialEq for AlignMac256bit {
#[inline]
fn eq(&self, other: &AlignMac256bit) -> bool {
self.mac.eq(&other.mac)
}
}
impl Eq for AlignMac256bit {}
impl fmt::Debug for AlignMac256bit {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignMac256bit")
.field("mac", &self.mac)
.finish()
}
}
#[repr(C, align(64))]
#[derive(Copy, Clone, Default)]
pub struct AlignEc256SharedKey {
_pad1: [u8; 8],
pub key: Ec256SharedKey,
_pad2: [u8; 24],
}
impl From<Ec256SharedKey> for AlignEc256SharedKey {
#[inline]
fn from(key: Ec256SharedKey) -> AlignEc256SharedKey {
AlignEc256SharedKey {
_pad1: [0; 8],
key,
_pad2: [0; 24],
}
}
}
impl From<&Ec256SharedKey> for AlignEc256SharedKey {
#[inline]
fn from(key: &Ec256SharedKey) -> AlignEc256SharedKey {
AlignEc256SharedKey {
_pad1: [0; 8],
key: *key,
_pad2: [0; 24],
}
}
}
impl AsRef<[u8; ECP256_KEY_SIZE]> for AlignEc256SharedKey {
#[inline]
fn as_ref(&self) -> &[u8; ECP256_KEY_SIZE] {
self.key.as_ref()
}
}
impl AsMut<[u8; ECP256_KEY_SIZE]> for AlignEc256SharedKey {
#[inline]
fn as_mut(&mut self) -> &mut [u8; ECP256_KEY_SIZE] {
self.key.as_mut()
}
}
impl From<[u8; ECP256_KEY_SIZE]> for AlignEc256SharedKey {
#[inline]
fn from(key: [u8; ECP256_KEY_SIZE]) -> AlignEc256SharedKey {
AlignEc256SharedKey::from(Ec256SharedKey::from(key))
}
}
impl From<&[u8; ECP256_KEY_SIZE]> for AlignEc256SharedKey {
#[inline]
fn from(key: &[u8; ECP256_KEY_SIZE]) -> AlignEc256SharedKey {
AlignEc256SharedKey::from(Ec256SharedKey::from(key))
}
}
impl PartialEq for AlignEc256SharedKey {
#[inline]
fn eq(&self, other: &AlignEc256SharedKey) -> bool {
self.key.eq(&other.key)
}
}
impl Eq for AlignEc256SharedKey {}
impl fmt::Debug for AlignEc256SharedKey {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignEc256SharedKey")
.field("key", &self.key)
.finish()
}
}
#[repr(C, align(64))]
#[derive(Copy, Clone, Default)]
pub struct AlignEc256PrivateKey {
_pad1: [u8; 8],
pub key: Ec256PrivateKey,
_pad2: [u8; 24],
}
impl From<Ec256PrivateKey> for AlignEc256PrivateKey {
#[inline]
fn from(key: Ec256PrivateKey) -> AlignEc256PrivateKey {
AlignEc256PrivateKey {
_pad1: [0; 8],
key,
_pad2: [0; 24],
}
}
}
impl From<&Ec256PrivateKey> for AlignEc256PrivateKey {
#[inline]
fn from(key: &Ec256PrivateKey) -> AlignEc256PrivateKey {
AlignEc256PrivateKey {
_pad1: [0; 8],
key: *key,
_pad2: [0; 24],
}
}
}
impl AsRef<[u8; ECP256_KEY_SIZE]> for AlignEc256PrivateKey {
#[inline]
fn as_ref(&self) -> &[u8; ECP256_KEY_SIZE] {
self.key.as_ref()
}
}
impl AsMut<[u8; ECP256_KEY_SIZE]> for AlignEc256PrivateKey {
#[inline]
fn as_mut(&mut self) -> &mut [u8; ECP256_KEY_SIZE] {
self.key.as_mut()
}
}
impl From<[u8; ECP256_KEY_SIZE]> for AlignEc256PrivateKey {
#[inline]
fn from(key: [u8; ECP256_KEY_SIZE]) -> AlignEc256PrivateKey {
AlignEc256PrivateKey::from(Ec256PrivateKey::from(key))
}
}
impl From<&[u8; ECP256_KEY_SIZE]> for AlignEc256PrivateKey {
#[inline]
fn from(key: &[u8; ECP256_KEY_SIZE]) -> AlignEc256PrivateKey {
AlignEc256PrivateKey::from(Ec256PrivateKey::from(key))
}
}
impl PartialEq for AlignEc256PrivateKey {
#[inline]
fn eq(&self, other: &AlignEc256PrivateKey) -> bool {
self.key.eq(&other.key)
}
}
impl Eq for AlignEc256PrivateKey {}
impl fmt::Debug for AlignEc256PrivateKey {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_struct("AlignEc256PrivateKey")
.field("key", &self.key)
.finish()
}
}
impl_struct_ContiguousMemory! {
AlignKey128bit;
AlignKey256bit;
AlignMac128bit;
AlignMac256bit;
AlignEc256SharedKey;
AlignEc256PrivateKey;
}
impl_unsafe_marker_for! {
BytewiseEquality,
AlignKey128bit AlignKey256bit AlignMac128bit AlignMac256bit AlignEc256SharedKey AlignEc256PrivateKey
}