RSA加密解密。包含java与.net互转。已经解密会出现URL转码问题解决

最新推荐文章于 2023-01-07 16:58:03 发布
最新推荐文章于 2023-01-07 16:58:03 发布
阅读量542 收藏
点赞数
分类专栏： java  .net加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34917069/article/details/102915194
版权 
俩个雷体。公钥加密，私钥解密。客户端服务端各有一套公钥私钥。客户端的公钥加密，使用服务端的私钥解密。代码是一样的。就是秘钥不同。
package com.pcitc.aims.project.common;

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateCrtKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.Base64;


public class RSA {

       public final static String publicKey ="";

       public final static String privateKey ="";

    public static void main(String[] args) {

      String javaPublicKey = publicKeyFromXml(publicKey);
      String javaPrivateKey = privateKeyFromXml(privateKey);

      System.out.println("公钥.java: \n\r" + javaPublicKey);
      System.out.println("私钥.java: \n\r" + javaPrivateKey);

        String token1 = URLDecoderString(ticket);
        String userInfo = RSAUtil.privateDecrypt(token1.trim(),javaPrivateKey);

        System.out.println("88888------------"+userInfo);
        try {

            String miyao ="D15693F7-9ECA-4144-B41D-400E0963E967";
            String token = RSAUtil.publicEncrypt(miyao, RSAUtil.getPublicKey(javaPublicKey));
            System.out.println("token============"+getURLEncoderString(token));
        } catch (Exception e) {
            e.printStackTrace();
        }


//    System.out.println("解析後：" + a);
//    System.out.println("解析後：" + a.length());
//    System.out.println("解析後：qujiabaogege");

   }

