CSharp丶Java前后端通讯(RSA丶AES通用加密)(记录一)

最新推荐文章于 2021-02-15 17:33:28 发布
最新推荐文章于 2021-02-15 17:33:28 发布
阅读量782 收藏
点赞数
分类专栏： Unity学习笔记 JAVA学习笔记

 

以下内容为查阅多方资料整理所得, 并非原创内容, 仅供参考

以下内容可能在未来进行修改丶更新

这些内容具有时效性, 在JAVA或C#的未来版本和不同版本之间可能不适用

 

C#与JAVA的RSA密钥格式不同, 需要转换

RSA加密使用了随机数, 同样的内容和密钥, 每次加密结果内容不一样, 但解密结果一致

 

 

 

JAVA端RSA丶AES加密: 以下内容已经验证

package utils.encrypt;

import sun.misc.*;

import java.io.IOException;

/**
 * BASE64编码(和C#_Convert.ToBase64String方法编码通用)
 */
public class BASE64 {

    private static final BASE64Encoder encoder = new BASE64Encoder();

    private static final BASE64Decoder decoder = new BASE64Decoder();


    public static String encode(byte[] src) {
        return encoder.encode(src);
    }

    public static byte[] decode(String src) {
        try {
            return decoder.decodeBuffer(src);
        } catch (IOException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return null;
    }
}

package utils.encrypt;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Random;

/**
 * AES加解密类  key:密钥_16位长度字符串 iv:偏移值_16位长度字符串
 */
public class AESEncrypt {

    //启用
    public static final boolean enable = true;

    //获取密钥
    public static String createKey() {
        return createKey(16);
    }

    public static String createKey(int length) {
        if (enable) {
            createKeyIgnoreEnable(length);
        }
        return null;
    }

    public static String createKeyIgnoreEnable(int length) {
        return genRandomString(length);
    }

    //加密/key
    public static String encrypt(String source, String key, String iv) {
        if (enable) {
            return encryptIgnoreEnable(source, key, iv);
        }
        return source;
    }
    //加密/key()
    public static String encryptIgnoreEnable(String source, String key, String iv) {
        if (key.length() == 16 && iv != null && iv.length() == 16) {
            try {
                byte[] src = source.getBytes("UTF8");
                src = operation(src, key, iv, Cipher.ENCRYPT_MODE);
                return BASE64.encode(src);
            } catch (Exception e) {
                System.out.println("AESEncryot Error:" + e.getMessage());
                e.printStackTrace();
            }
        }
        return source;
    }

    //解密
    public static String decrypt(String source, String key, String iv) {
        if (enable) {
            return decryptIgnoreEnable(source, key, iv);
        }
        return source;
    }

    public static String decryptIgnoreEnable(String source, String key, String iv) {
        if (key != null && key.length() == 16 && iv != null && iv.length() == 16) {
            try {
                byte[] src = BASE64.decode(source);
                src = operation(src, key, iv, Cipher.DECRYPT_MODE);
                return new String(src, "UTF8");
            } catch (Exception e) {
                System.out.println("AESDecryot Error:" + e.getMessage());
                e.printStackTrace();
            }
        }
        return source;
    }

    private static byte[] operation(byte[] src, String key, String iv, int mode) throws Exception {
        byte[] keyRaw = key.getBytes();
        byte[] ivRaw = iv.getBytes();
        SecretKeySpec keySpec = new SecretKeySpec(keyRaw, "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(ivRaw);

        Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");// "AES/CBC/NoPadding"
        cipher.init(mode, keySpec, ivSpec);
        //加密
        if (mode == Cipher.ENCRYPT_MODE) {
            //长度处理(加密时:textSize必须为blockSize的整倍数)
            int blockSize = cipher.getBlockSize();
            int textSize = src.length;
            if (textSize % blockSize != 0) {
                textSize = textSize + blockSize - (textSize % blockSize);
            }
            byte[] plaintext = new byte[textSize];
            System.arraycopy(src, 0, plaintext, 0, src.length);

            byte[] result = cipher.doFinal(plaintext);
            return result;
        }
        //解密
        byte[] result = cipher.doFinal(src);
        return result;
    }

    //随机字符串源字符串
    private static final String sourceString = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    //生成随机字符串
    private static String genRandomString(final int length) {
        String result = "";
        Random random = new SecureRandom();
        for (int i = 0; i < length; i++) {
            result += sourceString.charAt(random.nextInt(sourceString.length()));
        }
        return result;
    }
}

package utils.encrypt;

import javax.crypto.Cipher;
import java.io.*;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSA加解密类(分段加密)
 */
public class RSAEncrypt {

