zecfoundation
/
frost
mirror of https://github.com/ZcashFoundation/frost.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

convert all usages of from/to_bytes() to (de)serialize() (#426) 

* convert all usages of from/to_bytes() to (de)serialize()

* changelog entry
This commit is contained in:
Conrado Gouvea 2023-07-03 05:18:19 -03:00 committed by GitHub
parent 31c6f9eb79
commit 17c98d4412
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 111 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
frost-core/CHANGELOG.md
View File

@ -6,6 +6,8 @@ Entries are listed in reverse chronological order.
## 0.6.0
* rename all `to_bytes()`/`from_bytes()` to `serialize()`/`deserialize()`
## Released
## 0.5.0

10
frost-core/src/frost.rs
View File

@ -45,7 +45,7 @@ where
C: Ciphersuite,
{
/// Deserializes [`BindingFactor`] from bytes.
pub fn from_bytes(
pub fn deserialize(
bytes: <<C::Group as Group>::Field as Field>::Serialization,
) -> Result<Self, Error<C>> {
<<C::Group as Group>::Field>::deserialize(&bytes)
@ -54,7 +54,7 @@ where
}
/// Serializes [`BindingFactor`] to bytes.
pub fn to_bytes(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
pub fn serialize(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
<<C::Group as Group>::Field>::serialize(&self.0)
}
}
@ -65,7 +65,7 @@ where
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("BindingFactor")
.field(&hex::encode(self.to_bytes()))
.field(&hex::encode(self.serialize()))
.finish()
}
}
@ -140,7 +140,7 @@ where
fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
let v: Vec<u8> = FromHex::from_hex(hex).map_err(|_| "invalid hex")?;
match v.try_into() {
Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed scalar encoding"),
Ok(bytes) => Self::deserialize(bytes).map_err(|_| "malformed scalar encoding"),
Err(_) => Err("malformed scalar encoding"),
}
}
@ -292,7 +292,7 @@ where
// impl<C> Debug for GroupCommitment<C> where C: Ciphersuite {
// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// f.debug_tuple("GroupCommitment")
// .field(&hex::encode(self.0.compress().to_bytes()))
// .field(&hex::encode(self.0.compress().serialize()))
// .finish()
// }
// }

20
frost-core/src/frost/keys.rs
View File

@ -55,7 +55,7 @@ where
C: Ciphersuite,
{
/// Deserialize from bytes
pub fn from_bytes(
pub fn deserialize(
bytes: <<C::Group as Group>::Field as Field>::Serialization,
) -> Result<Self, Error<C>> {
<<C::Group as Group>::Field>::deserialize(&bytes)
@ -64,7 +64,7 @@ where
}
/// Serialize to bytes
pub fn to_bytes(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
pub fn serialize(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
<<C::Group as Group>::Field>::serialize(&self.0)
}
}
@ -100,7 +100,7 @@ where
fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
let v: Vec<u8> = FromHex::from_hex(hex).map_err(|_| "invalid hex")?;
match v.try_into() {
Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed secret encoding"),
Ok(bytes) => Self::deserialize(bytes).map_err(|_| "malformed secret encoding"),
Err(_) => Err("malformed secret encoding"),
}
}
@ -114,7 +114,7 @@ where
type Error = Error<C>;
fn try_from(value: ScalarSerialization<C>) -> Result<Self, Self::Error> {
Self::from_bytes(value.0)
Self::deserialize(value.0)
}
}
@ -124,7 +124,7 @@ where
C: Ciphersuite,
{
fn from(value: SigningShare<C>) -> Self {
Self(value.to_bytes())
Self(value.serialize())
}
}
@ -142,14 +142,14 @@ where
C: Ciphersuite,
{
/// Deserialize from bytes
pub fn from_bytes(bytes: <C::Group as Group>::Serialization) -> Result<Self, Error<C>> {
pub fn deserialize(bytes: <C::Group as Group>::Serialization) -> Result<Self, Error<C>> {
<C::Group as Group>::deserialize(&bytes)
.map(|element| Self(element))
.map_err(|e| e.into())
}
/// Serialize to bytes
pub fn to_bytes(&self) -> <C::Group as Group>::Serialization {
pub fn serialize(&self) -> <C::Group as Group>::Serialization {
<C::Group as Group>::serialize(&self.0)
}
}
@ -160,7 +160,7 @@ where
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("VerifyingShare")
.field(&hex::encode(self.to_bytes()))
.field(&hex::encode(self.serialize()))
.finish()
}
}
@ -182,7 +182,7 @@ where
type Error = Error<C>;
fn try_from(value: ElementSerialization<C>) -> Result<Self, Self::Error> {
Self::from_bytes(value.0)
Self::deserialize(value.0)
}
}
@ -192,7 +192,7 @@ where
C: Ciphersuite,
{
fn from(value: VerifyingShare<C>) -> Self {
Self(value.to_bytes())
Self(value.serialize())
}
}

