xmtool 2.0.56

Binding 
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

use std::ffi::CString;

use anyhow::{bail, Result};
use cyberex::xffi::sto::cchar_to_string;
use xmtool_sys::{
    util_cert_check, util_cert_parse, util_init_gmtool_runtime, util_pubkey_to_what,
    util_sm2key_gen,
};

pub fn init_gmtool_runtime(params: &str) -> Result<()> {
    let params_ctsring = CString::new(params)?;
    let mut out_err = vec![0; 256];

    if unsafe {
        util_init_gmtool_runtime(
            params_ctsring.as_ptr(),
            out_err.as_mut_ptr(),
            out_err.len() as _,
        )
    } == -1
    {
        bail!(cchar_to_string(out_err.as_ptr()))
    }
    Ok(())
}

pub fn sm2key_gen(password: &str) -> Result<(Vec<u8>, Vec<u8>)> {
    let mut out_pubkey = vec![0; 1024];
    let mut out_prikey = vec![0; 1024];
    let (mut out_pubkey_len, mut out_prikey_len) = (0_i32, 0_i32);
    let mut out_err = vec![0; 256];

    if unsafe {
        util_sm2key_gen(
            password.as_ptr(),
            password.len() as _,
            out_pubkey.as_mut_ptr(),
            out_pubkey.len() as _,
            &mut out_pubkey_len as _,
            out_prikey.as_mut_ptr(),
            out_prikey.len() as _,
            &mut out_prikey_len as _,
            out_err.as_mut_ptr(),
            out_err.len() as _,
        )
    } == -1
    {
        bail!(cchar_to_string(out_err.as_ptr()))
    }
    out_pubkey.resize(out_pubkey_len as _, 0);
    out_prikey.resize(out_prikey_len as _, 0);
    Ok((out_pubkey, out_prikey))
}

pub fn cert_check(cert: &str, root_cert: &str, etc: &str) -> Result<()> {
    let mut out_err = vec![0; 256];
    if unsafe {
        util_cert_check(
            cert.as_ptr(),
            cert.len() as _,
            root_cert.as_ptr(),
            root_cert.len() as _,
            etc.as_ptr().cast(),
            etc.len() as _,
            out_err.as_mut_ptr(),
            out_err.len() as _,
        )
    } == -1
    {
        bail!(cchar_to_string(out_err.as_ptr()))
    }
    Ok(())
}
// pubkey((cert, pubkey)pem(path), hex-string-(un)compress) to what(hex-string)
// what=1: pubkey -> hex-string-compress(len:66)
// what=2: pubkey -> hex-string-uncompress(len:130)
// what=3: pubkey -> [x, y]
pub fn pubkey_to_what_string(pubkey: &[u8], what: i32) -> Result<String> {
    let mut out_err = vec![0; 256];
    let mut out = vec![0; 1024];
    let len = unsafe {
        util_pubkey_to_what(
            pubkey.as_ptr(),
            pubkey.len() as _,
            what,
            out.as_mut_ptr(),
            out.len() as _,
            out_err.as_mut_ptr(),
            out_err.len() as _,
        )
    };
    if len == -1 {
        bail!(cchar_to_string(out_err.as_ptr()))
    }
    out.resize(len as _, 0);

    Ok(String::from_utf8(out)?)
}

pub fn cert_parse(pubkey: &[u8]) -> Result<String> {
    let mut out_err = vec![0; 256];
    let mut out = vec![0; 10 * 1024];

    let len = unsafe {
        util_cert_parse(
            pubkey.as_ptr(),
            pubkey.len() as _,
            out.as_mut_ptr(),
            out.len() as _,
            out_err.as_mut_ptr(),
            out_err.len() as _,
        )
    };
    if len == -1 {
        bail!(cchar_to_string(out_err.as_ptr()))
    }
    out.resize(len as _, 0);

    Ok(String::from_utf8(out)?)
}