    //启用
    public static final boolean enable = true;
    //密钥长度
    public static final int KEYLENGTH = 1024;
    //最大加密长度=KEYLENGTH/8-11
    public static final int MAXENCRYPTSIZE = 117;
    //最大解密长度=KEYLENGTH/8
    public static final int MAXDECRYPTSIZE = 128;

    //获取密钥
    public static RSAKey createKey() {
        if (enable) {
            return createKeyIgnoreEnable();
        }
        return new RSAKey();
    }

    public static RSAKey createKeyIgnoreEnable() {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            // 初始化密钥对生成器，密钥大小为96-1024位
            keyPairGen.initialize(KEYLENGTH, new SecureRandom());
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            //得到密钥字符串
            RSAKey key = new RSAKey();
            key.publicKey = BASE64.encode(publicKey.getEncoded());
            key.privateKey = BASE64.encode(privateKey.getEncoded());
            return key;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return new RSAKey();
    }

    //加密
    public static String encript(String source, String key) {
        if (enable) {
            return encriptIgnoreEnable(source, key, KEYLENGTH);
        }
        return source;
    }

    //解密
    public static String decript(String source, String key) {
        if (enable) {
            return decriptIgnoreEnable(source, key, KEYLENGTH);
        }
        return source;
    }

    //加密(忽略enable)
    public static String encriptIgnoreEnable(String source, String key, int keyLength) {
        if (key != null && !key.equals("")) {
            try {
                byte[] src = source.getBytes("UTF8");
                //RSA加密
                byte[] decoded = BASE64.decode(key);  //BSAE64解码
                RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
                src = encript(src, pubKey, keyLength);
                //BASE64编码
                return BASE64.encode(src);
            } catch (Exception e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            }
        }
        return source;
    }

    //解密(忽略enable)
    public static String decriptIgnoreEnable(String source, String key, int keyLength) {
        if (key != null && !key.equals("")) {
            try {
                byte[] src = BASE64.decode(source);
                //RSA加密
                byte[] decoded = BASE64.decode(key);  //BSAE64解码
                RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
                src = decript(src, priKey, keyLength);
                //BASE64编码
                return new String(src, "UTF8");
            } catch (Exception e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            }
        }
        return source;
    }

    private static byte[] encript(byte[] src, RSAPublicKey key, int keyLength) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        //分段加密
        byte[] cache;
        int offset = 0;
        int length = src.length;
        int maxEncryptLength = (int) (keyLength / 8 - 11);
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        int i = 0;
        while (length - offset > 0) {
            if (length - offset > maxEncryptLength) {
                cache = cipher.doFinal(src, offset, maxEncryptLength);
            } else {
                cache = cipher.doFinal(src, offset, length - offset);
            }
            outStream.write(cache, 0, cache.length);
            i++;
            offset = i * maxEncryptLength;
        }
        return outStream.toByteArray();
    }

    private static byte[] decript(byte[] src, RSAPrivateKey key, int keyLength) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, key);
        //分段解密
        byte[] cache;
        int offset = 0;
        int length = src.length;
        int maxDecryptLength = (int) (keyLength / 8);
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        int i = 0;
        while (length - offset > 0) {
            if (length - offset > maxDecryptLength) {
                cache = cipher.doFinal(src, offset, maxDecryptLength);
            } else {
                cache = cipher.doFinal(src, offset, length - offset);
            }
            outStream.write(cache, 0, cache.length);
            i++;
            offset = i * maxDecryptLength;
        }
        return outStream.toByteArray();
    }

    public static class RSAKey {
        public String publicKey;
        public String privateKey;
    }
}

JAVA端RSAKeyConvert类: 这些内容还未验证

package utils.encrypt;

