查询管理员操作日志

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
 
public class DecryptDemo {   
/**     
* decryptData 解密数据    
*     
* @param rsaPriKey PKCS#8格式的RSA私钥文件内容    
* @param encData 加密数据   
* @param encKey 加密对称密钥   
* @return decData 解密后数据    
*/    
public static String decryptData(String rsaPriKey, String encData, String encKey) throws Exception {
         
// 解密对称密钥       
String aesKey = decEncKey(rsaPriKey, encKey);
        
// 解密数据        
return decEncData(aesKey, encData);
   
}
  
/**     
* decEncKey 解密对称密钥     
* @param rsaPriKey    
* @param encKey     
* @return 对称密钥    
*/    
public static String decEncKey(String rsaPriKey, String encKey) throws Exception {
        
// base64解码对称密钥       
byte[] decodeKey = Base64.getDecoder().decode(encKey);
        
// 私钥解密对称密钥
Cipher cipher = Cipher.getInstance("RSA");        
PrivateKey pk = ReadPemKeyPair.loadPrivateKey(rsaPriKey);       
cipher.init(Cipher.DECRYPT_MODE, pk);       
String aesKey = new String(cipher.doFinal(decodeKey));
       
if (aesKey.length() != 32) {            
throw new Exception("非256位对称密钥");        
}        
return aesKey;    
} 
    
/**     
* decEncData 解密数据    
* @param aesKey    
* @param encData
* @return 解密后的明文数据     
*/    
public static String decEncData(String aesKey, String encData) throws Exception {
        
// 获取初始向量IV       
String iv = aesKey.substring(0, 16);
        
// base64解码数据       
byte[] decodeData = Base64.getDecoder().decode(encData);
       
// 解密数据       
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");       
IvParameterSpec params = new IvParameterSpec(iv.getBytes());      
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(aesKey.getBytes(), "AES"), params);

//        byte[] originData = pkcs7UnPadding(cipher.doFinal(decodeData));

//        return new String(originData, StandardCharsets.UTF_8);
       
return new String(cipher.doFinal(decodeData));
    
}
   
private static byte[] pkcs7UnPadding(byte[] originData) throws Exception {        
int length = originData.length;       
int unpadding = originData[length - 1];        
int index = length - unpadding;
        
if (index < 0 || index > length) {           
throw new Exception("index out of range");       
}
       
byte[] dst = new byte[index];
       
System.arraycopy(originData, 0, dst, 0, index);
        
return dst;
    
}
}
 
class ReadPemKeyPair {
   
private static String loadKey(String keyPem) throws IOException {       
BufferedReader brKey = new BufferedReader(new StringReader(keyPem));       
StringBuilder sb = new StringBuilder();       
String line;
     
while ((line = brKey.readLine())!= null) {           
if (!line.startsWith("-")) {                
sb.append(line);
            
}
        
}        
return sb.toString();
   
}    
public static PrivateKey loadPrivateKey(String privateKeyPem) throws GeneralSecurityException, IOException {       
// 读取 pem 中的 key        
String privateKeyStr = loadKey(privateKeyPem);        
byte [] pkcs8EncodedKeySpec = Base64.getDecoder().decode(privateKeyStr);       
PKCS8EncodedKeySpec privSpec = new PKCS8EncodedKeySpec(pkcs8EncodedKeySpec);      
KeyFactory kf = KeyFactory.getInstance("RSA");       
return kf.generatePrivate(privSpec);   
}
   
public static PublicKey loadPublicKey(String publicKeyPem) throws GeneralSecurityException, IOException {       
// 读取 pem 中的 key        
String publicKeyStr = loadKey(publicKeyPem);       
X509EncodedKeySpec x509PubKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyStr));       
KeyFactory fact = KeyFactory.getInstance("RSA");       
return fact.generatePublic(x509PubKeySpec);   
}
}

#include <iostream>
#include <string>
#include <vector>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/evp.h>
#include <openssl/aes.h>
#include <openssl/err.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>
 
// Base64解码
std::string base64Decode(const std::string &input) {    
    BIO* bio_mem = BIO_new_mem_buf(input.data(), input.length());   
    BIO* bio64 = BIO_new(BIO_f_base64());    
    BIO_set_flags(bio64, BIO_FLAGS_BASE64_NO_NL);   
    BIO_push(bio64, bio_mem);   
    char buffer[1024];    
    std::string result;    
    int decoded_size;
    
    while ((decoded_size = BIO_read(bio64, buffer, 1024)) > 0) {        
      result.append(buffer, decoded_size);   
    }
   
    BIO_free_all(bio64);    
    return result;
}
 
// 解密对称密钥
std::string decEncKey(const std::string &rsa_pri_key, const std::string &enc_key) {
    BIO *bio_mem = BIO_new_mem_buf(rsa_pri_key.data(), rsa_pri_key.size());
    RSA *rsa = RSA_new();
    rsa = PEM_read_bio_RSAPrivateKey(bio_mem, &rsa, nullptr, nullptr);
    if (rsa == nullptr) {
      return "";
      }
          
    // base64解码对称密钥   
    std::string decoded_key = base64Decode(enc_key);
    
    // 私钥解密对称密钥   
    std::vector<unsigned char> decrypted_key(RSA_size(rsa));
   
    int key_size = RSA_private_decrypt(decoded_key.size(), (const unsigned char *)decoded_key.data(), &decrypted_key[0], rsa, RSA_PKCS1_PADDING);
   
    RSA_free(rsa);   
    BIO_free(bio_mem);
   
    return std::string(decrypted_key.begin(), decrypted_key.begin() + key_size);

}
 
