skf-rs 0.8.1

Rust wrapper for GM/T 0016-2012(Smart token cryptography application interface specification).
Documentation 
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

use skf_api::native::types::ECCPublicKeyBlob;
use skf_rs::spec::algorithm::SGD_SM4_ECB;
use skf_rs::EnvelopedKeyData;

use crate::common::{
    describe_result, get_or_create_test_container_1, SK_INITIATOR_ID, SK_RESPONDER_ID,
};

mod common;

#[test]
#[ignore]
fn invoke_container_fn() {
    let (_dev, _app, container) = get_or_create_test_container_1();

    let ret = container.get_type();
    println!("invoke get_type result: {:?}", &ret);

    let ret = container.import_certificate(true, &[0u8; 256]);
    println!(
        "invoke import_certificate result: {:?}",
        describe_result(&ret)
    );

    let ret = container.export_certificate(true);
    println!(
        "invoke export_certificate result: {:?}",
        describe_result(&ret)
    );
    let ret = container.ecc_gen_key_pair(SGD_SM4_ECB);
    println!(
        "invoke ecc_gen_key_pair result: {:?}",
        describe_result(&ret)
    );

    let ret = container.ecc_import_key_pair(&EnvelopedKeyData::default());
    println!(
        "invoke ecc_import_key_pair result: {:?}",
        describe_result(&ret)
    );

    let ret = container.ecc_export_public_key(true);
    println!(
        "invoke ecc_export_public_key result: {:?}",
        describe_result(&ret)
    );

    let ret = container.ecc_sign(&[0u8; 32]);
    println!("invoke ecc_sign result: {:?}", describe_result(&ret));

    let ret = container.sk_gen_agreement_data(SGD_SM4_ECB, &SK_INITIATOR_ID);
    println!(
        "invoke sk_gen_agreement_data result: {:?}",
        describe_result(&ret)
    );

    let ret = container.sk_gen_agreement_data_and_key(
        SGD_SM4_ECB,
        &ECCPublicKeyBlob::default(),
        &ECCPublicKeyBlob::default(),
        &SK_INITIATOR_ID,
        &SK_RESPONDER_ID,
    );
    println!(
        "invoke sk_gen_agreement_data_and_key result: {:?}",
        describe_result(&ret)
    );

    let ret = container.sk_import(SGD_SM4_ECB, &[0u8; 32]);
    println!("invoke sk_import result: {:?}", describe_result(&ret));

    let ret = container.sk_export(SGD_SM4_ECB, &ECCPublicKeyBlob::default());
    println!("invoke sk_export result: {:?}", describe_result(&ret));
}