diff --git a/curve25519-dalek-derive/src/lib.rs b/curve25519-dalek-derive/src/lib.rs index 53877493e..6e5920bb5 100644 --- a/curve25519-dalek-derive/src/lib.rs +++ b/curve25519-dalek-derive/src/lib.rs @@ -110,8 +110,8 @@ pub fn unsafe_target_feature_specialize( let features: Vec<_> = attributes .lit() .value() - .split(",") - .map(|feature| feature.replace(" ", "")) + .split(',') + .map(|feature| feature.replace(' ', "")) .collect(); let name = format!("{}_{}", item_mod.ident, features.join("_")); let ident = syn::Ident::new(&name, item_mod.ident.span()); diff --git a/curve25519-dalek-derive/tests/tests.rs b/curve25519-dalek-derive/tests/tests.rs index 3f0c0d093..1516b3527 100644 --- a/curve25519-dalek-derive/tests/tests.rs +++ b/curve25519-dalek-derive/tests/tests.rs @@ -83,9 +83,7 @@ impl StructWithGenericsNoWhere { #[unsafe_target_feature("sse2")] #[allow(dead_code)] impl<'a> From<&'a Struct> for () { - fn from(_: &'a Struct) -> Self { - () - } + fn from(_: &'a Struct) -> Self {} } #[unsafe_target_feature("sse2")] @@ -97,8 +95,6 @@ mod inner { #[unsafe_target_feature_specialize("sse2", "avx2", conditional("avx512ifma", disabled))] mod inner_spec { - use std; - #[for_target_feature("sse2")] const CONST: u32 = 1; diff --git a/curve25519-dalek/benches/dalek_benchmarks.rs b/curve25519-dalek/benches/dalek_benchmarks.rs index 9148faafe..62a6280f4 100644 --- a/curve25519-dalek/benches/dalek_benchmarks.rs +++ b/curve25519-dalek/benches/dalek_benchmarks.rs @@ -147,14 +147,14 @@ mod multiscalar_benches { let static_size = total_size; let static_points = construct_points(static_size); - let precomp = VartimeEdwardsPrecomputation::new(&static_points); + let precomp = VartimeEdwardsPrecomputation::new(static_points); // Rerandomize the scalars for every call to prevent // false timings from better caching (e.g., the CPU // cache lifts exactly the right table entries for the // benchmark into the highest cache levels). b.iter_batched( || construct_scalars(static_size), - |scalars| precomp.vartime_multiscalar_mul(&scalars), + |scalars| precomp.vartime_multiscalar_mul(scalars), BatchSize::SmallInput, ); }, @@ -182,7 +182,7 @@ mod multiscalar_benches { let static_points = construct_points(static_size); let dynamic_points = construct_points(dynamic_size); - let precomp = VartimeEdwardsPrecomputation::new(&static_points); + let precomp = VartimeEdwardsPrecomputation::new(static_points); // Rerandomize the scalars for every call to prevent // false timings from better caching (e.g., the CPU // cache lifts exactly the right table entries for the diff --git a/curve25519-dalek/src/edwards.rs b/curve25519-dalek/src/edwards.rs index b52a58862..2f449eaee 100644 --- a/curve25519-dalek/src/edwards.rs +++ b/curve25519-dalek/src/edwards.rs @@ -276,6 +276,7 @@ impl<'de> Deserialize<'de> for EdwardsPoint { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? @@ -311,6 +312,7 @@ impl<'de> Deserialize<'de> for CompressedEdwardsY { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? diff --git a/curve25519-dalek/src/ristretto.rs b/curve25519-dalek/src/ristretto.rs index 03fa343f9..748b4dd4a 100644 --- a/curve25519-dalek/src/ristretto.rs +++ b/curve25519-dalek/src/ristretto.rs @@ -388,6 +388,7 @@ impl<'de> Deserialize<'de> for RistrettoPoint { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? @@ -423,6 +424,7 @@ impl<'de> Deserialize<'de> for CompressedRistretto { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? @@ -970,7 +972,7 @@ impl VartimeMultiscalarMul for RistrettoPoint { I::Item: Borrow, J: IntoIterator>, { - let extended_points = points.into_iter().map(|opt_P| opt_P.map(|P| P.borrow().0)); + let extended_points = points.into_iter().map(|opt_P| opt_P.map(|P| P.0)); EdwardsPoint::optional_multiscalar_mul(scalars, extended_points).map(RistrettoPoint) } @@ -1270,7 +1272,7 @@ mod test { let bp_compressed_ristretto = constants::RISTRETTO_BASEPOINT_POINT.compress(); let bp_recaf = bp_compressed_ristretto.decompress().unwrap().0; // Check that bp_recaf differs from bp by a point of order 4 - let diff = &constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf; + let diff = constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf; let diff4 = diff.mul_by_pow_2(2); assert_eq!(diff4.compress(), CompressedEdwardsY::identity()); } @@ -1681,7 +1683,7 @@ mod test { ]; // Check that onewaymap(input) == output for all the above vectors for (input, output) in test_vectors { - let Q = RistrettoPoint::from_uniform_bytes(&input); + let Q = RistrettoPoint::from_uniform_bytes(input); assert_eq!(&Q.compress(), output); } } diff --git a/curve25519-dalek/src/scalar.rs b/curve25519-dalek/src/scalar.rs index 6634c88fc..468a55281 100644 --- a/curve25519-dalek/src/scalar.rs +++ b/curve25519-dalek/src/scalar.rs @@ -436,13 +436,14 @@ impl<'de> Deserialize<'de> for Scalar { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? .ok_or_else(|| serde::de::Error::invalid_length(i, &"expected 32 bytes"))?; } Option::from(Scalar::from_canonical_bytes(bytes)) - .ok_or_else(|| serde::de::Error::custom(&"scalar was not canonically encoded")) + .ok_or_else(|| serde::de::Error::custom("scalar was not canonically encoded")) } } @@ -1475,13 +1476,13 @@ pub(crate) mod test { #[cfg(feature = "alloc")] fn impl_product() { // Test that product works for non-empty iterators - let X_Y_vector = vec![X, Y]; + let X_Y_vector = [X, Y]; let should_be_X_times_Y: Scalar = X_Y_vector.iter().product(); assert_eq!(should_be_X_times_Y, X_TIMES_Y); // Test that product works for the empty iterator let one = Scalar::ONE; - let empty_vector = vec![]; + let empty_vector = []; let should_be_one: Scalar = empty_vector.iter().product(); assert_eq!(should_be_one, one); @@ -1506,13 +1507,13 @@ pub(crate) mod test { fn impl_sum() { // Test that sum works for non-empty iterators let two = Scalar::from(2u64); - let one_vector = vec![Scalar::ONE, Scalar::ONE]; + let one_vector = [Scalar::ONE, Scalar::ONE]; let should_be_two: Scalar = one_vector.iter().sum(); assert_eq!(should_be_two, two); // Test that sum works for the empty iterator let zero = Scalar::ZERO; - let empty_vector = vec![]; + let empty_vector = []; let should_be_zero: Scalar = empty_vector.iter().sum(); assert_eq!(should_be_zero, zero); diff --git a/ed25519-dalek/benches/ed25519_benchmarks.rs b/ed25519-dalek/benches/ed25519_benchmarks.rs index 7c9685337..efa419ceb 100644 --- a/ed25519-dalek/benches/ed25519_benchmarks.rs +++ b/ed25519-dalek/benches/ed25519_benchmarks.rs @@ -64,8 +64,7 @@ mod ed25519_benches { .collect(); let msg: &[u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; let messages: Vec<&[u8]> = (0..size).map(|_| msg).collect(); - let signatures: Vec = - keypairs.iter().map(|key| key.sign(&msg)).collect(); + let signatures: Vec = keypairs.iter().map(|key| key.sign(msg)).collect(); let verifying_keys: Vec<_> = keypairs.iter().map(|key| key.verifying_key()).collect(); diff --git a/ed25519-dalek/src/batch.rs b/ed25519-dalek/src/batch.rs index d5d174643..ed2618d6c 100644 --- a/ed25519-dalek/src/batch.rs +++ b/ed25519-dalek/src/batch.rs @@ -176,7 +176,7 @@ pub fn verify_batch( let mut h: Sha512 = Sha512::default(); h.update(signatures[i].r_bytes()); h.update(verifying_keys[i].as_bytes()); - h.update(&messages[i]); + h.update(messages[i]); *h.finalize().as_ref() }) .collect(); diff --git a/ed25519-dalek/src/context.rs b/ed25519-dalek/src/context.rs index afc64377c..2a27edd9d 100644 --- a/ed25519-dalek/src/context.rs +++ b/ed25519-dalek/src/context.rs @@ -80,6 +80,8 @@ impl<'k, 'v, K> Context<'k, 'v, K> { #[cfg(all(test, feature = "digest"))] mod test { + #![allow(clippy::unwrap_used)] + use crate::{Signature, SigningKey, VerifyingKey}; use curve25519_dalek::digest::Digest; use ed25519::signature::{DigestSigner, DigestVerifier}; diff --git a/ed25519-dalek/src/hazmat.rs b/ed25519-dalek/src/hazmat.rs index d8c16ab87..784961304 100644 --- a/ed25519-dalek/src/hazmat.rs +++ b/ed25519-dalek/src/hazmat.rs @@ -156,11 +156,11 @@ where /// [rfc8032]: https://tools.ietf.org/html/rfc8032#section-5.1 #[cfg(feature = "digest")] #[allow(non_snake_case)] -pub fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>( +pub fn raw_sign_prehashed( esk: &ExpandedSecretKey, prehashed_message: MsgDigest, verifying_key: &VerifyingKey, - context: Option<&'a [u8]>, + context: Option<&[u8]>, ) -> Result where MsgDigest: Digest, @@ -204,6 +204,8 @@ where #[cfg(test)] mod test { + #![allow(clippy::unwrap_used)] + use super::*; use rand::{rngs::OsRng, CryptoRng, RngCore}; @@ -226,8 +228,8 @@ mod test { #[test] fn sign_verify_nonspec() { // Generate the keypair - let mut rng = OsRng; - let esk = ExpandedSecretKey::random(&mut rng); + let rng = OsRng; + let esk = ExpandedSecretKey::random(rng); let vk = VerifyingKey::from(&esk); let msg = b"Then one day, a piano fell on my head"; @@ -245,8 +247,8 @@ mod test { use curve25519_dalek::digest::Digest; // Generate the keypair - let mut rng = OsRng; - let esk = ExpandedSecretKey::random(&mut rng); + let rng = OsRng; + let esk = ExpandedSecretKey::random(rng); let vk = VerifyingKey::from(&esk); // Hash the message diff --git a/ed25519-dalek/src/signing.rs b/ed25519-dalek/src/signing.rs index 4e95ee359..92c9a86e8 100644 --- a/ed25519-dalek/src/signing.rs +++ b/ed25519-dalek/src/signing.rs @@ -685,7 +685,7 @@ impl<'d> Deserialize<'d> for SigningKey { self, bytes: &'de [u8], ) -> Result { - SigningKey::try_from(bytes.as_ref()).map_err(E::custom) + SigningKey::try_from(bytes).map_err(E::custom) } fn visit_seq(self, mut seq: A) -> Result @@ -693,6 +693,7 @@ impl<'d> Deserialize<'d> for SigningKey { A: serde::de::SeqAccess<'de>, { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? @@ -782,11 +783,11 @@ impl ExpandedSecretKey { #[cfg(feature = "digest")] #[allow(non_snake_case)] #[inline(always)] - pub(crate) fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>( + pub(crate) fn raw_sign_prehashed( &self, prehashed_message: MsgDigest, verifying_key: &VerifyingKey, - context: Option<&'a [u8]>, + context: Option<&[u8]>, ) -> Result where CtxDigest: Digest, diff --git a/ed25519-dalek/src/verifying.rs b/ed25519-dalek/src/verifying.rs index e86499cf4..29f8a4d14 100644 --- a/ed25519-dalek/src/verifying.rs +++ b/ed25519-dalek/src/verifying.rs @@ -640,7 +640,7 @@ impl<'d> Deserialize<'d> for VerifyingKey { self, bytes: &'de [u8], ) -> Result { - VerifyingKey::try_from(bytes.as_ref()).map_err(E::custom) + VerifyingKey::try_from(bytes).map_err(E::custom) } fn visit_seq(self, mut seq: A) -> Result @@ -649,6 +649,7 @@ impl<'d> Deserialize<'d> for VerifyingKey { { let mut bytes = [0u8; 32]; + #[allow(clippy::needless_range_loop)] for i in 0..32 { bytes[i] = seq .next_element()? diff --git a/ed25519-dalek/tests/ed25519.rs b/ed25519-dalek/tests/ed25519.rs index d275778a4..c05efa3c3 100644 --- a/ed25519-dalek/tests/ed25519.rs +++ b/ed25519-dalek/tests/ed25519.rs @@ -9,7 +9,7 @@ //! Integration tests for ed25519-dalek. -use curve25519_dalek; +#![allow(clippy::items_after_test_module)] use ed25519_dalek::*; @@ -63,10 +63,10 @@ mod vectors { let parts: Vec<&str> = line.split(':').collect(); assert_eq!(parts.len(), 5, "wrong number of fields in line {}", lineno); - let sec_bytes: Vec = FromHex::from_hex(&parts[0]).unwrap(); - let pub_bytes: Vec = FromHex::from_hex(&parts[1]).unwrap(); - let msg_bytes: Vec = FromHex::from_hex(&parts[2]).unwrap(); - let sig_bytes: Vec = FromHex::from_hex(&parts[3]).unwrap(); + let sec_bytes: Vec = FromHex::from_hex(parts[0]).unwrap(); + let pub_bytes: Vec = FromHex::from_hex(parts[1]).unwrap(); + let msg_bytes: Vec = FromHex::from_hex(parts[2]).unwrap(); + let sig_bytes: Vec = FromHex::from_hex(parts[3]).unwrap(); let sec_bytes = &sec_bytes[..SECRET_KEY_LENGTH].try_into().unwrap(); let pub_bytes = &pub_bytes[..PUBLIC_KEY_LENGTH].try_into().unwrap(); @@ -161,13 +161,13 @@ mod vectors { let mut h = Sha512::default(); if let Some(c) = context { h.update(b"SigEd25519 no Ed25519 collisions"); - h.update(&[1]); - h.update(&[c.len() as u8]); + h.update([1]); + h.update([c.len() as u8]); h.update(c); } - h.update(&signature_r.compress().as_bytes()); + h.update(signature_r.compress().as_bytes()); h.update(&pub_key.compress().as_bytes()[..]); - h.update(&message); + h.update(message); Scalar::from_hash(h) } @@ -223,7 +223,7 @@ mod vectors { // = R + H(R || A || M₂) · A // Check that this is true let signature = serialize_signature(&r, &s); - let vk = VerifyingKey::from_bytes(&pubkey.compress().as_bytes()).unwrap(); + let vk = VerifyingKey::from_bytes(pubkey.compress().as_bytes()).unwrap(); let sig = Signature::try_from(&signature[..]).unwrap(); assert!(vk.verify(message1, &sig).is_ok()); assert!(vk.verify(message2, &sig).is_ok()); @@ -265,7 +265,7 @@ mod vectors { // Check that verify_prehashed succeeds on both sigs let signature = serialize_signature(&r, &s); - let vk = VerifyingKey::from_bytes(&pubkey.compress().as_bytes()).unwrap(); + let vk = VerifyingKey::from_bytes(pubkey.compress().as_bytes()).unwrap(); let sig = Signature::try_from(&signature[..]).unwrap(); assert!(vk .verify_prehashed(message1.clone(), context_str, &sig) @@ -295,45 +295,42 @@ mod integrations { #[test] fn sign_verify() { // TestSignVerify - let signing_key: SigningKey; - let good_sig: Signature; - let bad_sig: Signature; let good: &[u8] = "test message".as_bytes(); let bad: &[u8] = "wrong message".as_bytes(); let mut csprng = OsRng; - signing_key = SigningKey::generate(&mut csprng); + let signing_key: SigningKey = SigningKey::generate(&mut csprng); let verifying_key = signing_key.verifying_key(); - good_sig = signing_key.sign(&good); - bad_sig = signing_key.sign(&bad); + let good_sig: Signature = signing_key.sign(good); + let bad_sig: Signature = signing_key.sign(bad); // Check that an honestly generated public key is not weak assert!(!verifying_key.is_weak()); assert!( - signing_key.verify(&good, &good_sig).is_ok(), + signing_key.verify(good, &good_sig).is_ok(), "Verification of a valid signature failed!" ); assert!( - verifying_key.verify_strict(&good, &good_sig).is_ok(), + verifying_key.verify_strict(good, &good_sig).is_ok(), "Strict verification of a valid signature failed!" ); assert!( - signing_key.verify(&good, &bad_sig).is_err(), + signing_key.verify(good, &bad_sig).is_err(), "Verification of a signature on a different message passed!" ); assert!( - verifying_key.verify_strict(&good, &bad_sig).is_err(), + verifying_key.verify_strict(good, &bad_sig).is_err(), "Strict verification of a signature on a different message passed!" ); assert!( - signing_key.verify(&bad, &good_sig).is_err(), + signing_key.verify(bad, &good_sig).is_err(), "Verification of a signature on a different message passed!" ); assert!( - verifying_key.verify_strict(&bad, &good_sig).is_err(), + verifying_key.verify_strict(bad, &good_sig).is_err(), "Strict verification of a signature on a different message passed!" ); } @@ -341,10 +338,6 @@ mod integrations { #[cfg(feature = "digest")] #[test] fn ed25519ph_sign_verify() { - let signing_key: SigningKey; - let good_sig: Signature; - let bad_sig: Signature; - let good: &[u8] = b"test message"; let bad: &[u8] = b"wrong message"; @@ -365,12 +358,12 @@ mod integrations { let context: &[u8] = b"testing testing 1 2 3"; - signing_key = SigningKey::generate(&mut csprng); + let signing_key: SigningKey = SigningKey::generate(&mut csprng); let verifying_key = signing_key.verifying_key(); - good_sig = signing_key + let good_sig: Signature = signing_key .sign_prehashed(prehashed_good1, Some(context)) .unwrap(); - bad_sig = signing_key + let bad_sig: Signature = signing_key .sign_prehashed(prehashed_bad1, Some(context)) .unwrap(); @@ -427,9 +420,9 @@ mod integrations { let mut signing_keys: Vec = Vec::new(); let mut signatures: Vec = Vec::new(); - for i in 0..messages.len() { + for msg in messages { let signing_key: SigningKey = SigningKey::generate(&mut csprng); - signatures.push(signing_key.sign(&messages[i])); + signatures.push(signing_key.sign(msg)); signing_keys.push(signing_key); } let verifying_keys: Vec = @@ -477,6 +470,8 @@ struct Demo { #[cfg(all(test, feature = "serde"))] mod serialisation { + #![allow(clippy::zero_prefixed_literal)] + use super::*; // The size for bincode to serialize the length of a byte array. @@ -547,7 +542,7 @@ mod serialisation { // derived from `serialize_deserialize_verifying_key_json` test // trailing zero elements makes key too long (34 bytes) let encoded_verifying_key_too_long = "[130,39,155,15,62,76,188,63,124,122,26,251,233,253,225,220,14,41,166,120,108,35,254,77,160,83,172,58,219,42,86,120,0,0]"; - let de_err = serde_json::from_str::(&encoded_verifying_key_too_long) + let de_err = serde_json::from_str::(encoded_verifying_key_too_long) .unwrap_err() .to_string(); assert!( @@ -560,7 +555,7 @@ mod serialisation { fn serialize_deserialize_verifying_key_json_too_short() { // derived from `serialize_deserialize_verifying_key_json` test let encoded_verifying_key_too_long = "[130,39,155,15]"; - let de_err = serde_json::from_str::(&encoded_verifying_key_too_long) + let de_err = serde_json::from_str::(encoded_verifying_key_too_long) .unwrap_err() .to_string(); assert!( @@ -575,6 +570,7 @@ mod serialisation { let encoded_signing_key: Vec = bincode::serialize(&signing_key).unwrap(); let decoded_signing_key: SigningKey = bincode::deserialize(&encoded_signing_key).unwrap(); + #[allow(clippy::needless_range_loop)] for i in 0..SECRET_KEY_LENGTH { assert_eq!(SECRET_KEY_BYTES[i], decoded_signing_key.to_bytes()[i]); } @@ -586,6 +582,7 @@ mod serialisation { let encoded_signing_key = serde_json::to_string(&signing_key).unwrap(); let decoded_signing_key: SigningKey = serde_json::from_str(&encoded_signing_key).unwrap(); + #[allow(clippy::needless_range_loop)] for i in 0..SECRET_KEY_LENGTH { assert_eq!(SECRET_KEY_BYTES[i], decoded_signing_key.to_bytes()[i]); } @@ -596,7 +593,7 @@ mod serialisation { // derived from `serialize_deserialize_signing_key_json` test // trailing zero elements makes key too long (34 bytes) let encoded_signing_key_too_long = "[62,70,27,163,92,182,11,3,77,234,98,4,11,127,79,228,243,187,150,73,201,137,76,22,85,251,152,2,241,42,72,54,0,0]"; - let de_err = serde_json::from_str::(&encoded_signing_key_too_long) + let de_err = serde_json::from_str::(encoded_signing_key_too_long) .unwrap_err() .to_string(); assert!( @@ -609,7 +606,7 @@ mod serialisation { fn serialize_deserialize_signing_key_json_too_short() { // derived from `serialize_deserialize_signing_key_json` test let encoded_signing_key_too_long = "[62,70,27,163]"; - let de_err = serde_json::from_str::(&encoded_signing_key_too_long) + let de_err = serde_json::from_str::(encoded_signing_key_too_long) .unwrap_err() .to_string(); assert!( diff --git a/ed25519-dalek/tests/validation_criteria.rs b/ed25519-dalek/tests/validation_criteria.rs index b7ae83874..fc5b8a5ab 100644 --- a/ed25519-dalek/tests/validation_criteria.rs +++ b/ed25519-dalek/tests/validation_criteria.rs @@ -89,7 +89,7 @@ impl From for TestVector { let msg = tv.msg.as_bytes().to_vec(); // Unwrap the Option> - let flags = tv.flags.unwrap_or_else(Default::default); + let flags = tv.flags.unwrap_or_default(); Self { number, diff --git a/x25519-dalek/src/x25519.rs b/x25519-dalek/src/x25519.rs index e1c79d44a..3b96f9cf0 100644 --- a/x25519-dalek/src/x25519.rs +++ b/x25519-dalek/src/x25519.rs @@ -101,7 +101,7 @@ impl EphemeralSecret { /// Generate a new [`EphemeralSecret`]. #[cfg(feature = "getrandom")] pub fn random() -> Self { - Self::random_from_rng(&mut rand_core::OsRng) + Self::random_from_rng(rand_core::OsRng) } } @@ -164,7 +164,7 @@ impl ReusableSecret { /// Generate a new [`ReusableSecret`]. #[cfg(feature = "getrandom")] pub fn random() -> Self { - Self::random_from_rng(&mut rand_core::OsRng) + Self::random_from_rng(rand_core::OsRng) } } @@ -225,7 +225,7 @@ impl StaticSecret { /// Generate a new [`StaticSecret`]. #[cfg(feature = "getrandom")] pub fn random() -> Self { - Self::random_from_rng(&mut rand_core::OsRng) + Self::random_from_rng(rand_core::OsRng) } /// Extract this key's bytes for serialization.