use alloc::boxed::Box;
use alloc::ffi::CString;
use alloc::vec::Vec;
use core::ffi::{c_char, CStr};
use std::path::Path;
use libadb::keys::rsa::rand_core::OsRng;
use libadb::keys::zeroize::Zeroizing;
use libadb::keys::{store, KeyName};
use crate::error::{self, AdbStatus};
const DEFAULT_NAME: &str = "libadb@host";
#[allow(non_camel_case_types)]
pub struct adb_key_t {
private_key_pem: Zeroizing<Vec<u8>>,
public_key: CString,
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_key_load_or_generate(
android_dir: *const c_char,
name: *const c_char,
out: *mut *mut adb_key_t,
) -> AdbStatus {
error::clear_last_error();
if android_dir.is_null() || out.is_null() {
return error::fail_invalid_arg("null pointer");
}
let dir = unsafe { CStr::from_ptr(android_dir) };
#[cfg(unix)]
let dir = {
use std::os::unix::ffi::OsStrExt;
Path::new(std::ffi::OsStr::from_bytes(dir.to_bytes()))
};
#[cfg(not(unix))]
let dir = match dir.to_str() {
Ok(s) => Path::new(s),
Err(e) => return error::fail_invalid_arg(e),
};
let name = if name.is_null() {
DEFAULT_NAME
} else {
match unsafe { CStr::from_ptr(name) }.to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
}
};
let name = match KeyName::new(name) {
Ok(n) => n,
Err(e) => return error::fail_invalid_arg(e),
};
let key = match store::load_or_generate(dir, &mut OsRng, name) {
Ok(k) => k,
Err(e @ (store::StoreError::Malformed { .. } | store::StoreError::NotAKeyFile { .. })) => {
return error::fail_auth(e)
}
Err(e @ store::StoreError::Key(_)) => return error::fail_internal(e),
Err(e @ store::StoreError::Io { .. }) => return error::fail_io(e),
};
let pem = match key.to_pkcs8_pem() {
Ok(p) => p,
Err(e) => return error::fail_internal(e),
};
let Ok(public_key) = CString::new(key.public_key_line()) else {
return error::fail_internal("key material contains a NUL");
};
if pem.as_bytes().contains(&0) {
return error::fail_internal("key material contains a NUL");
}
let mut private_key_pem = Zeroizing::new(Vec::with_capacity(pem.len() + 1));
private_key_pem.extend_from_slice(pem.as_bytes());
private_key_pem.push(0);
let handle = Box::into_raw(Box::new(adb_key_t {
private_key_pem,
public_key,
}));
unsafe { *out = handle };
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_key_private_key_pem(key: *const adb_key_t) -> *const c_char {
match unsafe { key.as_ref() } {
Some(k) => k.private_key_pem.as_ptr() as *const c_char,
None => core::ptr::null(),
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_key_public_key(key: *const adb_key_t) -> *const c_char {
match unsafe { key.as_ref() } {
Some(k) => k.public_key.as_ptr(),
None => core::ptr::null(),
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_key_free(key: *mut adb_key_t) {
if !key.is_null() {
drop(unsafe { Box::from_raw(key) });
}
}