Extract SCALAR_SIZE and PRD_SCALAR_SIZE constants

Author: dobo90

crates/playready/src/binary_format/device.rs

@@ -2,22 +2,24 @@
 
 use binrw::{BinRead, BinWrite};
 
+pub const PRD_SCALAR_SIZE: usize = 96;
+
 #[derive(BinRead, BinWrite, Debug, Clone)]
 #[brw(big)]
 pub struct DeviceV2 {
     pub group_certificate_length: u32,
     #[br(count = group_certificate_length)]
     pub group_certificate: Vec<u8>,
-    pub encryption_key: [u8; 96],
-    pub signing_key: [u8; 96],
+    pub encryption_key: [u8; PRD_SCALAR_SIZE],
+    pub signing_key: [u8; PRD_SCALAR_SIZE],
 }
 
 #[derive(BinRead, BinWrite, Debug, Clone)]
 #[brw(big)]
 pub struct DeviceV3 {
-    pub group_key: [u8; 96],
-    pub encryption_key: [u8; 96],
-    pub signing_key: [u8; 96],
+    pub group_key: [u8; PRD_SCALAR_SIZE],
+    pub encryption_key: [u8; PRD_SCALAR_SIZE],
+    pub signing_key: [u8; PRD_SCALAR_SIZE],
     pub group_certificate_length: u32,
     #[br(count = group_certificate_length)]
     pub group_certificate: Vec<u8>,

crates/playready/src/crypto/ecc_p256.rs

@@ -14,6 +14,7 @@ pub type PublicKey = elastic_elgamal::PublicKey<Generic<NistP256>>;
 pub type SecretKey = elastic_elgamal::SecretKey<Generic<NistP256>>;
 pub type Keypair = elastic_elgamal::Keypair<Generic<NistP256>>;
 
+pub const SCALAR_SIZE: usize = 32;
 pub const SIGNATURE_SIZE: usize = 64;
 
 pub trait ToUntaggedBytes {

crates/playready/src/device.rs

@@ -1,9 +1,9 @@
 //! Creating and parsing devices.
 
 use crate::{
-    binary_format::{self},
+    binary_format::{self, device::PRD_SCALAR_SIZE},
     certificate::CertificateChain,
-    crypto::ecc_p256::{FromBytes, Keypair, ToUntaggedBytes},
+    crypto::ecc_p256::{FromBytes, Keypair, ToUntaggedBytes, SCALAR_SIZE},
 };
 use binrw::{BinRead, BinWrite};
 use p256::ecdsa::SigningKey;
@@ -50,7 +50,7 @@ impl Device {
         };
 
         let group_key = match group_key {
-            Some(group_key) => Some(SigningKey::from_slice(&group_key[..32])?),
+            Some(group_key) => Some(SigningKey::from_slice(&group_key[..SCALAR_SIZE])?),
             None => None,
         };
 
@@ -64,8 +64,8 @@ impl Device {
             binary_format::device::DeviceInner::V3(v3) => &v3.signing_key,
         };
 
-        let encryption_key = Keypair::from_bytes(&encryption_key[..32])?;
-        let signing_key = SigningKey::from_slice(&signing_key[..32])?;
+        let encryption_key = Keypair::from_bytes(&encryption_key[..SCALAR_SIZE])?;
+        let signing_key = SigningKey::from_slice(&signing_key[..SCALAR_SIZE])?;
 
         let group_certificate = match device.inner {
             binary_format::device::DeviceInner::V2(v2) => v2.group_certificate,
@@ -202,7 +202,7 @@ impl Device {
         bytes.clear();
         file.read_to_end(&mut bytes)?;
 
-        let group_key = SigningKey::from_slice(bytes.get(..32).ok_or(
+        let group_key = SigningKey::from_slice(bytes.get(..SCALAR_SIZE).ok_or(
             crate::Error::SliceOutOfBoundsError("group_key", bytes.len()),
         )?)?;
 
@@ -211,21 +211,21 @@ impl Device {
 
     /// Serializes and writes device to file specified by path.
     pub fn write_to_file(&self, path: impl AsRef<Path>) -> Result<(), crate::Error> {
-        let mut group_key = [0u8; 96];
-        let mut encryption_key = [0u8; 96];
-        let mut signing_key = [0u8; 96];
+        let mut group_key = [0u8; PRD_SCALAR_SIZE];
+        let mut encryption_key = [0u8; PRD_SCALAR_SIZE];
+        let mut signing_key = [0u8; PRD_SCALAR_SIZE];
 
-        group_key[..32].copy_from_slice(
+        group_key[..SCALAR_SIZE].copy_from_slice(
             &self
                 .group_key
                 .as_ref()
                 .ok_or(crate::Error::GroupKeyMissingError)?
                 .to_bytes(),
         );
 
-        encryption_key[..32]
+        encryption_key[..SCALAR_SIZE]
             .copy_from_slice(&self.encryption_key.secret().expose_scalar().to_repr());
-        signing_key[..32].copy_from_slice(&self.signing_key.to_bytes());
+        signing_key[..SCALAR_SIZE].copy_from_slice(&self.signing_key.to_bytes());
 
         let group_certificate = self.group_certificate().to_vec();
         let group_certificate_length = u32::try_from(group_certificate.len()).unwrap();