br-crypto 0.4.8

This is an crypto
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

use openssl::rsa::Rsa;
use openssl::pkey::PKey;
use std::str;
use base64::Engine;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use openssl::hash::MessageDigest;
use openssl::pkey_ctx::PkeyCtx;
use openssl::sign::{Signer, Verifier};
use crate::base64::{decode_u8, encode_file};

/// 创建非对称pkcs8密钥对
pub fn create_pkey_pkcs8() -> (String, String) {
    let rsa = Rsa::generate(2048).unwrap();
    let pkey = PKey::from_rsa(rsa.clone()).unwrap();
    let pub_key: Vec<u8> = pkey.public_key_to_pem().unwrap();
    let pri_key: Vec<u8> = pkey.private_key_to_pem_pkcs8().unwrap();
    (str::from_utf8(pub_key.as_slice()).unwrap().to_string(), str::from_utf8(pri_key.as_slice()).unwrap().to_string())
}

/// 私钥签名
pub fn pri_key_sign(pri_key: &str, content: &str, types: &str) -> String {
    match types {
        "RS256"=>{
            let key = PKey::private_key_from_pem(pri_key.as_bytes()).unwrap();
            let mut signer = Signer::new(MessageDigest::sha256(), &key).unwrap();
            signer.update(content.as_bytes()).unwrap();
            let signature = signer.sign_to_vec().unwrap();
            URL_SAFE_NO_PAD.encode(signature)
        }
        _ => {
            let r = PKey::private_key_from_pem(pri_key.as_bytes()).unwrap();
            let mut ctx = PkeyCtx::new(&r).unwrap();
            ctx.sign_init().unwrap();
            let mut signature = vec![];
            ctx.sign_to_vec(content.as_bytes(), &mut signature).unwrap();
            encode_file(signature)
        }
    }


}

/// 公钥验证
pub fn pub_key_verify(pub_key: String, content: &str, signature: String,types:&str) -> bool {
    match types {
        "RS256" => {
            let pkey = PKey::public_key_from_pem(pub_key.as_bytes())
                .expect("invalid public key");
            let signature_bytes = match URL_SAFE_NO_PAD.decode(signature) {
                Ok(sig) => sig,
                Err(_) => return false, // 签名格式不对
            };
            let mut verifier = Verifier::new(MessageDigest::sha256(), &pkey).expect("verifier init failed");
            verifier.update(content.as_bytes()).expect("verifier update failed");
            verifier.verify(&signature_bytes).unwrap_or(false)
        }
        _ => {
            let pkey = PKey::public_key_from_pem(pub_key.as_bytes()).unwrap();
            let mut ctx = PkeyCtx::new(&pkey).unwrap();
            ctx.verify_init().unwrap();
            let signature = decode_u8(signature);
            ctx.verify(content.as_bytes(), signature.as_slice()).unwrap()
        }
    }


}

/// 公钥加密
pub fn encrypt(pub_key: String, content: &str) -> String {
    let r = PKey::public_key_from_pem(pub_key.as_bytes()).unwrap();
    let mut ctx = PkeyCtx::new(&r).unwrap();
    ctx.encrypt_init().unwrap();
    let mut ciphertext = vec![];
    ctx.encrypt_to_vec(content.as_bytes(), &mut ciphertext).unwrap();
    encode_file(ciphertext)
}

/// 私钥解密
pub fn decrypt(pri_key: String, signature: String) -> String {
    let r = PKey::private_key_from_pem(pri_key.as_bytes()).unwrap();
    let mut ctx = PkeyCtx::new(&r).unwrap();
    ctx.decrypt_init().unwrap();
    let from = decode_u8(signature);
    let mut data = vec![];
    ctx.decrypt_to_vec(from.as_ref(), &mut data).unwrap();
    str::from_utf8(data.as_slice()).unwrap().to_string()
}