    /**
     * 解码
     * @param str
     * @return
     */
    public static String URLDecoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLDecoder.decode(str, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 转码
     * @param str
     * @return
     */
    public static String getURLEncoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLEncoder.encode(str, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }

   /**
    * java私钥转换成C#私钥
    */
   public static String privateKeyToXml(RSAPrivateCrtKey privateKey) {

      String modulusBase64 = Base64.getEncoder().encodeToString(privateKey.getModulus().toByteArray());
      String modulus = modulusBase64.replace("\r", "").replace("\n", "");

      String exponentBase64 = Base64.getEncoder()
            .encodeToString(privateKey.getPublicExponent().toByteArray());
      String exponent = exponentBase64.replace("\r", "").replace("\n", "");

      String pBase64 = Base64.getEncoder().encodeToString(privateKey.getPrimeP().toByteArray());
      String p = pBase64.replace("\r", "").replace("\n", "");

      String qBase64 = Base64.getEncoder().encodeToString(privateKey.getPrimeQ().toByteArray());
      String q = qBase64.replace("\r", "").replace("\n", "");

      String dpBase64 = Base64.getEncoder().encodeToString(privateKey.getPrimeExponentP().toByteArray());
      String dp = dpBase64.replace("\r", "").replace("\n", "");

      String dqBase64 = Base64.getEncoder().encodeToString(privateKey.getPrimeExponentQ().toByteArray());
      String dq = dqBase64.replace("\r", "").replace("\n", "");

      String dBase64 = Base64.getEncoder().encodeToString(privateKey.getPrivateExponent().toByteArray());
      String d = dBase64.replace("\r", "").replace("\n", "");

      String inverseQBase64 = Base64.getEncoder()
            .encodeToString(privateKey.getCrtCoefficient().toByteArray());
      String inverseQ = inverseQBase64.replace("\r", "").replace("\n", "");

      StringBuilder stringBuilder = new StringBuilder();
      stringBuilder.append("<RSAKeyValue>\n");
      stringBuilder.append("<Modulus>").append(modulus).append("</Modulus>\n");
      stringBuilder.append("<Exponent>").append(exponent).append("</Exponent>\n");
      stringBuilder.append("<P>").append(p).append("</P>\n");
      stringBuilder.append("<Q>").append(q).append("</Q>\n");
      stringBuilder.append("<DP>").append(dp).append("</DP>\n");
      stringBuilder.append("<DQ>").append(dq).append("</DQ>\n");
      stringBuilder.append("<InverseQ>").append(inverseQ).append("</InverseQ>\n");
      stringBuilder.append("<D>").append(d).append("</D>\n");
      stringBuilder.append("</RSAKeyValue>");
      return stringBuilder.toString();
   }

   /**
    * java公钥转换成C#公钥
    */
   public static String publicKeyToXml(RSAPublicKey publicKey) {
      String modulusBase64 = Base64.getEncoder().encodeToString(publicKey.getModulus().toByteArray());
      String modulus = modulusBase64.replace("\r", "").replace("\n", "");

      String exponentBase64 = Base64.getEncoder()
            .encodeToString(publicKey.getPublicExponent().toByteArray());
      String exponent = exponentBase64.replace("\r", "").replace("\n", "");

      StringBuilder stringBuilder = new StringBuilder();
      stringBuilder.append("<RSAKeyValue>\n");
      stringBuilder.append("<Modulus>").append(modulus).append("</Modulus>\n");
      stringBuilder.append("<Exponent>").append(exponent).append("</Exponent>\n");
      stringBuilder.append("</RSAKeyValue>");
      return stringBuilder.toString();
   }

   /**
    * C#私钥转换成java私钥
    */
   public static String privateKeyFromXml(String privateKeyXml) {
      privateKeyXml = privateKeyXml.replaceAll("\r", "").replaceAll("\n", "");

      KeyFactory keyFactory;
      try {
         String modulusXml = privateKeyXml.substring(privateKeyXml.indexOf("<Modulus>") + 9,
               privateKeyXml.indexOf("</Modulus>"));
         BigInteger modulus = new BigInteger(1, Base64.getDecoder().decode(modulusXml));

         String publicExponentXml = privateKeyXml.substring(privateKeyXml.indexOf("<Exponent>") + 10,
               privateKeyXml.indexOf("</Exponent>"));
         BigInteger publicExponent = new BigInteger(1, Base64.getDecoder().decode(publicExponentXml));

         String privateExponentXml = privateKeyXml.substring(privateKeyXml.indexOf("<D>") + 3,
               privateKeyXml.indexOf("</D>"));
         BigInteger privateExponent = new BigInteger(1, Base64.getDecoder().decode(privateExponentXml));

         String primePXml = privateKeyXml.substring(privateKeyXml.indexOf("<P>") + 3, privateKeyXml.indexOf("</P>"));
         BigInteger primeP = new BigInteger(1, Base64.getDecoder().decode(primePXml));

         String primeQXml = privateKeyXml.substring(privateKeyXml.indexOf("<Q>") + 3, privateKeyXml.indexOf("</Q>"));
         BigInteger primeQ = new BigInteger(1, Base64.getDecoder().decode(primeQXml));

         String primeExponentPXml = privateKeyXml.substring(privateKeyXml.indexOf("<DP>") + 4,
               privateKeyXml.indexOf("</DP>"));
         BigInteger primeExponentP = new BigInteger(1, Base64.getDecoder().decode(primeExponentPXml));

         String primeExponentQXml = privateKeyXml.substring(privateKeyXml.indexOf("<DQ>") + 4,
               privateKeyXml.indexOf("</DQ>"));
         BigInteger primeExponentQ = new BigInteger(1, Base64.getDecoder().decode(primeExponentQXml));

         String crtCoefficientXml = privateKeyXml.substring(privateKeyXml.indexOf("<InverseQ>") + 10,
               privateKeyXml.indexOf("</InverseQ>"));
         BigInteger crtCoefficient = new BigInteger(1, Base64.getDecoder().decode(crtCoefficientXml));

         RSAPrivateCrtKeySpec rsaPriKey = new RSAPrivateCrtKeySpec(modulus, publicExponent, privateExponent, primeP,
               primeQ, primeExponentP, primeExponentQ, crtCoefficient);

         keyFactory = KeyFactory.getInstance("RSA");
         PrivateKey privateKey = keyFactory.generatePrivate(rsaPriKey);
         byte[] bytes = Base64.getEncoder().encode(privateKey.getEncoded());
         return new String(bytes, Charset.forName("utf-8"));
      } catch (Exception e) {
         System.err.println(e.toString());
      }
      return null;
   }

   /**
    * C#公钥转换成java公钥
    */
   public static String publicKeyFromXml(String publicKeyXml) {
      KeyFactory keyFactory;
      publicKeyXml = publicKeyXml.replaceAll("\r", "").replaceAll("\n", "");
      try {
         String modulusXml = publicKeyXml.substring(publicKeyXml.indexOf("<Modulus>") + 9,
               publicKeyXml.indexOf("</Modulus>"));
         BigInteger modulus = new BigInteger(1, Base64.getDecoder().decode(modulusXml));

         String exponentXml = publicKeyXml.substring(publicKeyXml.indexOf("<Exponent>") + 10,
               publicKeyXml.indexOf("</Exponent>"));
         BigInteger publicExponent = new BigInteger(1, Base64.getDecoder().decode(exponentXml));

         RSAPublicKeySpec rsaPubKey = new RSAPublicKeySpec(modulus, publicExponent);
         keyFactory = KeyFactory.getInstance("RSA");
         PublicKey publicKey = keyFactory.generatePublic(rsaPubKey);
         byte[] bytes = Base64.getEncoder().encode(publicKey.getEncoded());
         return new String(bytes, Charset.forName("utf-8"));
      } catch (Exception e) {
         System.err.println(e.toString());
         return null;
      }
   }

}

 

===================================================================================================

package com.pcitc.aims.project.common;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSAUtil {
   public static final String CHARSET = "UTF-8";
    public static final String RSA_ALGORITHM = "RSA"; // ALGORITHM ['ælgərɪð(ə)m] 算法的意思

    public static Map<String, String> createKeys(int keySize) {
        // 为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }

        // 初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        // 生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        // 得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
        // 得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
        // map装载公钥和私钥
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey",privateKeyStr); // 返回map
        return keyPairMap;
    }

    /**
     * 得到公钥
     * @param publicKey  密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * 得到私钥
     * @param privateKey  密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }

    /**
     * 公钥加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String publicEncrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥解密
     * @param
     * @param privateKey
     * @return
     */

    public static String privateDecrypt(String str, String  privateKey) {
       
       try{
           byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
          //base64编码的私钥
          byte[] decoded = Base64.decodeBase64(privateKey);  
            RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));  
          //RSA解密
          Cipher cipher = Cipher.getInstance("RSA");
          cipher.init(Cipher.DECRYPT_MODE, priKey);
          String outStr = new String(cipher.doFinal(inputByte));
          return outStr;
        } catch (Exception e) {
          return "";
       }
       
    }

    /**
     * 私钥加密
     * @param data
     * @param privateKey
     * @return
     */

    public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            //每个Cipher初始化方法使用一个模式参数opmod，并用此模式初始化Cipher对象。此外还有其他参数，包括密钥key、包含密钥的证书certificate、算法参数params和随机源random。
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密
     * @param data
     * @param publicKey
     * @return
     */

    public static String publicDecrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    //rsa切割解码  , ENCRYPT_MODE,加密数据   ,DECRYPT_MODE,解密数据
    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
        int maxBlock = 0;  //最大块
        if (opmode == Cipher.DECRYPT_MODE) {
            maxBlock = keySize / 8;
        } else {
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try {
            while (datas.length > offSet) {
                if (datas.length - offSet > maxBlock) {
                    //可以调用以下的doFinal（）方法完成加密或解密数据：
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
        } catch (Exception e) {
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        }
        byte[] resultDatas = out.toByteArray();
        return resultDatas;
    }
}

 

 

北方的路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#rsa加密java解密_在C＃中使用RSA加密和Java中的解密时出现填充错误
weixin_32179097的博客
02-27 1033
当前，当我使用Java解密用C＃生成的Base64编码的RSA加密字符串时，我收到以下错误：javax.crypto.BadPaddingException: Not PKCS#1 block type 2 or Zero padding通过.NET和Java进行交换之间的设置过程是通过在.NET密钥存储区中创建一个私钥，然后从提取的PEM文件中创建的，使用keytool创建的具有私钥的JKS版本...
.NET使用RSA加密解密的方法
01-20
本文实例为大家分享了.NET使用RSA加密解密的具体代码，供大家参考，具体内容如下 PassWordHelper.cs代码: using System; using System.IO; using System.Text; using System.Globalization; using System....
RSA 数字签名算法（.net版）
weixin_30237281的博客
03-29 272
直接上代码，不BB public class RSASign { public static string RSASignature(string data, string privateKeyPem, string charset, bool keyFromFile, string signType) { ...
java rsa .net_java与.net平台之间进行RSA加密验证
weixin_29350039的博客
02-16 734
RSA加密算法虽然不分平台，标准都是一样的，但是各个平台的实现方式都不尽相同，下面来我来说说java与.net平台之间该如何进行RSA加密验证，即java端加密-》.net端验证和.net端加密-》java端验证。我对RSA算法也只是停留在应用的层面，所以我就以应用的角度来说说这个过程。首先，我们来看一下java端的私钥和公钥的样子：私钥：MIICeQIBADANBgkqhkiG9w0BAQEFA...
RSA的密钥把JAVA格式转换成C#的格式
weixin_30819163的博客
03-31 246
RSA算法在C#与JAVA之前的交互 在JAVA生成一对RSA私钥和公钥的时候，是以下的形式给到C#去调用： stringpublickey = @"MIGfMA0GCSqGSIb4DQEBAQUAA4GNADCBiQKBgQC/M9kJVwi+sO672NBm5fAEbUEl2PqRFuYZVB5ZrKah7eJPP0pKBe/eoA6pOMsjnKFoZGVizz7oCt+TJ+1...
在做sha256_rsa验签时，关于url解码时加号变为空的情况
m0_57661807的博客
10-20 422
做了一个验签的功能，自己用Postman测试的时候是可以正常验签成功的。但是对端怎么都验签不合适，去查了日志才发现， 自己才用Postman请求过来的入参，是合适的。对方请求过来的参数加号变成了空格。 查询了一些资料，应该是应用服务器的内部已经做了一次URL解码，在我代码里我又做了一次解码。第二次解码就会把加号变成空格。于是我尝试将自己代码里的URL解码去掉，测试成功。但Postman请求不会自动解码，所以我只有传解码后的参数才成功，其中原理不明…… 解决办法一就是上面这个了。 或..
常见编码加密解密Base64，URL ，GZIP，DES，RSA等
木子饼干的博客
03-22 2093
常见编码加密解密的基础用法 Base64编码 URL编码 GZIP AES加密 DES加密 RSA加密 public class MainActivity extends AppCompatActivity { private EditText mTextContent; private TextView mTxtResult; private TextVi...
Rsa 加密解密，java 私钥 与 .net私钥互转
04-29
总结来说，实现Java和.NET之间的RSA私钥互转需要理解两种平台对私钥的不同表示方式，利用BouncyCastle库进行转换，并确保加密解密操作的正确性。这是一个涉及到多个步骤的技术挑战，但一旦完成，就能在两个平台上...
Rsa加密解密.rar_RSA 加密解密_java rsa_rsa加密_rsa加密java_加密 解密
07-14
RSA加密解密是一种广泛应用于网络安全领域的非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman三位科学家在1977年提出，因此得名RSA。这种算法基于大整数因子分解的困难性，使得只有持有正确密钥的人才能...
Java RSA 分段加密解密工具 .NET密钥转换
11-25
采用Java Swing技术实现的一个小工具类 请在jre环境下使用
RSA 加密 解密 C# Java 转化.zip
09-15
可以实现C# Rsa加密（私钥加密、公钥解密、密钥格式转换、支持超大长度分段加密）.net 转 java，java 转 .net 比如有一个开放平台：和目平台 亲测可用。他们就是只提供java的密钥，我已成功调用！如果有疑问需要...
RSA JAVA公钥和C#公钥的转换
风过留痕
01-29 3048
RSA JAVA公钥和C#公钥的转换
C#和JAVA的RSA密钥、公钥转换
热门推荐
TxNet
05-22 1万+
C#的秘钥跟JAVA的密钥区别 RSA对于程序本身是没有区别的，其格式都是相同的。对于不同的程序来说，存储使用的语法（包装的类）会有所不同。 RSA语法和语法标准有很多，大的类型大概分为ASN.1、PKCS、X.509。  RSA语法介绍 ASN.1、PKCS是最初的，也是最主要的RSA公钥和私钥的语法标准，被RSA Lab所维护。 ASN.1、PKCS#1都定义了公钥和私钥的类型——序
RSA加密算法在Java与C#中的跨语言密钥转换问题
SeeDoubleU的专栏
06-17 1612
文章目录前言1 算法简介1.1 算法步骤1.2 算法示例2 密钥格式2.1 PEM格式2.2 ASN格式2.3 XML格式2.4 DER格式3 密钥解析（ASN.1）3.1 BER编码规则3.1.1 Tag字段3.1.1.1 通用标签3.1.1.2 非通用标签3.1.2 Length字段3.1.2.1 定长方式短形式长形式3.1.2.2 不定长方式3.1.3 Value字段3.2 公钥解析示例4 源代码总结 前言   前段时间遇到个项目问题，涉及RSA加密，研究了几天，终于解决了，情况是这样的，项目使用的是
Java RSA公钥、私钥与C#RSA公钥、私钥转换
weixin_30912051的博客
02-01 240
最近公司项目需要对接第四方支付接口，但是对方的demo是Java的,给的算法是Java版本的公钥和私钥，如果要做RSA加密就需要将Java的公钥和私钥转换成dotnet版本的公钥和私钥，具体的算法如下： 1 /// <summary> 2 /// RSA私钥格式转换，java->.net 3 /// <...
Base64编码详解与URL安全的Base64编码
Coding home - 漂流瓶jz
07-23 7614
Base64的基本编码方式 base64编码是一种常见的编码方式，主要用于对8bit的字节进行编码。具体的编码方式是： 把三个字节作为一组，转化为二进制的形式，一共3*8=24个二进制位。 例如： abc 三个字符用ASCII编码，转换为二进制： 01100001 01100010 01100011 把24个二进制数字每6个一组，分为4组： 01100001 01100010 01100011 被分为 011000 010110 001001 100011 按照表格，把每组二进制串转为对应字
base64和base64url编解码
lzg_na的博客
01-07 1125
一个字节可以表示256种数值，但是由于一些字节在网络中有特殊的含义。所以当传输字节内容时就不能传输这些具有控制功能的字符。具体的做法就是将这些字符进行转码。ASCII中是可打印字符，所以可以将要传输的字符转码为这个范围内的字符。base64编码就是将255种字节转换为64种进行传输;base64url编码也是将255种字节转换为64种进行传输，与base64选择的字符稍有不同.
C# RSA和Java RSA互通
任薛纪的专栏
12-09 1万+
方法1： 源码：http://download.csdn.net/detail/kith002/4192327#comment Java中有很好的rsa加密与解密类库，同样这些类库也被迁移到了Android的api中，但稍有不同，在java中的base64编码和解码api与Android稍有不同，Android只是简化了一部分操作。如下就将Android中常用的加密和解密的方法总结
我需要一段JAVA与.NET通用的RSA2加解密.NET代码
最新发布
02-19
这里有一段C＃代码，可以用于在JAVA和.NET之间进行RSA2加解密： using System; using System.Security.Cryptography; public class RSA2 { //RSA2加密 public static string RSAEncrypt(string plainText, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值