diff --git a/umskt/src/confid/black_box.rs b/umskt/src/confid/black_box.rs index 17351c0..688552d 100644 --- a/umskt/src/confid/black_box.rs +++ b/umskt/src/confid/black_box.rs @@ -1,26 +1,49 @@ -use std::mem::{size_of, swap}; +use std::{ffi::c_void, ptr}; #[derive(Copy, Clone)] +#[repr(C)] struct TDivisor { u: [u64; 2], v: [u64; 2], } - #[derive(Copy, Clone)] -struct Encoded { +#[repr(C)] +struct C2RustUnnamed { + encoded: [u32; 4], +} +#[derive(Copy, Clone)] +#[repr(C)] +union C2RustUnnamed0 { + c2rust_unnamed: C2RustUnnamed1, + c2rust_unnamed_0: C2RustUnnamed, +} +#[derive(Copy, Clone)] +#[repr(C)] +struct C2RustUnnamed1 { encoded_lo: u64, encoded_hi: u64, } - #[derive(Copy, Clone)] -struct ParsedInstallationId { +#[repr(C)] +struct C2RustUnnamed2 { + lo: u64, + hi: u64, +} +#[derive(Copy, Clone)] +#[repr(C)] +union C2RustUnnamed3 { + buffer: [u8; 14], + c2rust_unnamed: C2RustUnnamed2, +} +#[derive(Copy, Clone)] +#[repr(C, packed)] +struct C2RustUnnamed4 { hardware_id: u64, product_id_low: u64, product_id_high: u8, key_sha1: u16, } - -static F: [u64; 6] = [ +static mut F: [u64; 6] = [ 0, 0x21840136c85381, 0x44197b83892ad0, @@ -178,7 +201,7 @@ fn residue_sqrt(what: u64) -> u64 { x } -fn find_divisor_v(d: &mut TDivisor) -> i32 { +unsafe fn find_divisor_v(d: *mut TDivisor) -> i32 { // u | v^2 - f // u = u0 + u1*x + x^2 // f%u = f0 + f1*x @@ -189,8 +212,8 @@ fn find_divisor_v(d: &mut TDivisor) -> i32 { f2[i as usize] = F[i as usize]; i += 1; } - let u0: u64 = d.u[0_i32 as usize]; - let u1: u64 = d.u[1_i32 as usize]; + let u0: u64 = (*d).u[0_i32 as usize]; + let u1: u64 = (*d).u[1_i32 as usize]; let mut j: i32 = 4_i32; loop { let fresh0 = j; @@ -258,18 +281,18 @@ fn find_divisor_v(d: &mut TDivisor) -> i32 { residue_add(f1, residue_mul(u1, residue_mul(v1, v1))), residue_inv(residue_add(v1, v1)), ); - d.v[0_i32 as usize] = v0; - d.v[1_i32 as usize] = v1; + (*d).v[0_i32 as usize] = v0; + (*d).v[1_i32 as usize] = v1; 1_i32 } -fn polynomial_mul( +unsafe fn polynomial_mul( adeg: i32, - a: &[u64], + a: *const u64, bdeg: i32, - b: &[u64], + b: *const u64, mut resultprevdeg: i32, - result: &mut [u64], + result: *mut u64, ) -> i32 { // generic short slow code if adeg < 0_i32 || bdeg < 0_i32 { @@ -277,7 +300,7 @@ fn polynomial_mul( } let mut i = resultprevdeg + 1_i32; while i <= adeg + bdeg { - result[i as usize] = 0_i32 as u64; + *result.offset(i as isize) = 0_i32 as u64; i += 1; } resultprevdeg = i - 1_i32; @@ -285,79 +308,86 @@ fn polynomial_mul( while i <= adeg { let mut j = 0_i32; while j <= bdeg { - result[(i + j) as usize] = residue_add( - result[(i + j) as usize], - residue_mul(a[i as usize], b[j as usize]), + *result.offset((i + j) as isize) = residue_add( + *result.offset((i + j) as isize), + residue_mul(*a.offset(i as isize), *b.offset(j as isize)), ); j += 1; } i += 1; } - while resultprevdeg >= 0_i32 && result[resultprevdeg as usize] == 0_i32 as u64 { + while resultprevdeg >= 0_i32 && *result.offset(resultprevdeg as isize) == 0_i32 as u64 { resultprevdeg -= 1; } resultprevdeg } -fn polynomial_div_monic( +unsafe fn polynomial_div_monic( adeg: i32, - a: &mut [u64], + a: *mut u64, bdeg: i32, - b: &[u64], - mut quotient: Option<&mut [u64]>, + b: *const u64, + quotient: *mut u64, ) -> i32 { let mut i = adeg - bdeg; while i >= 0_i32 { - let q: u64 = a[(i + bdeg) as usize]; - if let Some(ref mut quotient) = quotient { - quotient[i as usize] = q; + let q: u64 = *a.offset((i + bdeg) as isize); + if !quotient.is_null() { + *quotient.offset(i as isize) = q; } let mut j = 0_i32; while j < bdeg { - a[(i + j) as usize] = residue_sub(a[(i + j) as usize], residue_mul(q, b[j as usize])); + *a.offset((i + j) as isize) = residue_sub( + *a.offset((i + j) as isize), + residue_mul(q, *b.offset(j as isize)), + ); j += 1; } - a[(i + j) as usize] = 0_i32 as u64; + *a.offset((i + j) as isize) = 0_i32 as u64; i -= 1; } i += bdeg; - while i >= 0_i32 && a[i as usize] == 0_i32 as u64 { + while i >= 0_i32 && *a.offset(i as isize) == 0_i32 as u64 { i -= 1; } i } #[allow(clippy::too_many_arguments)] -fn polynomial_xgcd( +unsafe fn polynomial_xgcd( adeg: i32, - a: &[u64], + a: *const u64, bdeg: i32, - b: &[u64], - pgcddeg: &mut i32, - gcd: &mut [u64], - pmult1deg: &mut i32, - mult1: &mut [u64], - pmult2deg: &mut i32, - mult2: &mut [u64], + b: *const u64, + pgcddeg: *mut i32, + gcd: *mut u64, + pmult1deg: *mut i32, + mult1: *mut u64, + pmult2deg: *mut i32, + mult2: *mut u64, ) { let mut sdeg: i32 = -1_i32; let mut s: [u64; 3] = [0_i32 as u64, 0_i32 as u64, 0_i32 as u64]; let mut mult1deg: i32 = 0_i32; - mult1[0] = 1_i32 as u64; - mult1[1] = 0_i32 as u64; - mult1[2] = 0_i32 as u64; + *mult1.offset(0_i32 as isize) = 1_i32 as u64; + *mult1.offset(1_i32 as isize) = 0_i32 as u64; + *mult1.offset(2_i32 as isize) = 0_i32 as u64; let mut tdeg: i32 = 0_i32; let mut t: [u64; 3] = [1_i32 as u64, 0_i32 as u64, 0_i32 as u64]; let mut mult2deg: i32 = -1_i32; - mult2[0] = 0_i32 as u64; - mult2[1] = 0_i32 as u64; - mult2[2] = 0_i32 as u64; + *mult2.offset(0_i32 as isize) = 0_i32 as u64; + *mult2.offset(1_i32 as isize) = 0_i32 as u64; + *mult2.offset(2_i32 as isize) = 0_i32 as u64; let mut rdeg: i32 = bdeg; - let mut r: [u64; 3] = [b[0], b[1], b[2]]; + let mut r: [u64; 3] = [ + *b.offset(0_i32 as isize), + *b.offset(1_i32 as isize), + *b.offset(2_i32 as isize), + ]; let mut gcddeg: i32 = adeg; - gcd[0] = a[0]; - gcd[1] = a[1]; - gcd[2] = a[2]; + *gcd.offset(0_i32 as isize) = *a.offset(0_i32 as isize); + *gcd.offset(1_i32 as isize) = *a.offset(1_i32 as isize); + *gcd.offset(2_i32 as isize) = *a.offset(2_i32 as isize); // s*u1 + t*u2 = r // mult1*u1 + mult2*u2 = gcd while rdeg >= 0_i32 { @@ -365,34 +395,55 @@ fn polynomial_xgcd( let tmp = rdeg as u32; rdeg = gcddeg; gcddeg = tmp as i32; - swap(&mut sdeg, &mut mult1deg); - swap(&mut tdeg, &mut mult2deg); - swap(&mut r[0], &mut gcd[0]); - swap(&mut r[1], &mut gcd[1]); - swap(&mut r[2], &mut gcd[2]); - swap(&mut s[0], &mut mult1[0]); - swap(&mut s[1], &mut mult1[1]); - swap(&mut s[2], &mut mult1[2]); - swap(&mut t[0], &mut mult2[0]); - swap(&mut t[1], &mut mult2[1]); - swap(&mut t[2], &mut mult2[2]); + std::mem::swap(&mut sdeg, &mut mult1deg); + std::mem::swap(&mut tdeg, &mut mult2deg); + let mut tmp2 = r[0_i32 as usize]; + r[0_i32 as usize] = *gcd.offset(0_i32 as isize); + *gcd.offset(0_i32 as isize) = tmp2; + tmp2 = r[1_i32 as usize]; + r[1_i32 as usize] = *gcd.offset(1_i32 as isize); + *gcd.offset(1_i32 as isize) = tmp2; + tmp2 = r[2_i32 as usize]; + r[2_i32 as usize] = *gcd.offset(2_i32 as isize); + *gcd.offset(2_i32 as isize) = tmp2; + tmp2 = s[0_i32 as usize]; + s[0_i32 as usize] = *mult1.offset(0_i32 as isize); + *mult1.offset(0_i32 as isize) = tmp2; + tmp2 = s[1_i32 as usize]; + s[1_i32 as usize] = *mult1.offset(1_i32 as isize); + *mult1.offset(1_i32 as isize) = tmp2; + tmp2 = s[2_i32 as usize]; + s[2_i32 as usize] = *mult1.offset(2_i32 as isize); + *mult1.offset(2_i32 as isize) = tmp2; + tmp2 = t[0_i32 as usize]; + t[0_i32 as usize] = *mult2.offset(0_i32 as isize); + *mult2.offset(0_i32 as isize) = tmp2; + tmp2 = t[1_i32 as usize]; + t[1_i32 as usize] = *mult2.offset(1_i32 as isize); + *mult2.offset(1_i32 as isize) = tmp2; + tmp2 = t[2_i32 as usize]; + t[2_i32 as usize] = *mult2.offset(2_i32 as isize); + *mult2.offset(2_i32 as isize) = tmp2; } else { let delta: i32 = gcddeg - rdeg; - let mult: u64 = residue_mul(gcd[gcddeg as usize], residue_inv(r[rdeg as usize])); + let mult: u64 = + residue_mul(*gcd.offset(gcddeg as isize), residue_inv(r[rdeg as usize])); // quotient = mult * x**delta let mut i: i32 = 0_i32; while i <= rdeg { - gcd[(i + delta) as usize] = - residue_sub(gcd[(i + delta) as usize], residue_mul(mult, r[i as usize])); + *gcd.offset((i + delta) as isize) = residue_sub( + *gcd.offset((i + delta) as isize), + residue_mul(mult, r[i as usize]), + ); i += 1; } - while gcddeg >= 0_i32 && gcd[gcddeg as usize] == 0_i32 as u64 { + while gcddeg >= 0_i32 && *gcd.offset(gcddeg as isize) == 0_i32 as u64 { gcddeg -= 1; } let mut i_0: i32 = 0_i32; while i_0 <= sdeg { - mult1[(i_0 + delta) as usize] = residue_sub( - mult1[(i_0 + delta) as usize], + *mult1.offset((i_0 + delta) as isize) = residue_sub( + *mult1.offset((i_0 + delta) as isize), residue_mul(mult, s[i_0 as usize]), ); i_0 += 1; @@ -400,13 +451,13 @@ fn polynomial_xgcd( if mult1deg < sdeg + delta { mult1deg = sdeg + delta; } - while mult1deg >= 0_i32 && mult1[mult1deg as usize] == 0_i32 as u64 { + while mult1deg >= 0_i32 && *mult1.offset(mult1deg as isize) == 0_i32 as u64 { mult1deg -= 1; } let mut i_1: i32 = 0_i32; while i_1 <= tdeg { - mult2[(i_1 + delta) as usize] = residue_sub( - mult2[(i_1 + delta) as usize], + *mult2.offset((i_1 + delta) as isize) = residue_sub( + *mult2.offset((i_1 + delta) as isize), residue_mul(mult, t[i_1 as usize]), ); i_1 += 1; @@ -414,7 +465,7 @@ fn polynomial_xgcd( if mult2deg < tdeg + delta { mult2deg = tdeg + delta; } - while mult2deg >= 0_i32 && mult2[mult2deg as usize] == 0_i32 as u64 { + while mult2deg >= 0_i32 && *mult2.offset(mult2deg as isize) == 0_i32 as u64 { mult2deg -= 1; } } @@ -425,35 +476,35 @@ fn polynomial_xgcd( *pmult2deg = mult2deg; } -fn u2poly(src: &TDivisor, polyu: &mut [u64], polyv: &mut [u64]) -> i32 { - if src.u[1_i32 as usize] != BAD { - polyu[0_i32 as usize] = src.u[0_i32 as usize]; - polyu[1_i32 as usize] = src.u[1_i32 as usize]; - polyu[2_i32 as usize] = 1_i32 as u64; - polyv[0_i32 as usize] = src.v[0_i32 as usize]; - polyv[1_i32 as usize] = src.v[1_i32 as usize]; +unsafe fn u2poly(src: *const TDivisor, polyu: *mut u64, polyv: *mut u64) -> i32 { + if (*src).u[1_i32 as usize] != BAD { + *polyu.offset(0_i32 as isize) = (*src).u[0_i32 as usize]; + *polyu.offset(1_i32 as isize) = (*src).u[1_i32 as usize]; + *polyu.offset(2_i32 as isize) = 1_i32 as u64; + *polyv.offset(0_i32 as isize) = (*src).v[0_i32 as usize]; + *polyv.offset(1_i32 as isize) = (*src).v[1_i32 as usize]; return 2_i32; } - if src.u[0_i32 as usize] != BAD { - polyu[0_i32 as usize] = src.u[0_i32 as usize]; - polyu[1_i32 as usize] = 1_i32 as u64; - polyv[0_i32 as usize] = src.v[0_i32 as usize]; - polyv[1_i32 as usize] = 0_i32 as u64; + if (*src).u[0_i32 as usize] != BAD { + *polyu.offset(0_i32 as isize) = (*src).u[0_i32 as usize]; + *polyu.offset(1_i32 as isize) = 1_i32 as u64; + *polyv.offset(0_i32 as isize) = (*src).v[0_i32 as usize]; + *polyv.offset(1_i32 as isize) = 0_i32 as u64; return 1_i32; } - polyu[0_i32 as usize] = 1_i32 as u64; - polyv[0_i32 as usize] = 0_i32 as u64; - polyv[1_i32 as usize] = 0_i32 as u64; + *polyu.offset(0_i32 as isize) = 1_i32 as u64; + *polyv.offset(0_i32 as isize) = 0_i32 as u64; + *polyv.offset(1_i32 as isize) = 0_i32 as u64; 0_i32 } -fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { +unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, dst: *mut TDivisor) { let mut u1: [u64; 3] = [0; 3]; let mut u2: [u64; 3] = [0; 3]; let mut v1: [u64; 2] = [0; 2]; let mut v2: [u64; 2] = [0; 2]; - let u1deg: i32 = u2poly(src1, &mut u1, &mut v1); - let u2deg: i32 = u2poly(src2, &mut u2, &mut v2); + let u1deg: i32 = u2poly(src1, u1.as_mut_ptr(), v1.as_mut_ptr()); + let u2deg: i32 = u2poly(src2, u2.as_mut_ptr(), v2.as_mut_ptr()); // extended gcd: d1 = gcd(u1, u2) = e1*u1 + e2*u2 let mut d1deg: i32 = 0; let mut e1deg: i32 = 0; @@ -462,10 +513,19 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { let mut e1: [u64; 3] = [0; 3]; let mut e2: [u64; 3] = [0; 3]; polynomial_xgcd( - u1deg, &u1, u2deg, &u2, &mut d1deg, &mut d1, &mut e1deg, &mut e1, &mut e2deg, &mut e2, + u1deg, + u1.as_mut_ptr() as *const u64, + u2deg, + u2.as_mut_ptr() as *const u64, + &mut d1deg, + d1.as_mut_ptr(), + &mut e1deg, + e1.as_mut_ptr(), + &mut e2deg, + e2.as_mut_ptr(), ); // extended gcd again: d = gcd(d1, v1+v2) = c1*d1 + c2*(v1+v2) - let b: [u64; 3] = [ + let mut b: [u64; 3] = [ residue_add(v1[0_i32 as usize], v2[0_i32 as usize]), residue_add(v1[1_i32 as usize], v2[1_i32 as usize]), 0_i32 as u64, @@ -486,7 +546,16 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { let mut c1: [u64; 3] = [0; 3]; let mut c2: [u64; 3] = [0; 3]; polynomial_xgcd( - d1deg, &d1, bdeg, &b, &mut ddeg, &mut d, &mut c1deg, &mut c1, &mut c2deg, &mut c2, + d1deg, + d1.as_mut_ptr() as *const u64, + bdeg, + b.as_mut_ptr() as *const u64, + &mut ddeg, + d.as_mut_ptr(), + &mut c1deg, + c1.as_mut_ptr(), + &mut c2deg, + c2.as_mut_ptr(), ); let dmult: u64 = residue_inv(d[ddeg as usize]); let mut i = 0_i32; @@ -506,7 +575,14 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { i += 1; } let mut u: [u64; 5] = [0; 5]; - let mut udeg: i32 = polynomial_mul(u1deg, &u1, u2deg, &u2, -1_i32, &mut u); + let mut udeg: i32 = polynomial_mul( + u1deg, + u1.as_mut_ptr() as *const u64, + u2deg, + u2.as_mut_ptr() as *const u64, + -1_i32, + u.as_mut_ptr(), + ); // u is monic let mut v: [u64; 7] = [0; 7]; let mut tmp: [u64; 7] = [0; 7]; @@ -514,9 +590,30 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { // c1*(e1*u1*(v2-v1) + d1*v1) + c2*(v1*v2 + f) v[0_i32 as usize] = residue_sub(v2[0_i32 as usize], v1[0_i32 as usize]); v[1_i32 as usize] = residue_sub(v2[1_i32 as usize], v1[1_i32 as usize]); - let mut tmpdeg = polynomial_mul(e1deg, &e1, 1_i32, &v, -1_i32, &mut tmp); - let mut vdeg = polynomial_mul(u1deg, &u1, tmpdeg, &tmp, -1_i32, &mut v); - vdeg = polynomial_mul(d1deg, &d1, 1_i32, &v1, vdeg, &mut v); + let mut tmpdeg = polynomial_mul( + e1deg, + e1.as_mut_ptr() as *const u64, + 1_i32, + v.as_mut_ptr() as *const u64, + -1_i32, + tmp.as_mut_ptr(), + ); + let mut vdeg = polynomial_mul( + u1deg, + u1.as_mut_ptr() as *const u64, + tmpdeg, + tmp.as_mut_ptr() as *const u64, + -1_i32, + v.as_mut_ptr(), + ); + vdeg = polynomial_mul( + d1deg, + d1.as_mut_ptr() as *const u64, + 1_i32, + v1.as_mut_ptr() as *const u64, + vdeg, + v.as_mut_ptr(), + ); i = 0_i32; while i <= vdeg { v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]); @@ -529,26 +626,71 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { tmp[4] = F[4]; tmp[5] = F[5]; tmpdeg = 5_i32; - tmpdeg = polynomial_mul(1_i32, &v1, 1_i32, &v2, tmpdeg, &mut tmp); - vdeg = polynomial_mul(c2deg, &c2, tmpdeg, &tmp, vdeg, &mut v); + tmpdeg = polynomial_mul( + 1_i32, + v1.as_mut_ptr() as *const u64, + 1_i32, + v2.as_mut_ptr() as *const u64, + tmpdeg, + tmp.as_mut_ptr(), + ); + vdeg = polynomial_mul( + c2deg, + c2.as_mut_ptr() as *const u64, + tmpdeg, + tmp.as_mut_ptr() as *const u64, + vdeg, + v.as_mut_ptr(), + ); if ddeg > 0_i32 { let mut udiv: [u64; 5] = [0; 5]; - polynomial_div_monic(udeg, &mut u, ddeg, &d, Some(&mut udiv)); + polynomial_div_monic( + udeg, + u.as_mut_ptr(), + ddeg, + d.as_mut_ptr() as *const u64, + udiv.as_mut_ptr(), + ); udeg -= ddeg; - polynomial_div_monic(udeg, &mut udiv, ddeg, &d, Some(&mut u)); + polynomial_div_monic( + udeg, + udiv.as_mut_ptr(), + ddeg, + d.as_mut_ptr() as *const u64, + u.as_mut_ptr(), + ); udeg -= ddeg; if vdeg >= 0_i32 { - polynomial_div_monic(vdeg, &mut v, ddeg, &d, Some(&mut udiv)); + polynomial_div_monic( + vdeg, + v.as_mut_ptr(), + ddeg, + d.as_mut_ptr() as *const u64, + udiv.as_mut_ptr(), + ); vdeg -= ddeg; for i in 0..=vdeg { v[i as usize] = udiv[i as usize]; } } } - vdeg = polynomial_div_monic(vdeg, &mut v, udeg, &u, None); + vdeg = polynomial_div_monic( + vdeg, + v.as_mut_ptr(), + udeg, + u.as_mut_ptr() as *const u64, + std::ptr::null_mut::(), + ); while udeg > 2_i32 { // u' = monic((f-v^2)/u), v'=-v mod u' - tmpdeg = polynomial_mul(vdeg, &v, vdeg, &v, -1_i32, &mut tmp); + tmpdeg = polynomial_mul( + vdeg, + v.as_mut_ptr() as *const u64, + vdeg, + v.as_mut_ptr() as *const u64, + -1_i32, + tmp.as_mut_ptr(), + ); i = 0_i32; while i <= tmpdeg && i <= 5_i32 { tmp[i as usize] = residue_sub(F[i as usize], tmp[i as usize]); @@ -564,7 +706,13 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { } tmpdeg = i - 1_i32; let mut udiv_0: [u64; 5] = [0; 5]; - polynomial_div_monic(tmpdeg, &mut tmp, udeg, &u, Some(&mut udiv_0)); + polynomial_div_monic( + tmpdeg, + tmp.as_mut_ptr(), + udeg, + u.as_mut_ptr() as *const u64, + udiv_0.as_mut_ptr(), + ); udeg = tmpdeg - udeg; let mult: u64 = residue_inv(udiv_0[udeg as usize]); i = 0_i32; @@ -578,52 +726,60 @@ fn divisor_add(src1: &TDivisor, src2: &TDivisor, dst: &mut TDivisor) { v[i as usize] = residue_sub(0_i32 as u64, v[i as usize]); i += 1; } - vdeg = polynomial_div_monic(vdeg, &mut v, udeg, &u, None); + vdeg = polynomial_div_monic( + vdeg, + v.as_mut_ptr(), + udeg, + u.as_mut_ptr() as *const u64, + std::ptr::null_mut::(), + ); } if udeg == 2_i32 { - dst.u[0_i32 as usize] = u[0_i32 as usize]; - dst.u[1_i32 as usize] = u[1_i32 as usize]; - dst.v[0_i32 as usize] = if vdeg >= 0_i32 { + (*dst).u[0_i32 as usize] = u[0_i32 as usize]; + (*dst).u[1_i32 as usize] = u[1_i32 as usize]; + (*dst).v[0_i32 as usize] = if vdeg >= 0_i32 { v[0_i32 as usize] } else { 0_i32 as u64 }; - dst.v[1_i32 as usize] = if vdeg >= 1_i32 { + (*dst).v[1_i32 as usize] = if vdeg >= 1_i32 { v[1_i32 as usize] } else { 0_i32 as u64 }; } else if udeg == 1_i32 { - dst.u[0_i32 as usize] = u[0_i32 as usize]; - dst.u[1_i32 as usize] = BAD; - dst.v[0_i32 as usize] = if vdeg >= 0_i32 { + (*dst).u[0_i32 as usize] = u[0_i32 as usize]; + (*dst).u[1_i32 as usize] = BAD; + (*dst).v[0_i32 as usize] = if vdeg >= 0_i32 { v[0_i32 as usize] } else { 0_i32 as u64 }; - dst.v[1_i32 as usize] = BAD; + (*dst).v[1_i32 as usize] = BAD; } else { - dst.u[0_i32 as usize] = BAD; - dst.u[1_i32 as usize] = BAD; - dst.v[0_i32 as usize] = BAD; - dst.v[1_i32 as usize] = BAD; + (*dst).u[0_i32 as usize] = BAD; + (*dst).u[1_i32 as usize] = BAD; + (*dst).v[0_i32 as usize] = BAD; + (*dst).v[1_i32 as usize] = BAD; }; } -fn divisor_mul128(src: &TDivisor, mut mult_lo: u64, mut mult_hi: u64, dst: &mut TDivisor) { +unsafe fn divisor_mul128( + src: *const TDivisor, + mut mult_lo: u64, + mut mult_hi: u64, + dst: *mut TDivisor, +) { if mult_lo == 0_i32 as u64 && mult_hi == 0_i32 as u64 { - dst.u[0_i32 as usize] = BAD; - dst.u[1_i32 as usize] = BAD; - dst.v[0_i32 as usize] = BAD; - dst.v[1_i32 as usize] = BAD; + (*dst).u[0_i32 as usize] = BAD; + (*dst).u[1_i32 as usize] = BAD; + (*dst).v[0_i32 as usize] = BAD; + (*dst).v[1_i32 as usize] = BAD; return; } let mut cur: TDivisor = *src; while mult_lo & 1_i32 as u64 == 0 { - { - let tmp = cur; - divisor_add(&tmp, &tmp, &mut cur); - } + divisor_add(&cur, &cur, &mut cur); mult_lo >>= 1_i32; if mult_hi & 1_i32 as u64 != 0 { mult_lo |= 1_u64 << 63_i32; @@ -640,12 +796,9 @@ fn divisor_mul128(src: &TDivisor, mut mult_lo: u64, mut mult_hi: u64, dst: &mut if mult_lo == 0_i32 as u64 && mult_hi == 0_i32 as u64 { break; } - { - let tmp = cur; - divisor_add(&tmp, &tmp, &mut cur); - } + divisor_add(&cur, &cur, &mut cur); if mult_lo & 1_i32 as u64 != 0 { - divisor_add(&(dst.clone()), &cur, dst); + divisor_add(dst, &cur, dst); } } } @@ -654,7 +807,7 @@ fn rol(x: u32, shift: i32) -> u32 { x << shift | x >> (32_i32 - shift) } -fn sha1_single_block(input: &[u8], output: &mut [u8]) { +unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) { let mut a = 0x67452301_i32 as u32; let mut b = 0xefcdab89_u32; let mut c = 0x98badcfe_u32; @@ -663,10 +816,10 @@ fn sha1_single_block(input: &[u8], output: &mut [u8]) { let mut w: [u32; 80] = [0; 80]; let mut i = 0_i32 as usize; while i < 16 { - w[i] = ((input[4_usize.wrapping_mul(i)] as i32) << 24_i32 - | (input[4_usize.wrapping_mul(i).wrapping_add(1)] as i32) << 16_i32 - | (input[4_usize.wrapping_mul(i).wrapping_add(2)] as i32) << 8_i32 - | input[4_usize.wrapping_mul(i).wrapping_add(3)] as i32) as u32; + w[i] = ((*input.add(4_usize.wrapping_mul(i)) as i32) << 24_i32 + | (*input.add(4_usize.wrapping_mul(i).wrapping_add(1)) as i32) << 16_i32 + | (*input.add(4_usize.wrapping_mul(i).wrapping_add(2)) as i32) << 8_i32 + | *input.add(4_usize.wrapping_mul(i).wrapping_add(3)) as i32) as u32; i = i.wrapping_add(1); } i = 16_i32 as usize; @@ -741,29 +894,29 @@ fn sha1_single_block(input: &[u8], output: &mut [u8]) { c = c.wrapping_add(0x98badcfe_u32); d = d.wrapping_add(0x10325476_i32 as u32); e = e.wrapping_add(0xc3d2e1f0_u32); - output[0] = (a >> 24_i32) as u8; - output[1] = (a >> 16_i32) as u8; - output[2] = (a >> 8_i32) as u8; - output[3] = a as u8; - output[4] = (b >> 24_i32) as u8; - output[5] = (b >> 16_i32) as u8; - output[6] = (b >> 8_i32) as u8; - output[7] = b as u8; - output[8] = (c >> 24_i32) as u8; - output[9] = (c >> 16_i32) as u8; - output[10] = (c >> 8_i32) as u8; - output[11] = c as u8; - output[12] = (d >> 24_i32) as u8; - output[13] = (d >> 16_i32) as u8; - output[14] = (d >> 8_i32) as u8; - output[15] = d as u8; - output[16] = (e >> 24_i32) as u8; - output[17] = (e >> 16_i32) as u8; - output[18] = (e >> 8_i32) as u8; - output[19] = e as u8; + *output.offset(0_i32 as isize) = (a >> 24_i32) as u8; + *output.offset(1_i32 as isize) = (a >> 16_i32) as u8; + *output.offset(2_i32 as isize) = (a >> 8_i32) as u8; + *output.offset(3_i32 as isize) = a as u8; + *output.offset(4_i32 as isize) = (b >> 24_i32) as u8; + *output.offset(5_i32 as isize) = (b >> 16_i32) as u8; + *output.offset(6_i32 as isize) = (b >> 8_i32) as u8; + *output.offset(7_i32 as isize) = b as u8; + *output.offset(8_i32 as isize) = (c >> 24_i32) as u8; + *output.offset(9_i32 as isize) = (c >> 16_i32) as u8; + *output.offset(10_i32 as isize) = (c >> 8_i32) as u8; + *output.offset(11_i32 as isize) = c as u8; + *output.offset(12_i32 as isize) = (d >> 24_i32) as u8; + *output.offset(13_i32 as isize) = (d >> 16_i32) as u8; + *output.offset(14_i32 as isize) = (d >> 8_i32) as u8; + *output.offset(15_i32 as isize) = d as u8; + *output.offset(16_i32 as isize) = (e >> 24_i32) as u8; + *output.offset(17_i32 as isize) = (e >> 16_i32) as u8; + *output.offset(18_i32 as isize) = (e >> 8_i32) as u8; + *output.offset(19_i32 as isize) = e as u8; } -fn mix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { +unsafe fn mix(buffer: *mut u8, buf_size: usize, key: *const 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); @@ -772,16 +925,22 @@ fn mix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { for n in &mut sha1_input { *n = 0; } - sha1_input[..half].copy_from_slice(&buffer[half..]); - sha1_input[half..half.wrapping_add(key_size)].copy_from_slice(key); + 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.wrapping_add(key_size)] = 0x80_i32 as u8; - sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] = + sha1_input + [(::std::mem::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[(size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] = + sha1_input + [(::std::mem::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; - sha1_single_block(&sha1_input, &mut sha1_result); + sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr()); let mut i = half & !3; while i < half { sha1_result[i] = sha1_result[i.wrapping_add(4).wrapping_sub(half & 3)]; @@ -789,16 +948,17 @@ fn mix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { } i = 0_i32 as usize; while i < half { - 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; + 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; i = i.wrapping_add(1); } external_counter += 1; } } -fn unmix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { +unsafe fn unmix(buffer: *mut u8, buf_size: usize, key: *const 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); @@ -807,16 +967,18 @@ fn unmix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { for n in &mut sha1_input { *n = 0; } - sha1_input[..half].copy_from_slice(&buffer[..half]); - sha1_input[half..half.wrapping_add(key_size)].copy_from_slice(key); + 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.wrapping_add(key_size)] = 0x80_i32 as u8; - sha1_input[(size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] = + sha1_input + [(::std::mem::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[(size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] = + sha1_input + [(::std::mem::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; - sha1_single_block(&sha1_input, &mut sha1_result); + sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr()); let mut i = half & !3; while i < half { sha1_result[i] = sha1_result[i.wrapping_add(4).wrapping_sub(half & 3)]; @@ -824,29 +986,33 @@ fn unmix(buffer: &mut [u8], buf_size: usize, key: &[u8], key_size: usize) { } i = 0_i32 as usize; while i < half { - 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; + 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; i = i.wrapping_add(1); } external_counter += 1; } } -pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { +pub unsafe fn generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> i32 { let mut installation_id: [u8; 19] = [0; 19]; // 10**45 < 256**19 let mut installation_id_len: usize = 0_i32 as usize; + let mut p: *const i8 = installation_id_str; let mut count: usize = 0_i32 as usize; let mut total_count: usize = 0_i32 as usize; let mut check: u32 = 0_i32 as u32; - for p in installation_id_str.iter() { - let p_curr = *p as i8; - if !(p_curr as i32 == ' ' as i32 || p_curr as i32 == '-' as i32) { - let d: i32 = p_curr as i32 - '0' as i32; + while *p != 0 { + if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) { + let d: i32 = *p as i32 - '0' as i32; if !(0_i32..=9_i32).contains(&d) { return 3_i32; } - if count == 5 { + if count == 5 || *p.offset(1_i32 as isize) as i32 == 0_i32 { + if count == 0 { + return if total_count == 45 { 2_i32 } else { 1_i32 }; + } if d as u32 != check.wrapping_rem(7_i32 as u32) { return if count < 5 { 1_i32 } else { 4_i32 }; } @@ -880,11 +1046,12 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { } } } + p = p.offset(1); } if total_count != 41 && total_count < 45 { return 1_i32; } - while installation_id_len < size_of::<[u8; 19]>() { + while installation_id_len < ::std::mem::size_of::<[u8; 19]>() { installation_id[installation_id_len] = 0_i32 as u8; installation_id_len = installation_id_len.wrapping_add(1); } @@ -895,32 +1062,25 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { 0xd4_i32 as u8, ]; unmix( - &mut installation_id, + installation_id.as_mut_ptr(), (if total_count == 41 { 17_i32 } else { 19_i32 }) as usize, - &IID_KEY, + IID_KEY.as_ptr(), 4_i32 as usize, ); if installation_id[18_i32 as usize] as i32 >= 0x10_i32 { return 5_i32; } - let mut parsed = ParsedInstallationId { + let mut parsed: C2RustUnnamed4 = C2RustUnnamed4 { hardware_id: 0, product_id_low: 0, product_id_high: 0, key_sha1: 0, }; - - let hardware_id_bytes: [u8; 8] = installation_id[0..8].try_into().unwrap(); - parsed.hardware_id = u64::from_le_bytes(hardware_id_bytes); - - let product_id_low_bytes: [u8; 8] = installation_id[8..16].try_into().unwrap(); - parsed.product_id_low = u64::from_le_bytes(product_id_low_bytes); - - parsed.product_id_high = installation_id[16]; - - let key_sha1_bytes: [u8; 2] = installation_id[17..19].try_into().unwrap(); - parsed.key_sha1 = u16::from_le_bytes(key_sha1_bytes); - + 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::(), + ); let product_id_1: u32 = (parsed.product_id_low & ((1_i32 << 17_i32) - 1_i32) as u64) as u32; let product_id_2: u32 = (parsed.product_id_low >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32; @@ -933,33 +1093,39 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { return 5_i32; } let mut keybuf: [u8; 16] = [0; 16]; - keybuf[..8].copy_from_slice(&parsed.hardware_id.to_le_bytes()[..8]); - let product_id_mixed: u64 = (product_id_1 as u64) << 41_i32 + let mut hardware_id = parsed.hardware_id; + ptr::copy_nonoverlapping( + &mut hardware_id as *mut u64 as *const c_void, + keybuf.as_mut_ptr() as *mut c_void, + 8, + ); + let mut product_id_mixed: u64 = (product_id_1 as u64) << 41_i32 | (product_id_2 as u64) << 58_i32 | (product_id_3 as u64) << 17_i32 | product_id_4 as u64; - keybuf[8..16].copy_from_slice(&product_id_mixed.to_le_bytes()[..8]); + ptr::copy_nonoverlapping( + &mut product_id_mixed as *mut u64 as *const c_void, + keybuf.as_mut_ptr().offset(8) as *mut c_void, + 8, + ); let mut d_0: TDivisor = TDivisor { u: [0; 2], v: [0; 2], }; let mut attempt = 0_i32 as u8; while attempt as i32 <= 0x80_i32 { - let mut u: [u8; 14] = [0; 14]; - u[7_i32 as usize] = attempt; - mix(&mut u, 14_i32 as usize, &keybuf, 16_i32 as usize); - let u_lo = u64::from_le_bytes(u[0..8].try_into().unwrap()); - let u_hi = u64::from_le_bytes( - u[8..14] - .iter() - .chain([0, 0].iter()) - .cloned() - .collect::>()[..] - .try_into() - .unwrap(), + let mut u: C2RustUnnamed3 = C2RustUnnamed3 { buffer: [0; 14] }; + 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, ); - let mut x2: u64 = ui128_quotient_mod(u_lo, u_hi); - let x1: u64 = u_lo.wrapping_sub(x2.wrapping_mul(MOD)); + 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); d_0.u[0_i32 as usize] = residue_sub( residue_mul(x1, x1), @@ -975,28 +1141,35 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { return 6_i32; } divisor_mul128( - &(d_0.clone()), + &d_0, 0x4e21b9d10f127c1_i64 as u64, 0x40da7c36d44c_i64 as u64, &mut d_0, ); - let mut e = Encoded { - encoded_lo: 0, - encoded_hi: 0, + let mut e: C2RustUnnamed0 = C2RustUnnamed0 { + c2rust_unnamed: C2RustUnnamed1 { + encoded_lo: 0, + encoded_hi: 0, + }, }; if d_0.u[0_i32 as usize] == BAD { // we can not get the zero divisor, actually... - e.encoded_lo = umul128(MOD.wrapping_add(2_i32 as u64), MOD, &mut e.encoded_hi); + e.c2rust_unnamed.encoded_lo = umul128( + MOD.wrapping_add(2_i32 as u64), + MOD, + &mut e.c2rust_unnamed.encoded_hi, + ); } else if d_0.u[1_i32 as usize] == BAD { - e.encoded_lo = umul128( + e.c2rust_unnamed.encoded_lo = umul128( MOD.wrapping_add(1_i32 as u64), d_0.u[0_i32 as usize], - &mut e.encoded_hi, + &mut e.c2rust_unnamed.encoded_hi, ); - e.encoded_lo = e.encoded_lo.wrapping_add(MOD); - e.encoded_hi = e + e.c2rust_unnamed.encoded_lo = e.c2rust_unnamed.encoded_lo.wrapping_add(MOD); + e.c2rust_unnamed.encoded_hi = e + .c2rust_unnamed .encoded_hi - .wrapping_add((e.encoded_lo < MOD) as i32 as u64); + .wrapping_add((e.c2rust_unnamed.encoded_lo < MOD) as i32 as u64); } else { let x1_0: u64 = (if d_0.u[1_i32 as usize] as i32 % 2_i32 != 0 { d_0.u[1_i32 as usize].wrapping_add(MOD) @@ -1008,15 +1181,16 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { let mut x2_0: u64 = residue_sqrt(x2sqr); if x2_0 == BAD { x2_0 = residue_sqrt(residue_mul(x2sqr, residue_inv(43_i32 as u64))); - e.encoded_lo = umul128( + e.c2rust_unnamed.encoded_lo = umul128( MOD.wrapping_add(1_i32 as u64), MOD.wrapping_add(x2_0), - &mut e.encoded_hi, + &mut e.c2rust_unnamed.encoded_hi, ); - e.encoded_lo = e.encoded_lo.wrapping_add(x1_0); - e.encoded_hi = e + e.c2rust_unnamed.encoded_lo = e.c2rust_unnamed.encoded_lo.wrapping_add(x1_0); + e.c2rust_unnamed.encoded_hi = e + .c2rust_unnamed .encoded_hi - .wrapping_add((e.encoded_lo < x1_0) as i32 as u64); + .wrapping_add((e.c2rust_unnamed.encoded_lo < x1_0) as i32 as u64); } else { // points (-x1+x2, v(-x1+x2)) and (-x1-x2, v(-x1-x2)) let mut x1a: u64 = residue_sub(x1_0, x2_0); @@ -1030,67 +1204,72 @@ pub fn generate(installation_id_str: &[u8], confirmation_id: &mut [u8]) -> i32 { residue_mul(d_0.v[1_i32 as usize], x2a), ); if x1a > x2a { - swap(&mut x1a, &mut x2a); + std::mem::swap(&mut x1a, &mut x2a); } if (y1 ^ y2) & 1_i32 as u64 != 0 { - swap(&mut x1a, &mut x2a); + std::mem::swap(&mut x1a, &mut x2a); } - e.encoded_lo = umul128(MOD.wrapping_add(1_i32 as u64), x1a, &mut e.encoded_hi); - e.encoded_lo = e.encoded_lo.wrapping_add(x2a); - e.encoded_hi = e + e.c2rust_unnamed.encoded_lo = umul128( + MOD.wrapping_add(1_i32 as u64), + x1a, + &mut e.c2rust_unnamed.encoded_hi, + ); + e.c2rust_unnamed.encoded_lo = e.c2rust_unnamed.encoded_lo.wrapping_add(x2a); + e.c2rust_unnamed.encoded_hi = e + .c2rust_unnamed .encoded_hi - .wrapping_add((e.encoded_lo < x2a) as i32 as u64); + .wrapping_add((e.c2rust_unnamed.encoded_lo < x2a) as i32 as u64); } } - let mut e_2 = [ - u32::from_le_bytes(e.encoded_lo.to_le_bytes()[0..4].try_into().unwrap()), - u32::from_le_bytes(e.encoded_lo.to_le_bytes()[4..].try_into().unwrap()), - u32::from_le_bytes(e.encoded_hi.to_le_bytes()[0..4].try_into().unwrap()), - u32::from_le_bytes(e.encoded_hi.to_le_bytes()[4..].try_into().unwrap()), - ]; let mut decimal: [u8; 35] = [0; 35]; let mut i = 0_i32 as usize; while i < 35 { - let c: u32 = (e_2[3_i32 as usize]).wrapping_rem(10_i32 as u32); - e_2[3_i32 as usize] = e_2[3_i32 as usize].wrapping_div(10_i32 as u32); - let c2: u32 = - ((c as u64) << 32_i32 | e_2[2_i32 as usize] as u64).wrapping_rem(10_i32 as u64) as u32; - e_2[2_i32 as usize] = - ((c as u64) << 32_i32 | e_2[2_i32 as usize] as u64).wrapping_div(10_i32 as u64) as u32; - let c3: u32 = - ((c2 as u64) << 32_i32 | e_2[1_i32 as usize] as u64).wrapping_rem(10_i32 as u64) as u32; - e_2[1_i32 as usize] = - ((c2 as u64) << 32_i32 | e_2[1_i32 as usize] as u64).wrapping_div(10_i32 as u64) as u32; - let c4: u32 = - ((c3 as u64) << 32_i32 | e_2[0_i32 as usize] as u64).wrapping_rem(10_i32 as u64) as u32; - e_2[0_i32 as usize] = - ((c3 as u64) << 32_i32 | e_2[0_i32 as usize] as u64).wrapping_div(10_i32 as u64) as u32; + let c: u32 = (e.c2rust_unnamed_0.encoded[3_i32 as usize]).wrapping_rem(10_i32 as u32); + e.c2rust_unnamed_0.encoded[3_i32 as usize] = + e.c2rust_unnamed_0.encoded[3_i32 as usize].wrapping_div(10_i32 as u32); + let c2: u32 = ((c as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64) + .wrapping_rem(10_i32 as u64) as u32; + e.c2rust_unnamed_0.encoded[2_i32 as usize] = + ((c as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[2_i32 as usize] as u64) + .wrapping_div(10_i32 as u64) as u32; + let c3: u32 = ((c2 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64) + .wrapping_rem(10_i32 as u64) as u32; + e.c2rust_unnamed_0.encoded[1_i32 as usize] = + ((c2 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[1_i32 as usize] as u64) + .wrapping_div(10_i32 as u64) as u32; + let c4: u32 = ((c3 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64) + .wrapping_rem(10_i32 as u64) as u32; + e.c2rust_unnamed_0.encoded[0_i32 as usize] = + ((c3 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64) + .wrapping_div(10_i32 as u64) as u32; decimal[34_usize.wrapping_sub(i)] = c4 as u8; i = i.wrapping_add(1); } - let q = confirmation_id; - let mut i: usize = 0; - let mut q_i = 0; + let mut q: *mut i8 = confirmation_id; + i = 0_i32 as usize; while i < 7 { if i != 0 { - q[q_i] = b'-'; - q_i += 1; + let fresh2 = q; + q = q.offset(1); + *fresh2 = '-' as i32 as i8; } - let p_0: &mut [u8] = &mut decimal[i.wrapping_mul(5)..]; - q[q_i] = (p_0[0] as i32 + '0' as i32) as u8; - q[q_i + 1] = (p_0[1] as i32 + '0' as i32) as u8; - q[q_i + 2] = (p_0[2] as i32 + '0' as i32) as u8; - q[q_i + 3] = (p_0[3] as i32 + '0' as i32) as u8; - q[q_i + 4] = (p_0[4] as i32 + '0' as i32) as u8; - q[q_i + 5] = ((p_0[0] as i32 - + p_0[1] as i32 * 2_i32 - + p_0[2] as i32 - + p_0[3] as i32 * 2_i32 - + p_0[4] as i32) + let p_0: *mut u8 = decimal.as_mut_ptr().add(i.wrapping_mul(5)); + *q.offset(0_i32 as isize) = (*p_0.offset(0_i32 as isize) as i32 + '0' as i32) as i8; + *q.offset(1_i32 as isize) = (*p_0.offset(1_i32 as isize) as i32 + '0' as i32) as i8; + *q.offset(2_i32 as isize) = (*p_0.offset(2_i32 as isize) as i32 + '0' as i32) as i8; + *q.offset(3_i32 as isize) = (*p_0.offset(3_i32 as isize) as i32 + '0' as i32) as i8; + *q.offset(4_i32 as isize) = (*p_0.offset(4_i32 as isize) as i32 + '0' as i32) as i8; + *q.offset(5_i32 as isize) = ((*p_0.offset(0_i32 as isize) as i32 + + *p_0.offset(1_i32 as isize) as i32 * 2_i32 + + *p_0.offset(2_i32 as isize) as i32 + + *p_0.offset(3_i32 as isize) as i32 * 2_i32 + + *p_0.offset(4_i32 as isize) as i32) % 7_i32 - + '0' as i32) as u8; - q_i = q_i.wrapping_add(6); + + '0' as i32) as i8; + q = q.offset(6_i32 as isize); i = i.wrapping_add(1); } + let fresh3 = q.offset(1); + *fresh3 = 0_i32 as i8; 0_i32 } diff --git a/umskt/src/confid/mod.rs b/umskt/src/confid/mod.rs index 710668d..077c2f5 100644 --- a/umskt/src/confid/mod.rs +++ b/umskt/src/confid/mod.rs @@ -1,3 +1,5 @@ +use std::ffi::{CStr, CString}; + use thiserror::Error; mod black_box; @@ -25,9 +27,9 @@ pub fn generate(installation_id: &str) -> Result { if installation_id.len() > 54 { return Err(ConfirmationIdError::TooLarge); } - let inst_id = installation_id.as_bytes(); - let mut conf_id = [0u8; 48]; - let result = black_box::generate(inst_id, &mut conf_id); + let inst_id = CString::new(installation_id).unwrap(); + let conf_id = [0u8; 49]; + let result = unsafe { black_box::generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) }; match result { 0 => {} 1 => return Err(ConfirmationIdError::TooShort), @@ -38,7 +40,12 @@ pub fn generate(installation_id: &str) -> Result { 6 => return Err(ConfirmationIdError::Unlucky), _ => panic!("Unknown error code: {}", result), } - Ok(String::from_utf8_lossy(&conf_id).into()) + unsafe { + Ok(CStr::from_ptr(conf_id.as_ptr() as *const i8) + .to_str() + .unwrap() + .to_string()) + } } #[cfg(test)]