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
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

mod common;
use crate::common::{describe_result, use_block_cipher, use_first_device};
use skf_rs::spec::algorithm;
use skf_rs::BlockCipherParameter;

#[test]
#[ignore]
fn set_symmetric_key_test() {
    let dev = use_first_device();
    let ret = dev.set_symmetric_key(algorithm::SGD_SM4_ECB, &[0u8; 16]);
    println!("set_symmetric_key result: {:?}", describe_result(&ret));
    assert!(ret.is_ok());
}

#[test]
#[ignore]
fn sm4_ecb_test() {
    let param = BlockCipherParameter::default();
    let dev = use_first_device();
    let crypto = use_block_cipher();
    let key_handle = dev
        .set_symmetric_key(algorithm::SGD_SM4_ECB, &[0u8; 16])
        .unwrap();
    crypto
        .encrypt_init(key_handle.as_ref(), &param)
        .expect("encrypt_init failed");
    let input = [0u8; 16];
    println!("SgdSms4Ecb encrypt,input: {:?}", &input);

    let ret = crypto.encrypt(key_handle.as_ref(), &input, 32);
    assert!(&ret.is_ok());
    let encrypted = ret.unwrap();
    println!("SgdSms4Ecb encrypt,output: {:?}", encrypted);

    crypto
        .decrypt_init(key_handle.as_ref(), &param)
        .expect("decrypt_init failed");
    let ret = crypto.decrypt(key_handle.as_ref(), &encrypted, 32);
    assert!(ret.is_ok());
    let decrypted = ret.unwrap();
    println!("SgdSms4Ecb decrypt,output: {:?}", &decrypted);
    assert_eq!(&decrypted, &input);
}

#[test]
#[ignore]
fn sm4_ecb_group_test() {
    let param = BlockCipherParameter {
        iv: vec![],
        padding_type: 1,
        feed_bit_len: 0,
    };
    let dev = use_first_device();
    let crypto = use_block_cipher();
    let key_handle = dev
        .set_symmetric_key(algorithm::SGD_SM4_ECB, &[0u8; 16])
        .unwrap();
    crypto
        .encrypt_init(key_handle.as_ref(), &param)
        .expect("encrypt_init failed");
    let input = [0u8; 27];
    println!(
        "SgdSms4Ecb encrypt_update,input {} bytes :{:?}",
        &input.len(),
        &input
    );

    let ret = crypto.encrypt_update(key_handle.as_ref(), &input[0..16], 32);
    assert!(&ret.is_ok());
    let encrypted_1 = ret.unwrap();
    println!(
        "SgdSms4Ecb encrypt_update 1,output {} bytes: {:?}",
        &encrypted_1.len(),
        &encrypted_1
    );

    let ret = crypto.encrypt_update(key_handle.as_ref(), &input[16..27], 32);
    assert!(&ret.is_ok());
    let encrypted_2 = ret.unwrap();
    println!(
        "SgdSms4Ecb encrypt_update 2,output {} bytes: {:?}",
        &encrypted_2.len(),
        &encrypted_2
    );

    let ret = crypto.encrypt_final(key_handle.as_ref(), 32);
    assert!(&ret.is_ok());
    let encrypted_3 = ret.unwrap();
    println!(
        "SgdSms4Ecb encrypt_final,output {} bytes :{:?}",
        &encrypted_3.len(),
        &encrypted_3
    );

    let encrypted = [encrypted_1, encrypted_2, encrypted_3].concat();
    println!(
        "SgdSms4Ecb encrypt ,output {} bytes :{:?}",
        &encrypted.len(),
        &encrypted
    );

    crypto
        .decrypt_init(key_handle.as_ref(), &param)
        .expect("decrypt_init failed");

    let ret = crypto.decrypt_update(key_handle.as_ref(), &encrypted[0..16], 32);
    assert!(&ret.is_ok());
    let decrypted_1 = ret.unwrap();
    println!(
        "SgdSms4Ecb decrypt_update 1,output {} bytes: {:?}",
        &decrypted_1.len(),
        &decrypted_1
    );

    let ret = crypto.decrypt_update(key_handle.as_ref(), &encrypted[16..32], 32);
    assert!(&ret.is_ok());
    let decrypted_2 = ret.unwrap();
    println!(
        "SgdSms4Ecb decrypt_update 2,output {} bytes: {:?}",
        &decrypted_2.len(),
        &decrypted_2
    );

    let ret = crypto.decrypt_final(key_handle.as_ref(), 32);
    assert!(&ret.is_ok());
    let decrypted_3 = ret.unwrap();
    println!(
        "SgdSms4Ecb decrypt_final,output {} bytes: {:?}",
        &decrypted_3.len(),
        &decrypted_3
    );

    let decrypted = [decrypted_1, decrypted_2, decrypted_3].concat();
    println!(
        "SgdSms4Ecb decrypt,output {} bytes: {:?}",
        &decrypted.len(),
        &decrypted
    );
    assert_eq!(&decrypted, &input);
}