1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use core::cmp::Ordering;
use core::{mem, ptr};
use std::ffi::CString;

use crate::errors::*;
use crate::ffi;

#[inline]
pub fn memzero<T>(mut obj: T)
where
    T: Sized,
{
    unsafe { ffi::hydro_memzero(&mut obj as *mut _ as *mut _, mem::size_of::<T>()) }
}

#[inline]
pub fn increment(n: &mut [u8]) {
    unsafe {
        ffi::hydro_increment(n.as_mut_ptr(), n.len());
    }
}

pub fn equal<T, U>(b1: T, b2: U) -> bool
where
    T: AsRef<[u8]>,
    U: AsRef<[u8]>,
{
    let b1 = b1.as_ref();
    let b2 = b2.as_ref();
    let len = b1.len();
    if b2.len() != len {
        return false;
    }
    unsafe { ffi::hydro_equal(b1.as_ptr() as *const _, b2.as_ptr() as *const _, len) as bool }
}

pub fn compare(b1: &[u8], b2: &[u8]) -> Ordering {
    let len = b1.len();
    if b2.len() != len {
        panic!("Comparison of vectors with different lengths")
    }
    match unsafe { ffi::hydro_compare(b1.as_ptr(), b2.as_ptr(), len) } {
        -1 => Ordering::Less,
        0 => Ordering::Equal,
        1 => Ordering::Greater,
        _ => unreachable!(),
    }
}

pub fn bin2hex<T>(bin: T) -> String
where
    T: AsRef<[u8]>,
{
    let bin = bin.as_ref();
    let len = bin.len();
    let hex_len = len * 2 + 1;
    let mut hex = vec![0u8; hex_len];
    unsafe {
        ffi::hydro_bin2hex(hex.as_mut_ptr() as *mut _, hex_len, bin.as_ptr(), len);
        hex.truncate(hex_len - 1);
        String::from_utf8_unchecked(hex)
    }
}

pub fn hex2bin(hex: &str, ignore: Option<&[u8]>) -> Result<Vec<u8>, HydroError> {
    let hex = hex.as_bytes();
    let hex_len = hex.len();
    let max_bin_len = hex_len / 2;
    let mut bin = vec![0u8; max_bin_len];
    let ignore_p = match ignore {
        Some(ignore) => CString::new(ignore)
            .map_err(|_| HydroError::InvalidInput)?
            .into_raw(),
        None => ptr::null_mut(), // doesn't make sense semantically, but required for `CString::from_raw()`.
    };
    let bin_len = unsafe {
        ffi::hydro_hex2bin(
            bin.as_mut_ptr(),
            max_bin_len,
            hex.as_ptr() as *const _,
            hex_len,
            ignore_p,
            ptr::null_mut(),
        )
    };
    if !ignore_p.is_null() {
        unsafe {
            // Even though `into_raw()` is not unsafe, Rust will leak the string.
            // Manually freeing the string is required, and the documented way
            // to do it is by recreating a CString using the pointer, and discarding it.
            _ = CString::from_raw(ignore_p);
        }
    }
    if bin_len < 0 {
        return Err(HydroError::InvalidInput);
    }
    bin.truncate(bin_len as usize);
    Ok(bin)
}

pub fn pad(buf: &mut Vec<u8>, blocksize: usize) {
    buf.reserve(blocksize);
    let unpadded_buflen = buf.len();
    let max_padded_buflen = unpadded_buflen + blocksize;
    let padded_buflen = unsafe {
        buf.set_len(max_padded_buflen);
        ffi::hydro_pad(
            buf.as_mut_ptr(),
            unpadded_buflen,
            blocksize,
            max_padded_buflen,
        )
    };
    if padded_buflen < 0 {
        panic!("Padding failed")
    }
    buf.truncate(padded_buflen as usize);
}

pub fn unpad(buf: &mut Vec<u8>, blocksize: usize) -> Result<(), HydroError> {
    let unpadded_buflen = unsafe { ffi::hydro_unpad(buf.as_ptr(), buf.len(), blocksize) };
    if unpadded_buflen < 0 {
        return Err(HydroError::InvalidPadding);
    }
    buf.truncate(unpadded_buflen as usize);
    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn test_utils() {
        let bin = [69u8, 42];
        let hex = utils::bin2hex(bin);
        assert_eq!(hex, "452a");
        let bin2: Vec<u8> = utils::hex2bin(&hex, None).unwrap();
        assert_eq!(bin, &bin2[..]);
        let mut bin2: Vec<u8> = utils::hex2bin("#452a#", Some(b"#")).unwrap();
        assert_eq!(bin, &bin2[..]);

        utils::pad(&mut bin2, 100);
        assert_eq!(bin2.len(), 100);
        utils::unpad(&mut bin2, 100).unwrap();
        assert_eq!(bin, &bin2[..]);
    }
}