import java.math.BigInteger;
import java.security.Key;
import java.security.KeyFactory;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSA密钥Convert类
 */
public class RSAKeyConvert {

    //根据RSA标准密钥的mudulus丶exponent提取JAVA可用密钥
    public static String getRSAKey(final String mudulus, final String exponent, final boolean isPrivateKey) {
        try {
            //Base64解码
            byte[] m = BASE64.decode(mudulus);
            byte[] e = BASE64.decode(exponent);
            BigInteger b1 = new BigInteger(1, m);
            BigInteger b2 = new BigInteger(1, e);
            //获取密钥
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            Key key;
            if (isPrivateKey) {
                RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
                key = (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } else {
                RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(b1, b2);
                key = (RSAPrivateKey) keyFactory.generatePrivate(priKeySpec);
            }
            //BASE64编码并返回
            return BASE64.encode(key.getEncoded());
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

    public static String getRSAPublicKeyJavaAsNet(String publicKey){
        byte[] encoded = BASE64.decode(publicKey);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
            RSAPublicKey  pvkKey = (RSAPublicKey) keyFactory.generatePublic(new X509EncodedKeySpec(encoded));
            //Buffer
            StringBuffer buffer = new StringBuffer(1024);
            buffer.append("<RSAKeyValue>");

            buffer.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");

            buffer.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent().toByteArray()))
                    + "</Exponent>");

            buffer.append("</RSAKeyValue>");
            return buffer.toString().replaceAll("[ \t\n\r]","");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

    public static String getRSAPrivateKeyJavaAsNet(String privateKey) {
        byte[] encoded = BASE64.decode(privateKey);
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory.generatePrivate(keySpec);
            //Buffer
            StringBuffer buffer = new StringBuffer(1024);
            buffer.append("<RSAKeyValue>");

            buffer.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");

            buffer.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent().toByteArray()))
                    + "</Exponent>");

            buffer.append("<P>"
                    + b64encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))
                    + "</P>");

            buffer.append("<Q>"
                    + b64encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))
                    + "</Q>");

            buffer.append("<DP>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentP().toByteArray()))
                    + "</DP>");

            buffer.append("<DQ>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentQ().toByteArray()))
                    + "</DQ>");

            buffer.append("<InverseQ>"
                    + b64encode(removeMSZero(pvkKey.getCrtCoefficient().toByteArray()))
                    + "</InverseQ>");

            buffer.append("<D>"
                    + b64encode(removeMSZero(pvkKey.getPrivateExponent().toByteArray()))
                    + "</D>");

            buffer.append("</RSAKeyValue>");
            return buffer.toString().replaceAll("[ \t\n\r]","");
        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

    private static byte[] removeMSZero(byte[] data) {
        byte[] data1;
        int len = data.length;
        if (data[0] == 0) {
            data1 = new byte[data.length - 1];
            System.arraycopy(data, 1, data1, 0, len - 1);
        } else
            data1 = data;
        return data1;
    }

    private static String b64encode(byte[] data) {
        return BASE64.encode(data);
    }

}

 

 

 

C#端RSA丶AES加密: 以下内容已经验证

关键字:C# Unity XLua 加密

using System;
using System.Collections;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

/// <summary>
/// key:密钥_16位长度字符串 iv:偏移值_16位长度字符串
/// </summary>
[XLua.LuaCallCSharp]
public static class AESEncrypt
{
    public static bool enable = true;

    /// <summary>
    /// 获取随机密钥字符串(16位长度)
    /// </summary>
    public static string CreateKey(int length = 16)
    {
        if (enable)
        {
            return GenRandomString(length);
        }
        return null;
    }

    //加密
    public static string Encrypt(string source, string key, string iv)
    {
        if (enable && key != null && iv != null && key.Length == 16 && iv.Length == 16)
        {
            byte[] src = Encoding.Default.GetBytes(source);
            src = Operation(src, key, iv, true);
            return Convert.ToBase64String(src);
        }
        return source;
    }
    //解密
    public static string Decrypt(string source, string key, string iv)
    {
        if (enable && key != null && iv != null && key.Length == 16 && iv.Length == 16)
        {
            byte[] src = Convert.FromBase64String(source);
            src = Operation(src, key, iv, false);
            return Encoding.Default.GetString(src);
        }
        return source;
    }