20
frost-core/src/frost/round1.rs
View File

@ -64,7 +64,7 @@ where
}
/// Deserialize [`Nonce`] from bytes
pub fn from_bytes(
pub fn deserialize(
bytes: <<C::Group as Group>::Field as Field>::Serialization,
) -> Result<Self, Error<C>> {
<<C::Group as Group>::Field>::deserialize(&bytes)
@ -73,7 +73,7 @@ where
}
/// Serialize [`Nonce`] to bytes
pub fn to_bytes(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
pub fn serialize(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
<<C::Group as Group>::Field>::serialize(&self.0)
}
}
@ -106,7 +106,7 @@ where
fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
let v: Vec<u8> = FromHex::from_hex(hex).map_err(|_| "invalid hex")?;
match v.try_into() {
Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed nonce encoding"),
Ok(bytes) => Self::deserialize(bytes).map_err(|_| "malformed nonce encoding"),
Err(_) => Err("malformed nonce encoding"),
}
}
@ -124,14 +124,14 @@ where
C: Ciphersuite,
{
/// Deserialize [`NonceCommitment`] from bytes
pub fn from_bytes(bytes: <C::Group as Group>::Serialization) -> Result<Self, Error<C>> {
pub fn deserialize(bytes: <C::Group as Group>::Serialization) -> Result<Self, Error<C>> {
<C::Group>::deserialize(&bytes)
.map(|element| Self(element))
.map_err(|e| e.into())
}
/// Serialize [`NonceCommitment`] to bytes
pub fn to_bytes(&self) -> <C::Group as Group>::Serialization {
pub fn serialize(&self) -> <C::Group as Group>::Serialization {
<C::Group>::serialize(&self.0)
}
}
@ -144,7 +144,7 @@ where
type Error = Error<C>;
fn try_from(value: ElementSerialization<C>) -> Result<Self, Self::Error> {
Self::from_bytes(value.0)
Self::deserialize(value.0)
}
}
@ -154,7 +154,7 @@ where
C: Ciphersuite,
{
fn from(value: NonceCommitment<C>) -> Self {
Self(value.to_bytes())
Self(value.serialize())
}
}
@ -164,7 +164,7 @@ where
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("NonceCommitment")
.field(&hex::encode(self.to_bytes()))
.field(&hex::encode(self.serialize()))
.finish()
}
}
@ -197,7 +197,9 @@ where
fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
let v: Vec<u8> = FromHex::from_hex(hex).map_err(|_| "invalid hex")?;
match v.try_into() {
Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed nonce commitment encoding"),
Ok(bytes) => {
Self::deserialize(bytes).map_err(|_| "malformed nonce commitment encoding")
}
Err(_) => Err("malformed nonce commitment encoding"),
}
}

10
frost-core/src/frost/round2.rs
View File

