The cipher block chaining is not yet implemented

base-station/software/src/radio.rs

     loop {
         sleep(Duration::from_millis(1));
         if let Some(pipe) = nrf24.can_read().unwrap() {
-            let payload = nrf24.read().unwrap();
+            let mut payload = nrf24.read().unwrap();
             info!(
                 "packet received on pipe {}: {:x?}, {}",
                 pipe,
                 continue;
             }
 
-            let sensor_id = payload.as_ref()[0];
-            let remainder_of_salt = payload.as_ref()[1..7].to_vec();
+            let mut payload = payload.as_ref().to_vec();
+
+            let sensor_id = payload[0];
+            let salt = payload[0..8].to_vec();
+
+            // Decrypt the package
+            let key = [
+                0x9e, 0x37, 0x79, 0xb9, 0x9b, 0x97, 0x73, 0xe9, 0xb9, 0x79, 0x37, 0x9e, 0x6b, 0x69,
+                0x51, 0x56,
+            ]; //TODO: define somewhere else
+            decrypt(&key, &mut payload.as_mut_slice()[8..32]);
+
+            info!("decrypted: {:x?}", payload);
+            let mut current_c
+            while (
+            {
+                
+            }
 
             // Calculate the CRC
-            let crc_calculation_buffer = payload.as_ref()[8..30].to_vec();
+            let crc_calculation_buffer = payload[8..30].to_vec();
             let calculated_crc = State::<KERMIT>::calculate(&crc_calculation_buffer);
             info!("calculated crc: 0x{:x}", calculated_crc);
-            let crc = u16::from_le_bytes(payload.as_ref()[30..32].try_into().unwrap());
+            let crc = u16::from_le_bytes(payload[30..32].try_into().unwrap());
 
             if crc != calculated_crc {
                 info!("malformed packet received: crc mismatch!");
                 continue;
             }
 
-            let packet_identifier = payload.as_ref()[8];
-            let packet_payload = &payload.as_ref()[9..29];
+            let packet_identifier = payload[8];
+            let packet_payload = &payload[9..30];
             info!("sensor id: 0x{:x}", sensor_id);
             info!("crc: 0x{:x}", crc);
 
             let packet_type = packet_identifier & 0x1F;
             let element_count = (packet_identifier & 0xE0) >> 5;
-            info!("packet_type: 0x{:x}", packet_type);
-            info!("element_count: 0x{:x}", element_count);
 
             let mut temperature = 0;
             let mut pressure = 0;
                 let mut i = 0;
                 let mut buffer_position = 0;
                 info!("report packet received");
-                info!("packet_payload: {:x?}", packet_payload.as_ref());
                 while i < element_count {
                     let value_type = packet_payload[buffer_position];
 
                                 .try_into()
                                 .unwrap(),
                         );
-                        info!(
-                            "temp: {:x?}, {:x}",
-                            packet_payload[buffer_position..buffer_position + 2].to_vec(),
-                            temperature
-                        );
                         buffer_position += 2;
                     } else if value_type == 2 {
                         pressure = u32::from_le_bytes(
                                 .try_into()
                                 .unwrap(),
                         );
-                        info!(
-                            "pressure: {:x?}, {:x}",
-                            packet_payload[buffer_position..buffer_position + 4].to_vec(),
-                            pressure
-                        );
                         buffer_position += 4;
                     } else if value_type == 3 {
                         humidity = u16::from_le_bytes(
                                 .try_into()
                                 .unwrap(),
                         );
-                        info!(
-                            "humidity: {:x?}, {:x}",
-                            packet_payload[buffer_position..buffer_position + 2].to_vec(),
-                            humidity
-                        );
                         buffer_position += 2;
                     } else {
                         info!("unknown value type");
                 continue;
             }
 
-            if humidity > 1000 {
+            if humidity > 10000 {
                 info!("humidity outside of range: {}", humidity);
                 continue;
             }
 
             let pressure = pressure as f32 / 100.0;
             let temperature = temperature as f32 / 10.0;
-            let humidity = humidity as f32 / 102.4;
+            let humidity = humidity as f32 / 100.0;
             info!("pressure: {} HPa", pressure);
             info!("temperature: {} °C", temperature);
             info!("humidity: {}%", humidity);