208 lines
5.9 KiB
Rust
208 lines
5.9 KiB
Rust
// Copyright (C) 2020 Éloïs SANCHEZ.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#![allow(clippy::missing_safety_doc, clippy::not_unsafe_ptr_arg_deref)]
|
|
|
|
mod r#async;
|
|
mod dewif;
|
|
mod error;
|
|
mod mnemonic;
|
|
|
|
use crate::error::{DartRes, DubpError};
|
|
use crate::r#async::exec_async;
|
|
use allo_isolate::{IntoDart, Isolate};
|
|
use dup_crypto::{
|
|
bases::b58::ToBase58,
|
|
dewif::{Currency, DewifReadError, ExpectedCurrency, G1_CURRENCY, G1_TEST_CURRENCY},
|
|
keys::{
|
|
ed25519::KeyPairFromSeed32Generator, KeyPair as _, KeyPairEnum, Signator as _,
|
|
Signature as _,
|
|
},
|
|
mnemonic::{Language, Mnemonic, MnemonicType},
|
|
};
|
|
use fast_threadpool::{ThreadPool, ThreadPoolConfig, ThreadPoolSyncHandler};
|
|
use once_cell::sync::Lazy;
|
|
use std::{ffi::CStr, io, os::raw};
|
|
use thiserror::Error;
|
|
|
|
pub(crate) fn char_ptr_to_str<'a>(c_char_ptr: *const raw::c_char) -> Result<&'a str, DubpError> {
|
|
if c_char_ptr.is_null() {
|
|
Err(DubpError::NullParamErr)
|
|
} else {
|
|
unsafe { CStr::from_ptr(c_char_ptr).to_str() }.map_err(DubpError::Utf8Error)
|
|
}
|
|
}
|
|
|
|
fn char_ptr_prt_to_vec_str<'a>(
|
|
char_ptr_ptr: *const *const raw::c_char,
|
|
len: u32,
|
|
) -> Result<Vec<&'a str>, DubpError> {
|
|
let len = len as usize;
|
|
let char_ptr_slice: &[*const raw::c_char] =
|
|
unsafe { std::slice::from_raw_parts(char_ptr_ptr, len) };
|
|
let mut str_vec = Vec::with_capacity(len);
|
|
for char_ptr in char_ptr_slice {
|
|
str_vec.push(char_ptr_to_str(*char_ptr)?);
|
|
}
|
|
Ok(str_vec)
|
|
}
|
|
|
|
fn u32_to_language(i: u32) -> Result<Language, DubpError> {
|
|
match i {
|
|
0 => Ok(Language::English),
|
|
1 => Ok(Language::French),
|
|
_ => Err(DubpError::UnknownLanguage),
|
|
}
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn change_dewif_pin(
|
|
port: i64,
|
|
currency: *const raw::c_char,
|
|
dewif: *const raw::c_char,
|
|
old_pin: *const raw::c_char,
|
|
new_pin: *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let currency = char_ptr_to_str(currency)?;
|
|
let dewif = char_ptr_to_str(dewif)?;
|
|
let old_pin = char_ptr_to_str(old_pin)?;
|
|
let new_pin = char_ptr_to_str(new_pin)?;
|
|
Ok((currency, dewif, old_pin, new_pin))
|
|
},
|
|
|(currency, dewif, old_pin, new_pin)| dewif::change_pin(currency, dewif, old_pin, new_pin),
|
|
)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn gen_dewif(
|
|
port: i64,
|
|
currency: *const raw::c_char,
|
|
language: u32,
|
|
mnemonic: *const raw::c_char,
|
|
pin: *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let currency = char_ptr_to_str(currency)?;
|
|
let mnemonic = char_ptr_to_str(mnemonic)?;
|
|
let pin = char_ptr_to_str(pin)?;
|
|
Ok((currency, language, mnemonic, pin))
|
|
},
|
|
|(currency, language, mnemonic, pin)| dewif::gen_dewif(currency, language, mnemonic, pin),
|
|
)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn gen_mnemonic(port: i64, language: u32) {
|
|
Isolate::new(port).post(DartRes::from(mnemonic::gen_mnemonic(language)));
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn gen_pin6(port: i64) {
|
|
Isolate::new(port).post(DartRes::from(dewif::gen_pin6()));
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn gen_pin8(port: i64) {
|
|
Isolate::new(port).post(DartRes::from(dewif::gen_pin8()));
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn gen_pin10(port: i64) {
|
|
Isolate::new(port).post(DartRes::from(dewif::gen_pin10()));
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn get_dewif_pubkey(
|
|
port: i64,
|
|
currency: *const raw::c_char,
|
|
dewif: *const raw::c_char,
|
|
pin: *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let currency = char_ptr_to_str(currency)?;
|
|
let dewif = char_ptr_to_str(dewif)?;
|
|
let pin = char_ptr_to_str(pin)?;
|
|
Ok((currency, dewif, pin))
|
|
},
|
|
|(currency, dewif, pin)| dewif::get_pubkey(currency, dewif, pin),
|
|
)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn mnemonic_to_pubkey(
|
|
port: i64,
|
|
language: u32,
|
|
mnemonic_phrase: *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let mnemonic_phrase = char_ptr_to_str(mnemonic_phrase)?;
|
|
Ok((language, mnemonic_phrase))
|
|
},
|
|
|(language, mnemonic_phrase)| mnemonic::mnemonic_to_pubkey(language, mnemonic_phrase),
|
|
)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn sign(
|
|
port: i64,
|
|
currency: *const raw::c_char,
|
|
dewif: *const raw::c_char,
|
|
pin: *const raw::c_char,
|
|
msg: *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let currency = char_ptr_to_str(currency)?;
|
|
let dewif = char_ptr_to_str(dewif)?;
|
|
let pin = char_ptr_to_str(pin)?;
|
|
let msg = char_ptr_to_str(msg)?;
|
|
Ok((currency, dewif, pin, msg))
|
|
},
|
|
|(currency, dewif, pin, msg)| dewif::sign(currency, dewif, pin, msg),
|
|
)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn sign_several(
|
|
port: i64,
|
|
currency: *const raw::c_char,
|
|
dewif: *const raw::c_char,
|
|
pin: *const raw::c_char,
|
|
msgs_len: u32,
|
|
msgs: *const *const raw::c_char,
|
|
) {
|
|
exec_async(
|
|
port,
|
|
|| {
|
|
let currency = char_ptr_to_str(currency)?;
|
|
let dewif = char_ptr_to_str(dewif)?;
|
|
let pin = char_ptr_to_str(pin)?;
|
|
let msgs = char_ptr_prt_to_vec_str(msgs, msgs_len)?;
|
|
Ok((currency, dewif, pin, msgs))
|
|
},
|
|
|(currency, dewif, pin, msgs)| dewif::sign_several(currency, dewif, pin, &msgs),
|
|
)
|
|
}
|