diff --git a/umskt/src/confid/black_box.rs b/umskt/src/confid/black_box.rs
index c70763e..3ef8aeb 100644
--- a/umskt/src/confid/black_box.rs
+++ b/umskt/src/confid/black_box.rs
@@ -1,4 +1,8 @@
-use std::{ffi::c_void, mem::swap, ptr};
+use std::{
+    ffi::c_void,
+    mem::{size_of, swap},
+    ptr,
+};
 
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -787,7 +791,7 @@ fn sha1_single_block(input: &[u8], output: &mut [u8]) {
     output[19] = e as u8;
 }
 
-unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
+fn mix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) {
     let mut sha1_input: [u8; 64] = [0; 64];
     let mut sha1_result: [u8; 20] = [0; 20];
     let half: usize = buf_size.wrapping_div(2);
@@ -796,18 +800,12 @@ unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize)
         for n in &mut sha1_input {
             *n = 0;
         }
-        ptr::copy_nonoverlapping(buffer.add(half), sha1_input.as_mut_ptr(), half);
-        ptr::copy_nonoverlapping(
-            key as *const c_void,
-            sha1_input.as_mut_ptr().add(half) as *mut c_void,
-            key_size,
-        );
+        sha1_input[..half].copy_from_slice(&buffer[half..]);
+        sha1_input[half..half.wrapping_add(key_size)].copy_from_slice(key);
         sha1_input[half.wrapping_add(key_size)] = 0x80_i32 as u8;
-        sha1_input
-            [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
+        sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
             half.wrapping_add(key_size).wrapping_mul(8) as u8;
-        sha1_input
-            [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
+        sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
             half.wrapping_add(key_size)
                 .wrapping_mul(8)
                 .wrapping_div(0x100) as u8;
@@ -819,17 +817,16 @@ unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize)
         }
         i = 0_i32 as usize;
         while i < half {
-            let tmp: u8 = *buffer.add(i.wrapping_add(half));
-            *buffer.add(i.wrapping_add(half)) =
-                (*buffer.add(i) as i32 ^ sha1_result[i] as i32) as u8;
-            *buffer.add(i) = tmp;
+            let tmp: u8 = buffer[i.wrapping_add(half)];
+            buffer[i.wrapping_add(half)] = (buffer[i] as i32 ^ sha1_result[i] as i32) as u8;
+            buffer[i] = tmp;
             i = i.wrapping_add(1);
         }
         external_counter += 1;
     }
 }
 
-unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usize) {
+fn unmix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) {
     let mut sha1_input: [u8; 64] = [0; 64];
     let mut sha1_result: [u8; 20] = [0; 20];
     let half: usize = buf_size.wrapping_div(2);
@@ -838,14 +835,12 @@ unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usiz
         for n in &mut sha1_input {
             *n = 0;
         }
-        ptr::copy_nonoverlapping(buffer, sha1_input.as_mut_ptr(), half);
-        ptr::copy_nonoverlapping(key, sha1_input.as_mut_ptr().add(half), key_size);
+        sha1_input[..half].copy_from_slice(&buffer[..half]);
+        sha1_input[half..half.wrapping_add(key_size)].copy_from_slice(key);
         sha1_input[half.wrapping_add(key_size)] = 0x80_i32 as u8;
-        sha1_input
-            [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
+        sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
             half.wrapping_add(key_size).wrapping_mul(8) as u8;
-        sha1_input
-            [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
+        sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
             half.wrapping_add(key_size)
                 .wrapping_mul(8)
                 .wrapping_div(0x100) as u8;
@@ -857,10 +852,9 @@ unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const u8, key_size: usiz
         }
         i = 0_i32 as usize;
         while i < half {
-            let tmp: u8 = *buffer.add(i);
-            *buffer.add(i) =
-                (*buffer.add(i.wrapping_add(half)) as i32 ^ sha1_result[i] as i32) as u8;
-            *buffer.add(i.wrapping_add(half)) = tmp;
+            let tmp: u8 = buffer[i];
+            buffer[i] = (buffer[i.wrapping_add(half)] as i32 ^ sha1_result[i] as i32) as u8;
+            buffer[i.wrapping_add(half)] = tmp;
             i = i.wrapping_add(1);
         }
         external_counter += 1;
@@ -922,7 +916,7 @@ pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8)
     if total_count != 41 && total_count < 45 {
         return 1_i32;
     }
-    while installation_id_len < ::std::mem::size_of::<[u8; 19]>() {
+    while installation_id_len < size_of::<[u8; 19]>() {
         installation_id[installation_id_len] = 0_i32 as u8;
         installation_id_len = installation_id_len.wrapping_add(1);
     }
@@ -933,9 +927,9 @@ pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         0xd4_i32 as u8,
     ];
     unmix(
-        installation_id.as_mut_ptr(),
+        &mut installation_id,
         (if total_count == 41 { 17_i32 } else { 19_i32 }) as usize,
-        IID_KEY.as_ptr(),
+        &IID_KEY,
         4_i32 as usize,
     );
     if installation_id[18_i32 as usize] as i32 >= 0x10_i32 {
@@ -950,7 +944,7 @@ pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8)
     ptr::copy_nonoverlapping(
         installation_id.as_mut_ptr() as *const c_void,
         &mut parsed as *mut C2RustUnnamed4 as *mut c_void,
-        std::mem::size_of::<C2RustUnnamed4>(),
+        size_of::<C2RustUnnamed4>(),
     );
     let product_id_1: u32 = (parsed.product_id_low & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
     let product_id_2: u32 =
@@ -989,12 +983,7 @@ pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8)
         u.c2rust_unnamed.lo = 0_i32 as u64;
         u.c2rust_unnamed.hi = 0_i32 as u64;
         u.buffer[7_i32 as usize] = attempt;
-        mix(
-            (u.buffer).as_mut_ptr(),
-            14_i32 as usize,
-            keybuf.as_mut_ptr(),
-            16_i32 as usize,
-        );
+        mix(&mut u.buffer, 14_i32 as usize, &keybuf, 16_i32 as usize);
         let mut x2: u64 = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi);
         let x1: u64 = u.c2rust_unnamed.lo.wrapping_sub(x2.wrapping_mul(MOD));
         x2 = x2.wrapping_add(1);