@ -26,7 +26,7 @@ where
C: Ciphersuite,
{
/// Deserialize [`SignatureResponse`] from bytes
pub fn from_bytes(
pub fn deserialize(
bytes: <<C::Group as Group>::Field as Field>::Serialization,
) -> Result<Self, Error<C>> {
<<C::Group as Group>::Field>::deserialize(&bytes)
@ -35,7 +35,7 @@ where
}
/// Serialize [`SignatureResponse`] to bytes
pub fn to_bytes(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
pub fn serialize(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
<<C::Group as Group>::Field>::serialize(&self.z_share)
}
}
@ -48,7 +48,7 @@ where
type Error = Error<C>;
fn try_from(value: ScalarSerialization<C>) -> Result<Self, Self::Error> {
Self::from_bytes(value.0)
Self::deserialize(value.0)
}
}
@ -58,7 +58,7 @@ where
C: Ciphersuite,
{
fn from(value: SignatureResponse<C>) -> Self {
Self(value.to_bytes())
Self(value.serialize())
}
}
@ -68,7 +68,7 @@ where
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("SignatureResponse")
.field("z_share", &hex::encode(self.to_bytes()))
.field("z_share", &hex::encode(self.serialize()))
.finish()
}
}

10
frost-core/src/signature.rs
View File

