valter/umskt-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Fix types and symbol names

Browse source
This commit is contained in:
Alex Page 2023-06-22 02:10:52 -04:00
parent 3c55eaadbc
commit 5cd13fb03a
2 changed files with 108 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

242
src/confid/black_box.rs
View file

@ -1,13 +1,7 @@
#![allow( #![allow(clippy::too_many_arguments)]
non_camel_case_types,
non_snake_case,
non_upper_case_globals,
clippy::too_many_arguments
)]
use std::{ffi::c_void, ptr}; use std::{ffi::c_void, ptr};
type size_t = u64;
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
#[repr(C)] #[repr(C)]
struct TDivisor { struct TDivisor {
@ -46,12 +40,12 @@ union C2RustUnnamed_3 {
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
#[repr(C, packed)] #[repr(C, packed)]
struct C2RustUnnamed_4 { struct C2RustUnnamed_4 {
HardwareID: u64, hardware_id: u64,
ProductIDLow: u64, product_id_low: u64,
ProductIDHigh: u8, product_id_high: u8,
KeySHA1: u16, key_sha1: u16,
} }
static mut f: [u64; 6] = [ static mut F: [u64; 6] = [
0, 0,
0x21840136c85381, 0x21840136c85381,
0x44197b83892ad0, 0x44197b83892ad0,
@ -220,7 +214,7 @@ unsafe fn find_divisor_v(mut d: *mut TDivisor) -> i32 {
let mut f2: [u64; 6] = [0; 6]; let mut f2: [u64; 6] = [0; 6];
let mut i: i32 = 0_i32; let mut i: i32 = 0_i32;
while i < 6_i32 { while i < 6_i32 {
f2[i as usize] = f[i as usize]; f2[i as usize] = F[i as usize];
i += 1; i += 1;
} }
let u0: u64 = (*d).u[0_i32 as usize]; let u0: u64 = (*d).u[0_i32 as usize];
@ -629,12 +623,12 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]); v[i as usize] = residue_mul(v[i as usize], c1[0_i32 as usize]);
i += 1; i += 1;
} }
tmp[0] = f[0]; tmp[0] = F[0];
tmp[1] = f[1]; tmp[1] = F[1];
tmp[2] = f[2]; tmp[2] = F[2];
tmp[3] = f[3]; tmp[3] = F[3];
tmp[4] = f[4]; tmp[4] = F[4];
tmp[5] = f[5]; tmp[5] = F[5];
tmpdeg = 5_i32; tmpdeg = 5_i32;
tmpdeg = polynomial_mul( tmpdeg = polynomial_mul(
1_i32, 1_i32,
@ -703,7 +697,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
); );
i = 0_i32; i = 0_i32;
while i <= tmpdeg && i <= 5_i32 { while i <= tmpdeg && i <= 5_i32 {
tmp[i as usize] = residue_sub(f[i as usize], tmp[i as usize]); tmp[i as usize] = residue_sub(F[i as usize], tmp[i as usize]);
i += 1; i += 1;
} }
while i <= tmpdeg { while i <= tmpdeg {
@ -711,7 +705,7 @@ unsafe fn divisor_add(src1: *const TDivisor, src2: *const TDivisor, mut dst: *mu
i += 1; i += 1;
} }
while i <= 5_i32 { while i <= 5_i32 {
tmp[i as usize] = f[i as usize]; tmp[i as usize] = F[i as usize];
i += 1; i += 1;
} }
tmpdeg = i - 1_i32; tmpdeg = i - 1_i32;
@ -824,32 +818,30 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
let mut d = 0x10325476_i32 as u32; let mut d = 0x10325476_i32 as u32;
let mut e = 0xc3d2e1f0_u32; let mut e = 0xc3d2e1f0_u32;
let mut w: [u32; 80] = [0; 80]; let mut w: [u32; 80] = [0; 80];
let mut i = 0_i32 as size_t; let mut i = 0_i32 as usize;
while i < 16_i32 as u64 { while i < 16 {
w[i as usize] = ((*input.offset((4_i32 as u64).wrapping_mul(i) as isize) as i32) << 24_i32 w[i as usize] = ((*input.offset((4 as usize).wrapping_mul(i) as isize) as i32) << 24_i32
| (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(1_i32 as u64) as isize) | (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(1) as isize) as i32)
as i32)
<< 16_i32 << 16_i32
| (*input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(2_i32 as u64) as isize) | (*input.offset((4 as usize).wrapping_mul(i).wrapping_add(2) as isize) as i32)
as i32)
<< 8_i32 << 8_i32
| *input.offset((4_i32 as u64).wrapping_mul(i).wrapping_add(3_i32 as u64) as isize) | *input.offset((4 as usize).wrapping_mul(i).wrapping_add(3) as isize) as i32)
as i32) as u32; as u32;
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 16_i32 as size_t; i = 16_i32 as usize;
while i < 80_i32 as u64 { while i < 80 {
w[i as usize] = rol( w[i as usize] = rol(
w[i.wrapping_sub(3_i32 as u64) as usize] w[i.wrapping_sub(3) as usize]
^ w[i.wrapping_sub(8_i32 as u64) as usize] ^ w[i.wrapping_sub(8) as usize]
^ w[i.wrapping_sub(14_i32 as u64) as usize] ^ w[i.wrapping_sub(14) as usize]
^ w[i.wrapping_sub(16_i32 as u64) as usize], ^ w[i.wrapping_sub(16) as usize],
1_i32, 1_i32,
); );
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 0_i32 as size_t; i = 0_i32 as usize;
while i < 20_i32 as u64 { while i < 20 {
let tmp: u32 = (rol(a, 5_i32)) let tmp: u32 = (rol(a, 5_i32))
.wrapping_add(b & c | !b & d) .wrapping_add(b & c | !b & d)
.wrapping_add(e) .wrapping_add(e)
@ -862,8 +854,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
a = tmp; a = tmp;
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 20_i32 as size_t; i = 20_i32 as usize;
while i < 40_i32 as u64 { while i < 40 {
let tmp_0: u32 = (rol(a, 5_i32)) let tmp_0: u32 = (rol(a, 5_i32))
.wrapping_add(b ^ c ^ d) .wrapping_add(b ^ c ^ d)
.wrapping_add(e) .wrapping_add(e)
@ -876,8 +868,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
a = tmp_0; a = tmp_0;
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 40_i32 as size_t; i = 40_i32 as usize;
while i < 60_i32 as u64 { while i < 60 {
let tmp_1: u32 = (rol(a, 5_i32)) let tmp_1: u32 = (rol(a, 5_i32))
.wrapping_add(b & c | b & d | c & d) .wrapping_add(b & c | b & d | c & d)
.wrapping_add(e) .wrapping_add(e)
@ -890,8 +882,8 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
a = tmp_1; a = tmp_1;
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 60_i32 as size_t; i = 60_i32 as usize;
while i < 80_i32 as u64 { while i < 80 {
let tmp_2: u32 = (rol(a, 5_i32)) let tmp_2: u32 = (rol(a, 5_i32))
.wrapping_add(b ^ c ^ d) .wrapping_add(b ^ c ^ d)
.wrapping_add(e) .wrapping_add(e)
@ -931,10 +923,10 @@ unsafe fn sha1_single_block(input: *mut u8, output: *mut u8) {
*output.offset(19_i32 as isize) = e as u8; *output.offset(19_i32 as isize) = e as u8;
} }
unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) { 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_input: [u8; 64] = [0; 64];
let mut sha1_result: [u8; 20] = [0; 20]; let mut sha1_result: [u8; 20] = [0; 20];
let half: size_t = bufSize.wrapping_div(2_i32 as u64); let half: usize = buf_size.wrapping_div(2);
let mut external_counter = 0_i32; let mut external_counter = 0_i32;
while external_counter < 4_i32 { while external_counter < 4_i32 {
for n in &mut sha1_input { for n in &mut sha1_input {
@ -948,27 +940,25 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
key as *const c_void, key as *const c_void,
sha1_input.as_mut_ptr().offset(half as isize) as *mut c_void, sha1_input.as_mut_ptr().offset(half as isize) as *mut c_void,
keySize as usize, key_size as usize,
); );
sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8; sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
sha1_input sha1_input
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] = [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8; half.wrapping_add(key_size).wrapping_mul(8) as u8;
sha1_input sha1_input
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] = [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
half.wrapping_add(keySize) half.wrapping_add(key_size)
.wrapping_mul(8_i32 as u64) .wrapping_mul(8)
.wrapping_div(0x100_i32 as u64) as u8; .wrapping_div(0x100) as u8;
sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr()); sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
let mut i = half & !3_i32 as u64; let mut i = half & !3;
while i < half { while i < half {
sha1_result[i as usize] = sha1_result[i sha1_result[i as usize] =
.wrapping_add(4_i32 as u64) sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
.wrapping_sub(half & 3_i32 as u64)
as usize];
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 0_i32 as size_t; i = 0_i32 as usize;
while i < half { while i < half {
let tmp: u8 = *buffer.offset(i.wrapping_add(half) as isize); let tmp: u8 = *buffer.offset(i.wrapping_add(half) as isize);
*buffer.offset(i.wrapping_add(half) as isize) = *buffer.offset(i.wrapping_add(half) as isize) =
@ -980,10 +970,10 @@ unsafe fn Mix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t)
} }
} }
unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_t) { 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_input: [u8; 64] = [0; 64];
let mut sha1_result: [u8; 20] = [0; 20]; let mut sha1_result: [u8; 20] = [0; 20];
let half: size_t = bufSize.wrapping_div(2_i32 as u64); let half: usize = buf_size.wrapping_div(2);
let mut external_counter = 0_i32; let mut external_counter = 0_i32;
while external_counter < 4_i32 { while external_counter < 4_i32 {
for n in &mut sha1_input { for n in &mut sha1_input {
@ -993,27 +983,25 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
key, key,
sha1_input.as_mut_ptr().offset(half as isize), sha1_input.as_mut_ptr().offset(half as isize),
keySize as usize, key_size as usize,
); );
sha1_input[half.wrapping_add(keySize) as usize] = 0x80_i32 as u8; sha1_input[half.wrapping_add(key_size) as usize] = 0x80_i32 as u8;
sha1_input sha1_input
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] = [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(1_i32 as u64) as usize] =
half.wrapping_add(keySize).wrapping_mul(8_i32 as u64) as u8; half.wrapping_add(key_size).wrapping_mul(8) as u8;
sha1_input sha1_input
[(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] = [(::std::mem::size_of::<[u8; 64]>() as u64).wrapping_sub(2_i32 as u64) as usize] =
half.wrapping_add(keySize) half.wrapping_add(key_size)
.wrapping_mul(8_i32 as u64) .wrapping_mul(8)
.wrapping_div(0x100_i32 as u64) as u8; .wrapping_div(0x100) as u8;
sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr()); sha1_single_block(sha1_input.as_mut_ptr(), sha1_result.as_mut_ptr());
let mut i = half & !3_i32 as u64; let mut i = half & !3;
while i < half { while i < half {
sha1_result[i as usize] = sha1_result[i sha1_result[i as usize] =
.wrapping_add(4_i32 as u64) sha1_result[i.wrapping_add(4).wrapping_sub(half & 3) as usize];
.wrapping_sub(half & 3_i32 as u64)
as usize];
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
i = 0_i32 as size_t; i = 0_i32 as usize;
while i < half { while i < half {
let tmp: u8 = *buffer.offset(i as isize); let tmp: u8 = *buffer.offset(i as isize);
*buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32 *buffer.offset(i as isize) = (*buffer.offset(i.wrapping_add(half) as isize) as i32
@ -1025,12 +1013,12 @@ unsafe fn Unmix(buffer: *mut u8, bufSize: size_t, key: *const u8, keySize: size_
} }
} }
pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8) -> 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: [u8; 19] = [0; 19]; // 10**45 < 256**19
let mut installation_id_len: size_t = 0_i32 as size_t; let mut installation_id_len: usize = 0_i32 as usize;
let mut p: *const i8 = installation_id_str; let mut p: *const i8 = installation_id_str;
let mut count: size_t = 0_i32 as size_t; let mut count: usize = 0_i32 as usize;
let mut totalCount: size_t = 0_i32 as size_t; let mut total_count: usize = 0_i32 as usize;
let mut check: u32 = 0_i32 as u32; let mut check: u32 = 0_i32 as u32;
while *p != 0 { while *p != 0 {
if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) { if !(*p as i32 == ' ' as i32 || *p as i32 == '-' as i32) {
@ -1038,34 +1026,30 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
if !(0_i32..=9_i32).contains(&d) { if !(0_i32..=9_i32).contains(&d) {
return 3_i32; return 3_i32;
} }
if count == 5_i32 as u64 || *p.offset(1_i32 as isize) as i32 == 0_i32 { if count == 5 || *p.offset(1_i32 as isize) as i32 == 0_i32 {
if count == 0 { if count == 0 {
return if totalCount == 45_i32 as u64 { return if total_count == 45 { 2_i32 } else { 1_i32 };
2_i32
} else {
1_i32
};
} }
if d as u32 != check.wrapping_rem(7_i32 as u32) { if d as u32 != check.wrapping_rem(7_i32 as u32) {
return if count < 5_i32 as u64 { 1_i32 } else { 4_i32 }; return if count < 5 { 1_i32 } else { 4_i32 };
} }
check = 0_i32 as u32; check = 0_i32 as u32;
count = 0_i32 as size_t; count = 0_i32 as usize;
} else { } else {
check = check.wrapping_add( check = check.wrapping_add(
(if count.wrapping_rem(2_i32 as u64) != 0 { (if count.wrapping_rem(2) != 0 {
d * 2_i32 d * 2_i32
} else { } else {
d d
}) as u32, }) as u32,
); );
count = count.wrapping_add(1); count = count.wrapping_add(1);
totalCount = totalCount.wrapping_add(1); total_count = total_count.wrapping_add(1);
if totalCount > 45_i32 as u64 { if total_count > 45 {
return 2_i32; return 2_i32;
} }
let mut carry: u8 = d as u8; let mut carry: u8 = d as u8;
let mut i = 0_i32 as size_t; let mut i = 0_i32 as usize;
while i < installation_id_len { while i < installation_id_len {
let x: u32 = let x: u32 =
(installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32; (installation_id[i as usize] as i32 * 10_i32 + carry as i32) as u32;
@ -1082,73 +1066,63 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
} }
p = p.offset(1); p = p.offset(1);
} }
if totalCount != 41_i32 as u64 && totalCount < 45_i32 as u64 { if total_count != 41 && total_count < 45 {
return 1_i32; return 1_i32;
} }
while installation_id_len < ::std::mem::size_of::<[u8; 19]>() as u64 { while installation_id_len < ::std::mem::size_of::<[u8; 19]>() {
installation_id[installation_id_len as usize] = 0_i32 as u8; installation_id[installation_id_len as usize] = 0_i32 as u8;
installation_id_len = installation_id_len.wrapping_add(1); installation_id_len = installation_id_len.wrapping_add(1);
} }
static mut iid_key: [u8; 4] = [ const IID_KEY: [u8; 4] = [
0x6a_i32 as u8, 0x6a_i32 as u8,
0xc8_i32 as u8, 0xc8_i32 as u8,
0x5e_i32 as u8, 0x5e_i32 as u8,
0xd4_i32 as u8, 0xd4_i32 as u8,
]; ];
Unmix( unmix(
installation_id.as_mut_ptr(), installation_id.as_mut_ptr(),
(if totalCount == 41_i32 as u64 { (if total_count == 41 { 17_i32 } else { 19_i32 }) as usize,
17_i32 IID_KEY.as_ptr(),
} else { 4_i32 as usize,
19_i32
}) as size_t,
iid_key.as_ptr(),
4_i32 as size_t,
); );
if installation_id[18_i32 as usize] as i32 >= 0x10_i32 { if installation_id[18_i32 as usize] as i32 >= 0x10_i32 {
return 5_i32; return 5_i32;
} }
let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 { let mut parsed: C2RustUnnamed_4 = C2RustUnnamed_4 {
HardwareID: 0, hardware_id: 0,
ProductIDLow: 0, product_id_low: 0,
ProductIDHigh: 0, product_id_high: 0,
KeySHA1: 0, key_sha1: 0,
}; };
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
installation_id.as_mut_ptr() as *const c_void, installation_id.as_mut_ptr() as *const c_void,
&mut parsed as *mut C2RustUnnamed_4 as *mut c_void, &mut parsed as *mut C2RustUnnamed_4 as *mut c_void,
std::mem::size_of::<C2RustUnnamed_4>(), std::mem::size_of::<C2RustUnnamed_4>(),
); );
let productId1: u32 = (parsed.ProductIDLow & ((1_i32 << 17_i32) - 1_i32) as u64) as u32; let product_id_1: u32 = (parsed.product_id_low & ((1_i32 << 17_i32) - 1_i32) as u64) as u32;
let productId2: u32 = let product_id_2: u32 =
(parsed.ProductIDLow >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32; (parsed.product_id_low >> 17_i32 & ((1_i32 << 10_i32) - 1_i32) as u64) as u32;
let productId3: u32 = let product_id_3: u32 =
(parsed.ProductIDLow >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32; (parsed.product_id_low >> 27_i32 & ((1_i32 << 25_i32) - 1_i32) as u64) as u32;
let version: u32 = (parsed.ProductIDLow >> 52_i32 & 7_i32 as u64) as u32; let version: u32 = (parsed.product_id_low >> 52_i32 & 7_i32 as u64) as u32;
let productId4: u32 = let product_id_4: u32 = (parsed.product_id_low >> 55_i32
(parsed.ProductIDLow >> 55_i32 | ((parsed.ProductIDHigh as i32) << 9_i32) as u64) as u32; | ((parsed.product_id_high as i32) << 9_i32) as u64) as u32;
if version if version != (if total_count == 41 { 4_i32 } else { 5_i32 }) as u32 {
!= (if totalCount == 41_i32 as u64 {
4_i32
} else {
5_i32
}) as u32
{
return 5_i32; return 5_i32;
} }
let mut keybuf: [u8; 16] = [0; 16]; let mut keybuf: [u8; 16] = [0; 16];
let mut hardware_id = parsed.HardwareID; let mut hardware_id = parsed.hardware_id;
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
&mut hardware_id as *mut u64 as *const c_void, &mut hardware_id as *mut u64 as *const c_void,
keybuf.as_mut_ptr() as *mut c_void, keybuf.as_mut_ptr() as *mut c_void,
8, 8,
); );
let mut productIdMixed: u64 = (productId1 as u64) << 41_i32 let mut product_id_mixed: u64 = (product_id_1 as u64) << 41_i32
| (productId2 as u64) << 58_i32 | (product_id_2 as u64) << 58_i32
| (productId3 as u64) << 17_i32 | (product_id_3 as u64) << 17_i32
| productId4 as u64; | product_id_4 as u64;
ptr::copy_nonoverlapping( ptr::copy_nonoverlapping(
&mut productIdMixed as *mut u64 as *const c_void, &mut product_id_mixed as *mut u64 as *const c_void,
keybuf.as_mut_ptr().offset(8) as *mut c_void, keybuf.as_mut_ptr().offset(8) as *mut c_void,
8, 8,
); );
@ -1162,11 +1136,11 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
u.c2rust_unnamed.lo = 0_i32 as u64; u.c2rust_unnamed.lo = 0_i32 as u64;
u.c2rust_unnamed.hi = 0_i32 as u64; u.c2rust_unnamed.hi = 0_i32 as u64;
u.buffer[7_i32 as usize] = attempt; u.buffer[7_i32 as usize] = attempt;
Mix( mix(
(u.buffer).as_mut_ptr(), (u.buffer).as_mut_ptr(),
14_i32 as size_t, 14_i32 as usize,
keybuf.as_mut_ptr(), keybuf.as_mut_ptr(),
16_i32 as size_t, 16_i32 as usize,
); );
let mut x2: u64 = ui128_quotient_mod(u.c2rust_unnamed.lo, u.c2rust_unnamed.hi); 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)); let x1: u64 = u.c2rust_unnamed.lo.wrapping_sub(x2.wrapping_mul(MOD));
@ -1266,8 +1240,8 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
} }
} }
let mut decimal: [u8; 35] = [0; 35]; let mut decimal: [u8; 35] = [0; 35];
let mut i = 0_i32 as size_t; let mut i = 0_i32 as usize;
while i < 35_i32 as u64 { while i < 35 {
let c: u32 = (e.c2rust_unnamed_0.encoded[3_i32 as usize]).wrapping_rem(10_i32 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] =
e.c2rust_unnamed_0.encoded[3_i32 as usize].wrapping_div(10_i32 as u32); e.c2rust_unnamed_0.encoded[3_i32 as usize].wrapping_div(10_i32 as u32);
@ -1286,20 +1260,18 @@ pub unsafe fn Generate(installation_id_str: *const i8, confirmation_id: *mut i8)
e.c2rust_unnamed_0.encoded[0_i32 as usize] = 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) ((c3 as u64) << 32_i32 | e.c2rust_unnamed_0.encoded[0_i32 as usize] as u64)
.wrapping_div(10_i32 as u64) as u32; .wrapping_div(10_i32 as u64) as u32;
decimal[(34_i32 as u64).wrapping_sub(i) as usize] = c4 as u8; decimal[(34 as usize).wrapping_sub(i) as usize] = c4 as u8;
i = i.wrapping_add(1); i = i.wrapping_add(1);
} }
let mut q: *mut i8 = confirmation_id; let mut q: *mut i8 = confirmation_id;
i = 0_i32 as size_t; i = 0_i32 as usize;
while i < 7_i32 as u64 { while i < 7 {
if i != 0 { if i != 0 {
let fresh2 = q; let fresh2 = q;
q = q.offset(1); q = q.offset(1);
*fresh2 = '-' as i32 as i8; *fresh2 = '-' as i32 as i8;
} }
let p_0: *mut u8 = decimal let p_0: *mut u8 = decimal.as_mut_ptr().offset(i.wrapping_mul(5) as isize);
.as_mut_ptr()
.offset(i.wrapping_mul(5_i32 as u64) as isize);
*q.offset(0_i32 as isize) = (*p_0.offset(0_i32 as isize) as i32 + '0' as i32) as i8; *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(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(2_i32 as isize) = (*p_0.offset(2_i32 as isize) as i32 + '0' as i32) as i8;

2
src/confid/mod.rs
View file

@ -23,7 +23,7 @@ pub enum ConfirmationIdError {
pub fn generate(installation_id: &str) -> Result<String, ConfirmationIdError> { pub fn generate(installation_id: &str) -> Result<String, ConfirmationIdError> {
let inst_id = CString::new(installation_id).unwrap(); let inst_id = CString::new(installation_id).unwrap();
let conf_id = [0u8; 49]; let conf_id = [0u8; 49];
let result = unsafe { black_box::Generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) }; let result = unsafe { black_box::generate(inst_id.as_ptr(), conf_id.as_ptr() as *mut i8) };
match result { match result {
0 => {} 0 => {}
1 => return Err(ConfirmationIdError::TooShort), 1 => return Err(ConfirmationIdError::TooShort),