    private static byte[] Operation(byte[] src, string key, string iv, bool isEncrypt)
    {
        byte[] keyRaw = Encoding.UTF8.GetBytes(key);
        byte[] ivRaw = Encoding.UTF8.GetBytes(iv);
        if (keyRaw.Length > 16)
        {
            byte[] temp = new byte[16];
            Array.Copy(keyRaw, temp, 16);
            keyRaw = temp;
        }
        RijndaelManaged cipher = new RijndaelManaged();
        cipher.Mode = CipherMode.CBC;
        cipher.Padding = PaddingMode.Zeros;
        cipher.KeySize = 128;
        cipher.BlockSize = 128;
        cipher.Key = keyRaw;
        cipher.IV = ivRaw;
        ICryptoTransform cTransform = isEncrypt ? cipher.CreateEncryptor() : cipher.CreateDecryptor();
        byte[] result = cTransform.TransformFinalBlock(src, 0, src.Length);
        cTransform.Dispose();
        cipher.Dispose();
        return result;
    }

    //随机字符串源字符串
    private const string sourceString = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    //生成随机字符串
    private static string GenRandomString(int length)
    {
        string result = "";
        for (int i = 0; i < length; i++)
        {
            result += sourceString[UnityEngine.Random.Range(0, sourceString.Length)];
        }
        return result;
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

[XLua.LuaCallCSharp]
public static class RSAEncrypt
{
    public static bool enable = true;
    //密钥长度
    public static int KEYLENGTH { get; private set; } = 1024;
    //最大加密长度
    public static int MAXENCRYPTSIZE { get; private set; } = 117;
    //解密最大长度
    public static int MAXDECRYPTSIZE { get; private set; } = 128;

    public static RSAKey CreateKey()
    {
        RSACryptoServiceProvider provider = new RSACryptoServiceProvider(KEYLENGTH);
        return new RSAKey()
        {
            publicKey = provider.ToXmlString(false),
            privateKey = provider.ToXmlString(true)
        };
    }

    public static void SetKeyLength(int keyLength)
    {
        if (keyLength != 512 && keyLength != 1024 && keyLength != 2048&& keyLength!=4096)
        {
            throw new Exception("RSAKey.Length must is 512/1024/2048/4096");
        }
        KEYLENGTH = keyLength;
        MAXDECRYPTSIZE = KEYLENGTH / 8;
        MAXENCRYPTSIZE = MAXDECRYPTSIZE - 11;
    }

    //加密
    public static string Encrypt(string source, string publicKey)
    {
        if (enable)
        {
            byte[] src = Encoding.Default.GetBytes(source);
            src = Encrypt(src, publicKey);
            return Convert.ToBase64String(src);
        }
        return source;
    }
    //解密
    public static string Decrypt(string source, string privateKey)
    {
        if (enable)
        {
            byte[] src = Convert.FromBase64String(source);
            src = Decrypt(src, privateKey);
            return Encoding.Default.GetString(src);
        }
        return source;
    }

    private static byte[] Encrypt(byte[] src, string publicKey)
    {
        RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
        provider.FromXmlString(publicKey);
        int i = 0;  //分段序号
        int offset = 0; //偏移值
        int length = src.Length;    //数据长度
        List<byte> data = new List<byte>();
        while (length - offset > 0)
        {
            byte[] cache;
            if (length - offset > MAXENCRYPTSIZE)
            {
                cache = provider.Encrypt(GetSplit(src, offset, MAXENCRYPTSIZE), false);
            }
            else
            {
                cache = provider.Encrypt(GetSplit(src, offset, length - offset), false);
            }
            i++;
            data.AddRange(cache);
            offset = i * MAXENCRYPTSIZE;
        }
        return data.ToArray();
    }
    private static byte[] Decrypt(byte[] src, string privateKey)
    {
        RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
        provider.FromXmlString(privateKey);
        int i = 0;  //分段序号
        int offset = 0; //偏移值
        int length = src.Length;    //数据长度
        List<byte> data = new List<byte>();
        while (length - offset > 0)
        {
            byte[] cache;
            if (length - offset > MAXDECRYPTSIZE)
            {
                cache = provider.Decrypt(GetSplit(src, offset, MAXDECRYPTSIZE), false);
            }
            else
            {
                cache = provider.Decrypt(GetSplit(src, offset, length - offset), false);
            }
            i++;
            data.AddRange(cache);
            offset = i * MAXDECRYPTSIZE;
        }
        return data.ToArray();
    }

    private static byte[] GetSplit(byte[] input, int offset, int length)
    {
        byte[] output = new byte[length];
        for (int i = offset; i < offset + length; i++)
        {
            output[i - offset] = input[i];
        }
        return output;
    }

    [XLua.LuaCallCSharp]
    public class RSAKey
    {
        public string publicKey;
        public string privateKey;
    }
}


using System;
using System.Xml;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;

/**
 * 依赖于BouncyCastle Crypto.dll开源加密库
 * 官网地址:http://www.bouncycastle.org/csharp/
 */
[XLua.LuaCallCSharp]
public static class RSAKeyConvert
{
    public static string RSAPrivateKeyJava2DotNet(string privateKey)
    {
        RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));

        return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
            Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
            Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
    }