@ -30,7 +30,7 @@ where
}
/// Converts bytes as [`Ciphersuite::SignatureSerialization`] into a `Signature<C>`.
pub fn from_bytes(bytes: C::SignatureSerialization) -> Result<Self, Error<C>> {
pub fn deserialize(bytes: C::SignatureSerialization) -> Result<Self, Error<C>> {
// To compute the expected length of the encoded point, encode the generator
// and get its length. Note that we can't use the identity because it can be encoded
// shorter in some cases (e.g. P-256, which uses SEC1 encoding).
@ -61,7 +61,7 @@ where
}
/// Converts this signature to its [`Ciphersuite::SignatureSerialization`] in bytes.
pub fn to_bytes(&self) -> C::SignatureSerialization {
pub fn serialize(&self) -> C::SignatureSerialization {
let mut bytes = vec![];
bytes.extend(<C::Group>::serialize(&self.R).as_ref());
@ -82,7 +82,7 @@ where
where
S: serde::Serializer,
{
serdect::slice::serialize_hex_lower_or_bin(&self.to_bytes().as_ref(), serializer)
serdect::slice::serialize_hex_lower_or_bin(&self.serialize().as_ref(), serializer)
}
}
@ -101,7 +101,7 @@ where
let array = bytes
.try_into()
.map_err(|_| serde::de::Error::custom("invalid byte length"))?;
let identifier = Signature::from_bytes(array)
let identifier = Signature::deserialize(array)
.map_err(|err| serde::de::Error::custom(format!("{err}")))?;
Ok(identifier)
}
@ -127,7 +127,7 @@ impl<C: Ciphersuite> std::fmt::Debug for Signature<C> {
// fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
// match FromHex::from_hex(hex) {
// Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed signature encoding"),
// Ok(bytes) => Self::deserialize(bytes).map_err(|_| "malformed signature encoding"),
// Err(_) => Err("invalid hex"),
// }
// }

4
frost-core/src/signing_key.rs
View File

@ -25,7 +25,7 @@ where
}
/// Deserialize from bytes
pub fn from_bytes(
pub fn deserialize(
bytes: <<C::Group as Group>::Field as Field>::Serialization,
) -> Result<SigningKey<C>, Error<C>> {
<<C::Group as Group>::Field as Field>::deserialize(&bytes)
@ -34,7 +34,7 @@ where
}
/// Serialize `SigningKey` to bytes
pub fn to_bytes(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
pub fn serialize(&self) -> <<C::Group as Group>::Field as Field>::Serialization {
<<C::Group as Group>::Field as Field>::serialize(&self.scalar)
}

4
frost-core/src/tests/ciphersuite_generic.rs
View File

@ -35,9 +35,9 @@ pub fn check_share_generation<C: Ciphersuite, R: RngCore + CryptoRng>(mut rng: R
assert_eq!(
frost::keys::reconstruct::<C>(&secret_shares)
.unwrap()
.to_bytes()
.serialize()
.as_ref(),
secret.to_bytes().as_ref()
secret.serialize().as_ref()
);
// Test error cases

6
frost-core/src/tests/proptests.rs
View File

@ -59,12 +59,12 @@ where
// The signature data is stored in (refined) byte types, but do a round trip
// conversion to raw bytes to exercise those code paths.
let _sig = {
let bytes = self.sig.to_bytes();
Signature::<C>::from_bytes(bytes)
let bytes = self.sig.serialize();
Signature::<C>::deserialize(bytes)
};
// Check that the verification key is a valid key.
let _pub_key = VerifyingKey::<C>::from_bytes(self.vk.to_bytes())
let _pub_key = VerifyingKey::<C>::deserialize(self.vk.serialize())
.expect("The test verification key to be well-formed.");
// Check that signature validation has the expected result.

6
frost-core/src/tests/vectors.rs
View File

@ -35,7 +35,7 @@ pub fn parse_test_vectors<C: Ciphersuite>(json_vectors: &Value) -> TestVectors<C
let secret_key_str = inputs["group_secret_key"].as_str().unwrap();
let secret_key_bytes = hex::decode(secret_key_str).unwrap();
let secret_key =
SigningKey::from_bytes(secret_key_bytes.try_into().debugless_unwrap()).unwrap();
SigningKey::deserialize(secret_key_bytes.try_into().debugless_unwrap()).unwrap();
let message = inputs["message"].as_str().unwrap();
let message_bytes = hex::decode(message).unwrap();
@ -330,7 +330,7 @@ pub fn check_sign_with_test_vectors<C: Ciphersuite>(json_vectors: &Value) {
// Check that the generated signature matches the test vector signature
let group_signature = group_signature_result.unwrap();
assert_eq!(group_signature.to_bytes().as_ref(), signature_bytes);
assert_eq!(group_signature.serialize().as_ref(), signature_bytes);
// Aggregate the FROST signature from our signature shares
let group_signature_result =
@ -341,5 +341,5 @@ pub fn check_sign_with_test_vectors<C: Ciphersuite>(json_vectors: &Value) {
// Check that the generated signature matches the test vector signature
let group_signature = group_signature_result.unwrap();
assert_eq!(group_signature.to_bytes().as_ref(), signature_bytes);
assert_eq!(group_signature.serialize().as_ref(), signature_bytes);
}

12
frost-core/src/verifying_key.rs
View File

@ -43,7 +43,7 @@ where
}
/// Deserialize from bytes
pub fn from_bytes(
pub fn deserialize(
bytes: <C::Group as Group>::Serialization,
) -> Result<VerifyingKey<C>, Error<C>> {
<C::Group>::deserialize(&bytes)
@ -52,7 +52,7 @@ where
}
/// Serialize `VerifyingKey` to bytes
pub fn to_bytes(&self) -> <C::Group as Group>::Serialization {
pub fn serialize(&self) -> <C::Group as Group>::Serialization {
<C::Group>::serialize(&self.element)
}
@ -90,7 +90,7 @@ where
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("VerifyingKey")
.field(&hex::encode(self.to_bytes()))
.field(&hex::encode(self.serialize()))
.finish()
}
}
@ -105,7 +105,7 @@ where
fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
let v: Vec<u8> = FromHex::from_hex(hex).map_err(|_| "invalid hex")?;
match v.try_into() {
Ok(bytes) => Self::from_bytes(bytes).map_err(|_| "malformed verifying key encoding"),
Ok(bytes) => Self::deserialize(bytes).map_err(|_| "malformed verifying key encoding"),
Err(_) => Err("malformed verifying key encoding"),
}
}
@ -119,7 +119,7 @@ where
type Error = Error<C>;
fn try_from(value: ElementSerialization<C>) -> Result<Self, Self::Error> {
Self::from_bytes(value.0)
Self::deserialize(value.0)
}
}
@ -129,7 +129,7 @@ where
C: Ciphersuite,
{
fn from(value: VerifyingKey<C>) -> Self {
Self(value.to_bytes())
Self(value.serialize())
}
}

4
frost-ed25519/tests/helpers/mod.rs
View File

@ -14,11 +14,11 @@ pub fn verify_signature(
group_pubkey: frost_core::VerifyingKey<Ed25519Sha512>,
) {
let sig = {
let bytes: [u8; 64] = group_signature.to_bytes();
let bytes: [u8; 64] = group_signature.serialize();
ed25519_dalek::Signature::from(bytes)
};
let pub_key = {
let bytes = group_pubkey.to_bytes();
let bytes = group_pubkey.serialize();
ed25519_dalek::PublicKey::from_bytes(&bytes).unwrap()
};
// Check that signature validation has the expected result.

22
frost-ed25519/tests/helpers/samples.rs
View File

@ -36,8 +36,8 @@ fn scalar1() -> Scalar<C> {
pub fn signing_commitments() -> SigningCommitments {
let serialized_element1 = <C as Ciphersuite>::Group::serialize(&element1());
let serialized_element2 = <C as Ciphersuite>::Group::serialize(&element2());
let hiding_nonce_commitment = NonceCommitment::from_bytes(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::from_bytes(serialized_element2).unwrap();
let hiding_nonce_commitment = NonceCommitment::deserialize(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::deserialize(serialized_element2).unwrap();
let identifier = 42u16.try_into().unwrap();
SigningCommitments::new(
@ -59,7 +59,7 @@ pub fn signing_package() -> SigningPackage {
pub fn signature_share() -> SignatureShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signature_response = SignatureResponse::from_bytes(serialized_scalar).unwrap();
let signature_response = SignatureResponse::deserialize(serialized_scalar).unwrap();
SignatureShare::new(identifier, signature_response)
}
@ -69,7 +69,7 @@ pub fn secret_share() -> SecretShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
@ -81,10 +81,10 @@ pub fn key_package() -> KeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
KeyPackage::new(identifier, signing_share, verifying_share, verifying_key)
}
@ -93,9 +93,9 @@ pub fn key_package() -> KeyPackage {
pub fn public_key_package() -> PublicKeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
let signer_pubkeys = HashMap::from([(identifier, verifying_share)]);
PublicKeyPackage::new(signer_pubkeys, verifying_key)
@ -116,7 +116,7 @@ pub fn round1_package() -> round1::Package {
.unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
let signature = Signature::from_bytes(serialized_signature).unwrap();
let signature = Signature::deserialize(serialized_signature).unwrap();
round1::Package::new(identifier, vss_commitment, signature)
}
@ -125,7 +125,7 @@ pub fn round1_package() -> round1::Package {
pub fn round2_package() -> round2::Package {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
round2::Package::new(identifier, identifier, signing_share)
}

22
frost-ed448/tests/helpers/samples.rs
View File

@ -36,8 +36,8 @@ fn scalar1() -> Scalar<C> {
pub fn signing_commitments() -> SigningCommitments {
let serialized_element1 = <C as Ciphersuite>::Group::serialize(&element1());
let serialized_element2 = <C as Ciphersuite>::Group::serialize(&element2());
let hiding_nonce_commitment = NonceCommitment::from_bytes(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::from_bytes(serialized_element2).unwrap();
let hiding_nonce_commitment = NonceCommitment::deserialize(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::deserialize(serialized_element2).unwrap();
let identifier = 42u16.try_into().unwrap();
SigningCommitments::new(
@ -59,7 +59,7 @@ pub fn signing_package() -> SigningPackage {
pub fn signature_share() -> SignatureShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signature_response = SignatureResponse::from_bytes(serialized_scalar).unwrap();
let signature_response = SignatureResponse::deserialize(serialized_scalar).unwrap();
SignatureShare::new(identifier, signature_response)
}
@ -69,7 +69,7 @@ pub fn secret_share() -> SecretShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
@ -81,10 +81,10 @@ pub fn key_package() -> KeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
KeyPackage::new(identifier, signing_share, verifying_share, verifying_key)
}
@ -93,9 +93,9 @@ pub fn key_package() -> KeyPackage {
pub fn public_key_package() -> PublicKeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
let signer_pubkeys = HashMap::from([(identifier, verifying_share)]);
PublicKeyPackage::new(signer_pubkeys, verifying_key)
@ -116,7 +116,7 @@ pub fn round1_package() -> round1::Package {
.unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
let signature = Signature::from_bytes(serialized_signature).unwrap();
let signature = Signature::deserialize(serialized_signature).unwrap();
round1::Package::new(identifier, vss_commitment, signature)
}
@ -125,7 +125,7 @@ pub fn round1_package() -> round1::Package {
pub fn round2_package() -> round2::Package {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
round2::Package::new(identifier, identifier, signing_share)
}

22
frost-p256/tests/helpers/samples.rs
View File

@ -36,8 +36,8 @@ fn scalar1() -> Scalar<C> {
pub fn signing_commitments() -> SigningCommitments {
let serialized_element1 = <C as Ciphersuite>::Group::serialize(&element1());
let serialized_element2 = <C as Ciphersuite>::Group::serialize(&element2());
let hiding_nonce_commitment = NonceCommitment::from_bytes(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::from_bytes(serialized_element2).unwrap();
let hiding_nonce_commitment = NonceCommitment::deserialize(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::deserialize(serialized_element2).unwrap();
let identifier = 42u16.try_into().unwrap();
SigningCommitments::new(
@ -59,7 +59,7 @@ pub fn signing_package() -> SigningPackage {
pub fn signature_share() -> SignatureShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signature_response = SignatureResponse::from_bytes(serialized_scalar).unwrap();
let signature_response = SignatureResponse::deserialize(serialized_scalar).unwrap();
SignatureShare::new(identifier, signature_response)
}
@ -69,7 +69,7 @@ pub fn secret_share() -> SecretShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
@ -81,10 +81,10 @@ pub fn key_package() -> KeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
KeyPackage::new(identifier, signing_share, verifying_share, verifying_key)
}
@ -93,9 +93,9 @@ pub fn key_package() -> KeyPackage {
pub fn public_key_package() -> PublicKeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
let signer_pubkeys = HashMap::from([(identifier, verifying_share)]);
PublicKeyPackage::new(signer_pubkeys, verifying_key)
@ -116,7 +116,7 @@ pub fn round1_package() -> round1::Package {
.unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
let signature = Signature::from_bytes(serialized_signature).unwrap();
let signature = Signature::deserialize(serialized_signature).unwrap();
round1::Package::new(identifier, vss_commitment, signature)
}
@ -125,7 +125,7 @@ pub fn round1_package() -> round1::Package {
pub fn round2_package() -> round2::Package {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
round2::Package::new(identifier, identifier, signing_share)
}

22
frost-ristretto255/tests/helpers/samples.rs
View File

@ -36,8 +36,8 @@ fn scalar1() -> Scalar<C> {
pub fn signing_commitments() -> SigningCommitments {
let serialized_element1 = <C as Ciphersuite>::Group::serialize(&element1());
let serialized_element2 = <C as Ciphersuite>::Group::serialize(&element2());
let hiding_nonce_commitment = NonceCommitment::from_bytes(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::from_bytes(serialized_element2).unwrap();
let hiding_nonce_commitment = NonceCommitment::deserialize(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::deserialize(serialized_element2).unwrap();
let identifier = 42u16.try_into().unwrap();
SigningCommitments::new(
@ -59,7 +59,7 @@ pub fn signing_package() -> SigningPackage {
pub fn signature_share() -> SignatureShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signature_response = SignatureResponse::from_bytes(serialized_scalar).unwrap();
let signature_response = SignatureResponse::deserialize(serialized_scalar).unwrap();
SignatureShare::new(identifier, signature_response)
}
@ -69,7 +69,7 @@ pub fn secret_share() -> SecretShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
@ -81,10 +81,10 @@ pub fn key_package() -> KeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
KeyPackage::new(identifier, signing_share, verifying_share, verifying_key)
}
@ -93,9 +93,9 @@ pub fn key_package() -> KeyPackage {
pub fn public_key_package() -> PublicKeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
let signer_pubkeys = HashMap::from([(identifier, verifying_share)]);
PublicKeyPackage::new(signer_pubkeys, verifying_key)
@ -116,7 +116,7 @@ pub fn round1_package() -> round1::Package {
.unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
let signature = Signature::from_bytes(serialized_signature).unwrap();
let signature = Signature::deserialize(serialized_signature).unwrap();
round1::Package::new(identifier, vss_commitment, signature)
}
@ -125,7 +125,7 @@ pub fn round1_package() -> round1::Package {
pub fn round2_package() -> round2::Package {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
round2::Package::new(identifier, identifier, signing_share)
}

22
frost-secp256k1/tests/helpers/samples.rs
View File

@ -36,8 +36,8 @@ fn scalar1() -> Scalar<C> {
pub fn signing_commitments() -> SigningCommitments {
let serialized_element1 = <C as Ciphersuite>::Group::serialize(&element1());
let serialized_element2 = <C as Ciphersuite>::Group::serialize(&element2());
let hiding_nonce_commitment = NonceCommitment::from_bytes(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::from_bytes(serialized_element2).unwrap();
let hiding_nonce_commitment = NonceCommitment::deserialize(serialized_element1).unwrap();
let binding_nonce_commitment = NonceCommitment::deserialize(serialized_element2).unwrap();
let identifier = 42u16.try_into().unwrap();
SigningCommitments::new(
@ -59,7 +59,7 @@ pub fn signing_package() -> SigningPackage {
pub fn signature_share() -> SignatureShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signature_response = SignatureResponse::from_bytes(serialized_scalar).unwrap();
let signature_response = SignatureResponse::deserialize(serialized_scalar).unwrap();
SignatureShare::new(identifier, signature_response)
}
@ -69,7 +69,7 @@ pub fn secret_share() -> SecretShare {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
@ -81,10 +81,10 @@ pub fn key_package() -> KeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
KeyPackage::new(identifier, signing_share, verifying_share, verifying_key)
}
@ -93,9 +93,9 @@ pub fn key_package() -> KeyPackage {
pub fn public_key_package() -> PublicKeyPackage {
let identifier = 42u16.try_into().unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_share = VerifyingShare::from_bytes(serialized_element).unwrap();
let verifying_share = VerifyingShare::deserialize(serialized_element).unwrap();
let serialized_element = <C as Ciphersuite>::Group::serialize(&element1());
let verifying_key = VerifyingKey::from_bytes(serialized_element).unwrap();
let verifying_key = VerifyingKey::deserialize(serialized_element).unwrap();
let signer_pubkeys = HashMap::from([(identifier, verifying_share)]);
PublicKeyPackage::new(signer_pubkeys, verifying_key)
@ -116,7 +116,7 @@ pub fn round1_package() -> round1::Package {
.unwrap();
let vss_commitment =
VerifiableSecretSharingCommitment::deserialize(vec![serialized_element]).unwrap();
let signature = Signature::from_bytes(serialized_signature).unwrap();
let signature = Signature::deserialize(serialized_signature).unwrap();
round1::Package::new(identifier, vss_commitment, signature)
}
@ -125,7 +125,7 @@ pub fn round1_package() -> round1::Package {
pub fn round2_package() -> round2::Package {
let identifier = 42u16.try_into().unwrap();
let serialized_scalar = <<C as Ciphersuite>::Group as Group>::Field::serialize(&scalar1());
let signing_share = SigningShare::from_bytes(serialized_scalar).unwrap();
let signing_share = SigningShare::deserialize(serialized_scalar).unwrap();
round2::Package::new(identifier, identifier, signing_share)
}