You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
151 lines
3.2 KiB
151 lines
3.2 KiB
use crate::*;
|
|
use malloc_array::*;
|
|
use getrandom::{
|
|
getrandom,
|
|
Error,
|
|
};
|
|
use hex_literal::hex;
|
|
|
|
use std::{
|
|
io::{
|
|
self,
|
|
Write,
|
|
},
|
|
};
|
|
|
|
pub const SIZE: usize = 32;
|
|
|
|
const STATIC_SALT: &[u8; SIZE] = &hex!("6787f049791466d5a31a3aa6f7138d8fbb907fd1785758298b5c97b0f3fb31ff");
|
|
|
|
#[derive(Clone,PartialEq,Eq,Hash,Debug)]
|
|
pub enum Salt
|
|
{
|
|
None,
|
|
Static(&'static [u8; SIZE]),
|
|
Fixed([u8; SIZE]),
|
|
Dynamic(Box<[u8]>),
|
|
}
|
|
|
|
impl Default for Salt
|
|
{
|
|
fn default() -> Self
|
|
{
|
|
Self::Static(STATIC_SALT)
|
|
}
|
|
}
|
|
|
|
impl Salt
|
|
{
|
|
pub fn fixed(array: [u8; SIZE]) -> Self
|
|
{
|
|
Self::Fixed(array)
|
|
}
|
|
pub fn unfixed<T>(slice: &T) -> Self
|
|
where T: AsRef<[u8]> + ?Sized
|
|
{
|
|
let slice = slice.as_ref();
|
|
assert!(slice.len() > 0, "Salt expects at least one byte.");
|
|
Self::Dynamic(Vec::from(slice).into_boxed_slice())
|
|
}
|
|
pub fn none() -> Self
|
|
{
|
|
Self::None
|
|
}
|
|
pub fn random() -> Result<Self, Error>
|
|
{
|
|
let mut buffer = [0u8; SIZE];
|
|
getrandom(&mut buffer[..])?;
|
|
Ok(Self::Fixed(buffer))
|
|
}
|
|
pub const fn internal() -> Self
|
|
{
|
|
Self::Static(STATIC_SALT)
|
|
}
|
|
|
|
pub fn bytes(&self) -> &[u8]
|
|
{
|
|
match &self {
|
|
Self::Fixed(ar) => &ar[..],
|
|
Self::Dynamic(vec) => &vec[..],
|
|
Self::Static(s) => &s[..],
|
|
_ => &[],
|
|
}
|
|
}
|
|
|
|
/// Append salt bytes to a stream.
|
|
pub fn append<W: Write+?Sized>(&self, to: &mut W) -> io::Result<usize>
|
|
{
|
|
to.write(self.bytes())
|
|
}
|
|
}
|
|
|
|
#[derive(Copy,Clone,Debug)]
|
|
#[repr(C)]
|
|
#[repr(packed)]
|
|
pub struct FFI
|
|
{
|
|
size: usize,
|
|
body: *mut u8,
|
|
}
|
|
|
|
/// We won't try to copy more than this much data.
|
|
const MAX_FFI_SALT_SIZE: usize = 1024;
|
|
/// Clone a new `Salt` from an `FFI` salt.
|
|
pub unsafe fn clone_from_raw(ptr: *const FFI) -> Salt
|
|
{
|
|
if ptr.is_null() {
|
|
Salt::default()
|
|
} else {
|
|
let ptr = &*ptr;
|
|
if ptr.size == 0 || ptr.body.is_null() {
|
|
return Salt::None;
|
|
}
|
|
let size = std::cmp::min(ptr.size, MAX_FFI_SALT_SIZE);
|
|
Salt::Dynamic(HeapArray::from_raw_copied(ptr.body, size).into_unsafe().into_boxed_slice())
|
|
}
|
|
}
|
|
/// Consume an `FFI` salt and return a `Salt`.
|
|
pub unsafe fn from_raw(ptr: *mut FFI) -> Salt
|
|
{
|
|
if ptr.is_null() {
|
|
Salt::default()
|
|
} else {
|
|
let ptr = {
|
|
let mut ptr = HeapArray::from_raw_parts(ptr, 1);
|
|
let rval = ptr[0].clone();
|
|
ptr.set_memory(0);
|
|
rval
|
|
};
|
|
if ptr.size == 0 || ptr.body.is_null() {
|
|
return Salt::None;
|
|
}
|
|
let body = HeapArray::from_raw_parts(ptr.body, ptr.size);
|
|
Salt::Dynamic(body.into_boxed_slice())
|
|
}
|
|
}
|
|
|
|
/// Consume a `Salt` and output a newly allocated `FFI` salt.
|
|
pub unsafe fn into_raw(salt: Salt) -> *mut FFI
|
|
{
|
|
unsafe fn genffi(bytes: &[u8]) -> *mut FFI
|
|
{
|
|
if bytes.len() == 0 {
|
|
let (ffi, _) = heap![FFI{size:0,body:0 as *mut u8}].into_raw_parts();
|
|
ffi
|
|
} else {
|
|
let mut array = heap![unsafe u8; bytes.len()];
|
|
array.memory_from_raw(&bytes[0] as *const u8, bytes.len());
|
|
let (body, size) = array.into_raw_parts();
|
|
let (ffi, _) = heap![FFI{size,body}].into_raw_parts();
|
|
ffi
|
|
}
|
|
}
|
|
match salt {
|
|
Salt::Static(STATIC_SALT) => 0 as *mut FFI,
|
|
Salt::Static(&other) | Salt::Fixed(other) => genffi(&other[..]),
|
|
Salt::Dynamic(other) => genffi(&other[..]),
|
|
_ => genffi(salt.bytes()),
|
|
}
|
|
}
|
|
|