    public static string RSAPrivateKeyDotNet2Java(string privateKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(privateKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
        BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
        BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
        BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
        BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));

        RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);

        PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
        byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
        return Convert.ToBase64String(serializedPrivateBytes);
    }

    public static string RSAPublicKeyJava2DotNet(string publicKey)
    {
        RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
        return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
                     Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
                     Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
    }

    public static string RSAPublicKeyDotNet2Java(string publicKey)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(publicKey);
        BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
        BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
        RsaKeyParameters pub = new RsaKeyParameters(false, m, p);

        SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
        byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
        return Convert.ToBase64String(serializedPublicBytes);
    }
}

 

C#中的AES加密与解密：从新手到高手
java专栏
09-21 841
通过以上的步骤，你现在可以使用C#来实现AES加密和解密了。AES不仅可以保护你的数据安全，还可以为你的应用程序增加额外的安全层。AES 加密是一种强大的加密技术，它可以有效地保护你的数据安全。希望这篇俏皮可爱的指南能够帮助你掌握AES加密的基本用法。记得在实践中不断尝试和完善，享受编程的乐趣！（注：实际上并未展示图片，如需进一步的帮助或有其他问题，随时告诉我哦！以上就是如何使用C#来实现AES加密与解密的完整指南。希望这些详细的步骤和代码示例能帮助你轻松上手。
C#实现RSA加密解密
weixin_30911809的博客
06-15 4487
RSA介绍 RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。 RSA的缺点: 产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。 分组长度太大，为保证安全性，n 至少也要 600bits以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级...
csharp 调用 java_C#调用java程序
weixin_33252145的博客
02-15 645
前言：最近跟项目组的人合作一个项目，由于之前我用的是java写的一个与android通信的程序，现在另一个同事来编写界面程序，由于C#编写起来比较方便，而我又不想重新写之前java的那段代码，于是需要使用C#来调用java程序。正文：一、所需工具(1)ikvm(下载地址:http://www.ikvm.net/)(2)eclipse二、具体步骤1、在eclipse编写java程序packageco...
RSA-csharp.rar
08-21
RSA加密解密
C#RSA加密解密
weixin_33913377的博客
07-21 100
首先是密钥对的生成 /// <summary> /// 生成公钥、私钥 /// </summary> /// <returns>公钥、私钥，公钥键"PUBLIC",私钥键"PRIVATE"</returns> public Dictionary<string...
RSA.zip_RSA CSharp _RSA算法实例_RSA解密_rsa_rsa加密解密
09-22
RSA算法是一种非对称加密算法，它在信息安全领域有着广泛的应用，特别是在数据加密、数字签名以及安全网络通信中。在C#编程环境下，我们可以利用.NET框架提供的类库来实现RSA算法。下面将详细介绍RSA算法的基本原理...
CAES.rar_C加密_Encryption c#_caes_加密_加密算法
09-19
以下是一段基本的C# AES加密代码示例： ```csharp using System; using System.IO; using System.Security.Cryptography; public class AesExample { public static void EncryptFile(string inputFile, string ...
Rsa加签验签，加密解密（对接java，亲测，好用）.7z
08-06
RSA是一种非对称加密算法，广泛应用于网络安全领域，如数据加密、数字签名和密钥交换。在C#和Java之间进行通信时，由于两者都支持RSA算法，可以通过公钥加密和私钥解密来实现安全的数据传输。本教程将详细阐述如何在...
C#程序Mac地址AES加密及解密
07-29
下面是一个基本的AES加密和解密的C#示例： ```csharp using System; using System.IO; using System.Security.Cryptography; using System.Text; public static void Encrypt(string plainText, string key, ...
AES java 与 C#加密解密
01-08
AES（Advanced Encryption Standard），即高级加密标准，是一种广泛使用的对称加密算法，适用于保护敏感信息。本主题将深入探讨AES在Java和C#中的实现，以及如何在两个平台上实现互操作性。 AES的工作原理基于替换...
Java与C#能共通的加密方式-AES
02-19
Java与C#能共通的加密方式-AES範例，不需要另外加library就可以使用。
C# RSA加密解密
04-15
C#做的RSA加密解密， 带winform界面， 测试通过， 代码完整。
RSA加密解密(C#)实现
02-04
RSA加密解密C#实现调用实例 public string RSAEncrypt(string xmlPublicKey, string m_strEncryptString) { try { byte[] PlainTextBArray; byte[] CypherTextBArray; string Result; System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(xmlPublicKey); PlainTextBArray = (new UnicodeEncoding()).GetBytes(m_strEncryptString); CypherTextBArray = rsa.Encrypt(PlainTextBArray, false); Result = Convert.ToBase64String(CypherTextBArray); return Result; } catch (Exception ex) { throw ex; } } //RSA的加密函数 public string RSAEncrypt(string xmlPublicKey, byte[] EncryptString) { try { byte[] CypherTextBArray; string Result; System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); rsa.FromXmlString(xmlPublicKey); CypherTextBArray = rsa.Encrypt(EncryptString, false); Result = Convert.ToBase64String(CypherTextBArray); return Result; } catch (Exception ex) { throw ex; } }
C# RSA加密、支持JAVA格式公钥私钥
04-30
C# RSA加密、支持JAVA格式公钥私钥，亲测很有用，真实有效，拒绝骗子，拒绝坑货，20分甩卖。
如何实现一个高性能的Socket后端 (C#,CSharp)
weixin_40333655的博客
04-26 1655
转载地址http://blog.sina.com.cn/s/blog_53b839dd0100pdg4.html 当你要创建一个对象,最好不要在事件监听函数,循环调用的函数中创建,因为只要函数体不释放,新创建的对象也永远不释放,结果造成内存泄露. 当你想用多线程去加速你的事务处理, 但你最好不要这么做,因为IOCP 已经实现了这功能,每一个接收到的Socket都是在一个独立的Thread运行的,如...
c# RAS 非对称加密
ikmb的专栏
03-16 1934
protected void Page_Load(object sender, EventArgs e)        {            //私钥            string pri = "";            //公钥            string pub = "";            //明文            string m = "I love
C# RAS 加密与解密讲解
u012943521的博客
08-30 4453
RSA加密算法 在谈RSA加密算法之前，我们需要先了解下两个专业名词，对称加密和非对称加密。 对称加密即：含有一个称为密钥的东西，在消息发送前使用密钥对消息进行加密，在对方收到消息之后，使用相同的密钥进行解密 非对称加密即：加密和解密使用不同的密钥的一类加密算法。这类加密算法通常有两个密钥A和B，使用密钥A加密数据得到的密文，只有密钥B可以进行解密操作（即使密钥A也无法解密），相反，使用了密...
C#实现RSA加密DEMO演示与JAVA公钥使用示例
4. RSA加密通常用于加密小块数据，如密钥和哈希值，对于大量数据的加密，建议使用对称加密算法（如AES）配合RSA加密生成的密钥进行。 通过以上知识点的介绍，我们可以了解到在C#环境下，如何使用Java提供的公钥进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值