Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "minidisc"
-version = "0.1.3"
+version = "0.1.2"
 edition = "2021"
 homepage = "https://github.com/G2-Games/minidisc-rs/"
 repository = "https://github.com/G2-Games/minidisc-rs/"
@@ -37,7 +37,7 @@ nofmt = "1.0.0"
 once_cell = "1.18.0"
 unicode-normalization = "0.1.22"
 regex = "1.10"
-cross_usb = "0.4"
+cross_usb = "0.3"
 num-derive = "0.4.2"
 num-traits = "0.2.14"
 rand = "0.8.5"

src/netmd/base.rs

@@ -6,7 +6,7 @@ use thiserror::Error;
 
 // USB stuff
 use cross_usb::prelude::*;
-use cross_usb::usb::{ControlIn, ControlOut, ControlType, Recipient, Error};
+use cross_usb::usb::{ControlIn, ControlOut, ControlType, Recipient, UsbError};
 use cross_usb::{DeviceInfo, Interface};
 
 use super::utils::cross_sleep;
@@ -114,7 +114,7 @@ pub enum NetMDError {
     UnknownDevice(DeviceId),
 
     #[error("usb connection error")]
-    UsbError(#[from] Error),
+    UsbError(#[from] UsbError),
 }
 
 /// A low-level USB connection to a NetMD device.

src/netmd/commands.rs

@@ -549,6 +549,7 @@ impl NetMDContext {
     /// # tokio_test::block_on(async {
     /// use minidisc::netmd::DEVICE_IDS_CROSSUSB;
     /// use minidisc::netmd::NetMDContext;
+    /// use minidisc::netmd::encryption::new_thread_encryptor;
     /// use minidisc::netmd::interface::{MDTrack, NetMDInterface};
     ///
     /// // Get the minidisc device from cross_usb
@@ -570,6 +571,7 @@ impl NetMDContext {
     ///     format: minidisc::netmd::interface::WireFormat::LP2,
     ///     full_width_title: None,
     ///     data: track_contents,
+    ///     encrypt_packets_iterator: Box::new(new_thread_encryptor),
     /// };
     ///
     /// // Download it to the player!

src/netmd/encryption.rs

@@ -9,27 +9,11 @@ use super::interface::DataEncryptorInput;
 type DesEcbEnc = ecb::Decryptor<des::Des>;
 type DesCbcEnc = cbc::Encryptor<des::Des>;
 
-pub struct Encryptor {
-    #[allow(clippy::type_complexity)]
-    channel: Option<UnboundedReceiver<(Vec<u8>, Vec<u8>, Vec<u8>)>>,
-    state: Option<EncryptorState>,
-}
-
-struct EncryptorState {
-    input_data: Vec<u8>,
-    iv: [u8; 8],
-    random_key: [u8; 8],
-    encrypted_random_key: [u8; 8],
-    default_chunk_size: usize,
-    current_chunk_size: usize,
-    offset: usize,
-    packet_count: usize,
-    closed: bool,
-}
-
-impl Encryptor {
-    pub fn new_threaded(input: DataEncryptorInput) -> Self {
+pub fn new_thread_encryptor(
+    _input: DataEncryptorInput,
+) -> UnboundedReceiver<(Vec<u8>, Vec<u8>, Vec<u8>)> {
     let (tx, rx) = unbounded_channel::<(Vec<u8>, Vec<u8>, Vec<u8>)>();
+    let input = Box::from(_input);
 
     thread::spawn(move || {
         let mut iv = [0u8; 8];
@@ -90,108 +74,5 @@ impl Encryptor {
         }
     });
 
-        Self {
-            channel: Some(rx),
-            state: None
-        }
-    }
-
-    pub fn new(input: DataEncryptorInput) -> Self {
-        let iv = [0u8; 8];
-
-        // Create the random key
-        let mut random_key = [0u8; 8];
-        rand::thread_rng().fill_bytes(&mut random_key);
-
-        // Encrypt it with the kek
-        let mut encrypted_random_key = random_key;
-        if let Err(x) = DesEcbEnc::new(&input.kek.into())
-            .decrypt_padded_mut::<NoPadding>(&mut encrypted_random_key)
-        {
-            panic!("Cannot create main key {:?}", x)
-        };
-
-        let default_chunk_size = match input.chunk_size {
-            0 => 0x00100000,
-            e => e,
-        };
-
-        let packet_count = 0;
-        let current_chunk_size = 0;
-
-        let mut input_data = input.data.clone();
-        if (input_data.len() % input.frame_size) != 0 {
-            let padding_remaining = input.frame_size - (input_data.len() % input.frame_size);
-            input_data.extend(std::iter::repeat(0).take(padding_remaining));
-        }
-
-        let offset: usize = 0;
-
-        Encryptor {
-            channel: None,
-            state: Some(EncryptorState {
-                input_data,
-                iv,
-                random_key,
-                encrypted_random_key,
-                current_chunk_size,
-                offset,
-                default_chunk_size,
-                packet_count,
-                closed: false,
-            })
-        }
-    }
-
-    /// Get the next encrypted value
-    pub async fn next(&mut self) -> Option<(Vec<u8>, Vec<u8>, Vec<u8>)> {
-        let output;
-
-        if let Some(state) = self.state.as_mut() {
-            if state.closed {
-                return None
-            }
-
-            if state.packet_count > 0 {
-                state.current_chunk_size = state.default_chunk_size;
-            } else {
-                state.current_chunk_size = state.default_chunk_size - 24;
-            }
-
-            state.current_chunk_size = std::cmp::min(state.current_chunk_size, state.input_data.len() - state.offset);
-
-            let this_data_chunk = &mut state.input_data[state.offset..state.offset + state.current_chunk_size];
-            DesCbcEnc::new(&state.random_key.into(), &state.iv.into())
-                .encrypt_padded_mut::<NoPadding>(this_data_chunk, state.current_chunk_size)
-                .unwrap();
-
-            output = Some((
-                state.encrypted_random_key.to_vec(),
-                state.iv.to_vec(),
-                this_data_chunk.to_vec(),
-            ));
-
-            state.iv.copy_from_slice(&this_data_chunk[this_data_chunk.len() - 8..]);
-
-            state.packet_count += 1;
-            state.offset += state.current_chunk_size;
-        } else if let Some(channel) = self.channel.as_mut() {
-            output = channel.recv().await
-        } else {
-            unreachable!("If you got here, this is bad!");
-        }
-
-        output
-    }
-
-    /// Call close to return none from subsequent calls
-    pub fn close(&mut self) {
-        if let Some(state) = self.state.as_mut() {
-            state.closed = true;
-        } else if let Some(channel) = self.channel.as_mut() {
-            channel.close()
-        } else {
-            unreachable!("If you got here, this is bad!");
-        }
-    }
+    rx
 }

src/netmd/interface.rs

@@ -15,9 +15,9 @@ use std::collections::HashMap;
 use std::error::Error;
 use std::time::Duration;
 use thiserror::Error;
+use tokio::sync::mpsc::UnboundedReceiver;
 
 use super::base::NetMD;
-use super::encryption::Encryptor;
 use super::utils::{cross_sleep, to_sjis};
 
 /// An action to take on the player
@@ -306,10 +306,7 @@ pub struct NetMDInterface {
 
 #[allow(dead_code)]
 impl NetMDInterface {
-    /// The maximum number of times to retry after an interim response
     const MAX_INTERIM_READ_ATTEMPTS: u8 = 4;
-
-    /// The amount of time to wait after an interim response (in milliseconds)
     const INTERIM_RESPONSE_RETRY_INTERVAL: u32 = 100;
 
     /// Get a new interface to a NetMD device
@@ -455,7 +452,7 @@ impl NetMDInterface {
     /// Send a query to the NetMD player
     async fn send_query(
         &mut self,
-        query: &[u8],
+        query: &Vec<u8>,
         test: bool,
         accept_interim: bool,
     ) -> Result<Vec<u8>, InterfaceError> {
@@ -468,7 +465,7 @@ impl NetMDInterface {
 
     async fn send_command(
         &mut self,
-        query: &[u8],
+        query: &Vec<u8>,
         test: bool,
     ) -> Result<(), InterfaceError> {
         let status_byte = match test {
@@ -479,7 +476,7 @@ impl NetMDInterface {
         let mut new_query = Vec::new();
 
         new_query.push(status_byte as u8);
-        new_query.extend_from_slice(query);
+        new_query.extend_from_slice(&query);
 
         self.device.send_command(new_query).await?;
 
@@ -621,6 +618,8 @@ impl NetMDInterface {
     pub async fn disc_present(&mut self) -> Result<bool, InterfaceError> {
         let status = self.status().await?;
 
+        println!("{:X?}", status);
+
         Ok(status[4] == 0x40)
     }
 
@@ -650,9 +649,11 @@ impl NetMDInterface {
         self.change_descriptor_state(&Descriptor::OperatingStatusBlock, &DescriptorAction::Close)
             .await?;
 
-        if operating_status.len() < 2 && !operating_status.is_empty() {
+        if operating_status.len() < 2 {
+            if !operating_status.is_empty() {
                 return Err(InterfaceError::InvalidStatus(StatusError(operating_status[0] as u16)));
             }
+        }
 
         let operating_status_number =
             (operating_status[0] as u16) << 8 | operating_status[1] as u16;
@@ -1040,13 +1041,11 @@ impl NetMDInterface {
             ));
         }
 
-        let mut remaining_tracks = Vec::new();
         for i in 0..track_count {
             if !track_dict.contains_key(&i) {
-                remaining_tracks.push(i);
+                result.insert(0, (None, None, Vec::from([i])))
             }
         }
-        result.insert(0, (None, None, remaining_tracks));
 
         Ok(result)
     }
@@ -1690,7 +1689,8 @@ impl NetMDInterface {
         discformat: u8,
         frames: u32,
         pkt_size: u32,
-        mut packets: Encryptor,
+        // key, iv, data
+        mut packets: UnboundedReceiver<(Vec<u8>, Vec<u8>, Vec<u8>)>,
         hex_session_key: &[u8],
         progress_callback: F,
     ) -> Result<(u16, Vec<u8>, Vec<u8>), InterfaceError>
@@ -1729,7 +1729,7 @@ impl NetMDInterface {
         let mut written_bytes = 0;
         let mut packet_count = 0;
 
-        while let Some((key, iv, data)) = packets.next().await {
+        while let Some((key, iv, data)) = packets.recv().await {
             let binpack = if packet_count == 0 {
                 let packed_length: Vec<u8> = pkt_size.to_be_bytes().to_vec();
                 [vec![0, 0, 0, 0], packed_length, key, iv, data].concat()
@@ -1862,6 +1862,10 @@ pub struct MDTrack {
     pub data: Vec<u8>,
     pub chunk_size: usize,
     pub full_width_title: Option<String>,
+
+    #[allow(clippy::type_complexity)]
+    pub encrypt_packets_iterator:
+        Box<dyn Fn(DataEncryptorInput) -> UnboundedReceiver<(Vec<u8>, Vec<u8>, Vec<u8>)>>,
 }
 
 pub struct DataEncryptorInput {
@@ -1916,19 +1920,8 @@ impl MDTrack {
         [0x14, 0xe3, 0x83, 0x4e, 0xe2, 0xd3, 0xcc, 0xa5]
     }
 
-    #[cfg(not(target_family = "wasm"))]
-    pub fn get_encrypting_iterator(&mut self) -> Encryptor {
-        Encryptor::new_threaded(DataEncryptorInput {
-            kek: self.get_kek(),
-            frame_size: self.frame_size(),
-            chunk_size: self.chunk_size(),
-            data: std::mem::take(&mut self.data),
-        })
-    }
-
-    #[cfg(target_family = "wasm")]
-    pub fn get_encrypting_iterator(&mut self) -> Encryptor {
-        Encryptor::new(DataEncryptorInput {
+    pub fn get_encrypting_iterator(&mut self) -> UnboundedReceiver<(Vec<u8>, Vec<u8>, Vec<u8>)> {
+        (self.encrypt_packets_iterator)(DataEncryptorInput {
             kek: self.get_kek(),
             frame_size: self.frame_size(),
             chunk_size: self.chunk_size(),