// 去除填充
std::string pkcs7UnPadding(const std::string& orig_data) {
   
    size_t length = orig_data.size();   
    unsigned char unpadding = orig_data[length - 1];  
    size_t index = length - unpadding;    
    if (index < 0 || index >= length) {
      throw std::runtime_error("index out of range");  
      }
    
    return orig_data.substr(0, index);
}
 
// 解密数据
std::string decEncData(const std::string &aes_key, const std::string &enc_data) {
   
    // base64解码数据
    std::string decoded_data = base64Decode(enc_data);
    
    // 获取初始向量IV
    std::string iv = aes_key.substr(0, 16);
    
    // 解密数据
    AES_KEY key;
    
    if (AES_set_decrypt_key(reinterpret_cast<const unsigned char*>(aes_key.data()), 256, &key) < 0) {
      throw std::runtime_error("failed to set AES decryption key");    
    }
   
    std::string orig_data(decoded_data.size(), '\\0');    
    AES_cbc_encrypt(reinterpret_cast<const unsigned char*>(decoded_data.data()),
    reinterpret_cast<unsigned char*>(&orig_data[0]),
                    
    decoded_data.size(),
                    
    &key,
                 
    reinterpret_cast<unsigned char*>(&iv[0]),
                   
    AES_DECRYPT);
    
    std::string dec_data = pkcs7UnPadding(orig_data);
    
    return dec_data;

}

 
/*
* DecryptData 解密数据 
* 
* @param rsaPriKey PKCS#8格式的RSA私钥文件内容 
* @param encData 加密数据 
* @param encKey 加密对称密钥
* @return decData 解密后数据
*/

std::string DecryptData(const std::string &rsaPriKey, const std::string &encData, const std::string &encKey) {
	
    // 解密对称密钥	
    std::string aesKey = decEncKey(rsaPriKey, encKey);
    
    if (aesKey == "") {
        return "";    
    }
	
    // 解密数据
    std::string decData = decEncData(aesKey, encData);	
    return decData;

}

package util
import (	
"crypto/aes"	
"crypto/cipher"	
"crypto/rand"	
"crypto/rsa"	
"crypto/x509"	
"encoding/base64"	
"encoding/pem"	
"errors"
)
 
/* 
* DecryptData 解密数据 
* 
* @param rsaPriKey PKCS#8格式的RSA私钥文件内容 
* @param encData 加密数据 
* @param encKey 加密对称密钥 
* @return decData 解密后数据 
* @return err 错误信息
*/

func DecryptData(rsaPriKey, encData, encKey string) (decData string, err error) {
	
    // 解密对称密钥	
    aesKey, err := decEncKey(rsaPriKey, encKey)
	if err != nil {	
      return "", err	
    }
	
    // 解密数据
    decData, err = decEncData(aesKey, encData)	
    if err != nil {	
      return "", err	
    }
	
    return decData, nil

}
 
// decEncKey 解密对称密钥
func decEncKey(rsaPriKey, encKey string) (string, error) {
	
    // base64解码对称密	
    decodeKey, err := base64.StdEncoding.DecodeString(string(encKey))	
    if err != nil {	
      return "", err	
    }	
    
    // 私钥解密对称密钥
    pemBlk, _ := pem.Decode([]byte(rsaPriKey))
    if pemBlk == nil {
      return "", errors.New("非法PEM格式的RSA私钥文件")
    }	
    pkInf, err := x509.ParsePKCS8PrivateKey(pemBlk.Bytes)
	if err != nil {
      return "", err
    }

	pk, ok := pkInf.(*rsa.PrivateKey)

	if !ok {
	return "", errors.New("非PKCS#8格式的RSA私钥文件")
	}

	byteAESKey, err := rsa.DecryptPKCS1v15(rand.Reader, pk, decodeKey)

	if err != nil {
      return "", err	
    }	
    
    aesKey := string(byteAESKey)
	
    if len(aesKey) != 32 {
      return "", errors.New("非256位对称密钥")
    }

	return aesKey, nil
}

 
// pkcs7UnPadding 去除填充

func pkcs7UnPadding(origData []byte) ([]byte, error) {

    length := len(origData)
    unpadding := int(origData[length-1])
    index := length - unpadding

	if index < 0 || index >= len(origData) {
      return nil, errors.New("index out of range")
      }

	return origData[:index], nil
}

 
// decEncData 解密数据
func decEncData(aesKey, encData string) (string, error) {
	
    // 获取初始向量IV
    iv := aesKey[:16]
    
    // base64解码数据
    decodeData, err := base64.StdEncoding.DecodeString(string(encData))	
    if err != nil {
      return "", err
    }
	
    // 解密数据
    cipherBlk, err := aes.NewCipher([]byte(aesKey))
    if err != nil {
      return "", err
    }

	blockMode := cipher.NewCBCDecrypter(cipherBlk, []byte(iv))

	origData := make([]byte, len(decodeData))

	blockMode.CryptBlocks(origData, decodeData)

	byteDecData, err := pkcs7UnPadding(origData)

    if err != nil {
      return "", err
    }

	decData := string(byteDecData)
    return decData, nil
}