android实现RSA公钥加密私钥解密工具类

最新推荐文章于 2023-06-21 16:30:07 发布
最新推荐文章于 2023-06-21 16:30:07 发布
阅读量2.9k 收藏 2
点赞数
文章标签： android rsa 解密 加密 class 
/**
 * RSA算法，实现数据的加密解密。 
 */
public class RSAUtil {

    /**
     *  使用私钥解密
     * @param content
     * @param private_key
     * @param input_charset
     * @return
     * @throws Exception
     */
    public static String decrypt(String content, String private_key, String input_charset) throws Exception {
        PrivateKey prikey = getPrivateKey(private_key);

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, prikey);

        InputStream ins = new ByteArrayInputStream(Base64Util.decode(content));
        ByteArrayOutputStream writer = new ByteArrayOutputStream();
        byte[] buf = new byte[128];
        int bufl;

        while ((bufl = ins.read(buf)) != -1) {
            byte[] block = null;

            if (buf.length == bufl) {
                block = buf;
            } else {
                block = new byte[bufl];
                for (int i = 0; i < bufl; i++) {
                    block[i] = buf[i];
                }
            }

            writer.write(cipher.doFinal(block));
        }

        return new String(writer.toByteArray(), input_charset);
    }

    /**
     * 获得私钥
     *
     * @param key
     *            私钥
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String key) throws Exception {

        byte[] keyBytes;

        keyBytes = Base64Util.decode(key);

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

        return privateKey;
    }

    /**
     * 得到公钥
     *
     * @param bysKey
     * @return
     */
    private static PublicKey getPublicKeyFromX509(String bysKey) throws NoSuchAlgorithmException, Exception {
        byte[] decodedKey = Base64Util.decode(bysKey);
        X509EncodedKeySpec x509 = new X509EncodedKeySpec(decodedKey);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(x509);
    }

    /**
     * 使用公钥加密
     *
     * @param content 密文
     * @param pub_key 公钥
     * @return
     */
    public static String encryptByPublic(String content, String pub_key) {
        try {
            PublicKey pubkey = getPublicKeyFromX509(pub_key);

            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, pubkey);

            byte plaintext[] = content.getBytes("UTF-8");
            byte[] output = cipher.doFinal(plaintext);

            String s = new String(Base64Util.encode(output));

            return s;

        } catch (Exception e) {
            return null;
        }
    }
}

 



 



 

public final class Base64Util {

    static private final int     BASELENGTH           = 128;
    static private final int     LOOKUPLENGTH         = 64;
    static private final int     TWENTYFOURBITGROUP   = 24;
    static private final int     EIGHTBIT             = 8;
    static private final int     SIXTEENBIT           = 16;
    static private final int     FOURBYTE             = 4;
    static private final int     SIGN                 = -128;
    static private final char    PAD                  = '=';
    static private final boolean fDebug               = false;
    static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
    static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];

    static {
        for (int i = 0; i < BASELENGTH; ++i) {
            base64Alphabet[i] = -1;
        }
        for (int i = 'Z'; i >= 'A'; i--) {
            base64Alphabet[i] = (byte) (i - 'A');
        }
        for (int i = 'z'; i >= 'a'; i--) {
            base64Alphabet[i] = (byte) (i - 'a' + 26);
        }

        for (int i = '9'; i >= '0'; i--) {
            base64Alphabet[i] = (byte) (i - '0' + 52);
        }

        base64Alphabet['+'] = 62;
        base64Alphabet['/'] = 63;

        for (int i = 0; i <= 25; i++) {
            lookUpBase64Alphabet[i] = (char) ('A' + i);
        }

        for (int i = 26, j = 0; i <= 51; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('a' + j);
        }

        for (int i = 52, j = 0; i <= 61; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('0' + j);
        }
        lookUpBase64Alphabet[62] = (char) '+';
        lookUpBase64Alphabet[63] = (char) '/';

    }

    private static boolean isWhiteSpace(char octect) {
        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
    }

    private static boolean isPad(char octect) {
        return (octect == PAD);
    }

    private static boolean isData(char octect) {
        return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    }

    /**
     * Encodes hex octects into Base64
     *
     * @param binaryData Array containing binaryData
     * @return Encoded Base64 array
     */
    public static String encode(byte[] binaryData) {

        if (binaryData == null) {
            return null;
        }

        int lengthDataBits = binaryData.length * EIGHTBIT;
        if (lengthDataBits == 0) {
            return "";
        }

        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
        char encodedData[] = null;

        encodedData = new char[numberQuartet * 4];

        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

        int encodedIndex = 0;
        int dataIndex = 0;
        if (fDebug) {
            System.out.println("number of triplets = " + numberTriplets);
        }

        for (int i = 0; i < numberTriplets; i++) {
            b1 = binaryData[dataIndex++];
            b2 = binaryData[dataIndex++];
            b3 = binaryData[dataIndex++];

            if (fDebug) {
                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
            }

            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);

            if (fDebug) {
                System.out.println("val2 = " + val2);
                System.out.println("k4   = " + (k << 4));
                System.out.println("vak  = " + (val2 | (k << 4)));
            }

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
        }

        // form integral number of 6-bit groups
        if (fewerThan24bits == EIGHTBIT) {
            b1 = binaryData[dataIndex];
            k = (byte) (b1 & 0x03);
            if (fDebug) {
                System.out.println("b1=" + b1);
                System.out.println("b1<<2 = " + (b1 >> 2));
            }
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
            encodedData[encodedIndex++] = PAD;
            encodedData[encodedIndex++] = PAD;
        } else if (fewerThan24bits == SIXTEENBIT) {
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
            encodedData[encodedIndex++] = PAD;
        }

        return new String(encodedData);
    }

    /**
     * Decodes Base64 data into octects
     *
     * @param encoded string containing Base64 data
     * @return Array containind decoded data.
     */
    public static byte[] decode(String encoded) {

        if (encoded == null) {
            return null;
        }

        char[] base64Data = encoded.toCharArray();
        // remove white spaces
        int len = removeWhiteSpace(base64Data);

        if (len % FOURBYTE != 0) {
            return null;//should be divisible by four
        }

        int numberQuadruple = (len / FOURBYTE);

        if (numberQuadruple == 0) {
            return new byte[0];
        }

        byte decodedData[] = null;
        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

        int i = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        decodedData = new byte[(numberQuadruple) * 3];

        for (; i < numberQuadruple - 1; i++) {

            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                || !isData((d3 = base64Data[dataIndex++]))
                || !isData((d4 = base64Data[dataIndex++]))) {
                return null;
            }//if found "no data" just return null

            b1 = base64Alphabet[d1];
            b2 = base64Alphabet[d2];
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];

            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
        }

        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
            return null;//if found "no data" just return null
        }

        b1 = base64Alphabet[d1];
        b2 = base64Alphabet[d2];

        d3 = base64Data[dataIndex++];
        d4 = base64Data[dataIndex++];
        if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
            if (isPad(d3) && isPad(d4)) {
                if ((b2 & 0xf) != 0)//last 4 bits should be zero
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 1];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                return tmp;
            } else if (!isPad(d3) && isPad(d4)) {
                b3 = base64Alphabet[d3];
                if ((b3 & 0x3) != 0)//last 2 bits should be zero
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 2];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                return tmp;
            } else {
                return null;
            }
        } else { //No PAD e.g 3cQl
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];
            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

        }

        return decodedData;
    }

    /**
     * remove WhiteSpace from MIME containing encoded Base64 data.
     *
     * @param data  the byte array of base64 data (with WS)
     * @return      the new length
     */
    private static int removeWhiteSpace(char[] data) {
        if (data == null) {
            return 0;
        }

        // count characters that's not whitespace
        int newSize = 0;
        int len = data.length;
        for (int i = 0; i < len; i++) {
            if (!isWhiteSpace(data[i])) {
                data[newSize++] = data[i];
            }
        }
        return newSize;
    }
}


                

        

        

    




    

      

        

            

              
                
                  qq_34697982
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
android rsa 私钥加密解密,Android网络数据传输安全——实现RSA公钥加密私钥解密...

				
			

			

				

					weixin_29233333的博客
				

				

					06-03
					
					1221
					
				

			

		

		

			
				
一，整体流程后台生成一个RSA秘钥对，包括公钥和私钥后台将公钥字符串下发给客户端，然后客户端用此公钥生成一个RSAPublicKey对象，再将手机号密码等数据用此对象加密，客户端将加密的数据发送给后台，后台将加密的数据用私钥解密。image.png二，公私钥你可以利用工具一键生成密钥对访问支付宝官网，进入如下页面，该页面的URL：https://docs.open.alipay.com/291/1...

			
		

	



                

              
                



	

		

			

				
					
android rsa加密工具类,GitHub - Lerist/encrypt: Android 加密解密工具包。

				
			

			

				

					weixin_39928801的博客
				

				

					05-25
					
					778
					
				

			

		

		

			
				
Encrypt(加密工具)字符串，byte[]，文件等对象的加密和解密工具集合，包含了多种加密方案。加密类型摘要相关方法简单加密换一种编码格式Base64Util单向加密只能加密，不能解密MD5Util、SHAUtil对称加密使用相同的秘钥加密和解密AESUtil、DESUtil非对称加密分公钥和私钥，一个加密，另一个解密RSAUtil使用方法Base64util方法摘要String  base6...

			
		

	



                


  
              

                


	

		

			

				
					
Android RSA和AES对称加密工具

					
最新发布

				
			

			

				

					吕氏春秋i
				

				

					06-21
					
					1180
					
				

			

		

		

			
				
最近开发 用到数据加密 研究后要用RSA和AES对称加密工具以前没搞过 记录一下心酸过程。

			
		

	





	

		

			

				
					
Android中Sha1加密和RSA加密解密（记录）

				
			

			

				

					lpCrazyBoy的博客
				

				

					02-15
					
					1821
					
				

			

		

		

			
				
一、SHA-1加密


/**
 * SHA-1加密工具类
 */
public class SHA1Util {

    /**
     * SHA-1加密字符串
     *
     * @param info
     * @return
     */
    public static String getSHA(String info) {
        byte[] byte...

			
		

	



		

			
		



	

		

			

				
					
Android RSA 签名工具类

				
			

			

				

					09-01
				

			

		

		

			
				
文件来自支付宝客户端 Demo，用于使用相应的私钥加密某段密文

			
		

	





	

		

			

				
					
C#  .net版 RSA 公钥加密私钥解密 私钥加密公钥解密

				
			

			

				

					02-15
				

			

		

		

			
				
总的来说，RSA算法在C# .NET中的实现涉及到了密钥对的生成、公钥加密、私钥解密等核心操作，理解这些概念对于开发安全的应用程序至关重要。在实际应用中，还需要考虑数据完整性校验、密钥管理等额外的安全措施。通过...

			
		

	





	

		

			

				
					
C# RSA 公钥加密，私钥解密

				
			

			

				

					04-20
				

			

		

		

			
				
总结来说，C#中的RSA公钥加密和私钥解密是通过RSACryptoServiceProvider类实现的，它为开发者提供了加密和解密的便捷接口。在VS2017这样的开发环境中，我们可以方便地构建这样的系统，确保数据在传输过程中的安全。

			
		

	





	

		

			

				
					
Java 公钥和私钥加密解密代码

				
			

			

				

					02-09
				

			

		

		

			
				
在Java编程语言中，公钥和私钥加密解密是一种重要的...总的来说，Java的公钥和私钥加密解密功能为开发安全的应用提供了强大的工具。通过理解这些基本概念和代码示例，开发者能够更好地保护数据，确保网络通信的安全。

			
		

	





	

		

			

				
					
RSA生成公钥私钥和使用公钥私钥加密解密demo

				
			

			

				

					05-26
				

			

		

		

			
				
本示例提供了一个RSA加密工具类，用于生成公钥和私钥，并使用它们进行加密和解密操作，这对于保护数据库中的敏感信息，如密码，是非常必要的。  1. **RSA算法原理**：  RSA算法基于数论中的大数因子分解难题。其基本...

			
		

	





	

		

			

				
					
Java公钥加密私钥解密.rar

				
			

			

				

					11-08
				

			

		

		

			
				
这个名为"Java公钥加密私钥解密.rar"的压缩包文件包含了一个使用Java实现的公钥/私钥加密解密的示例。在这个案例中，开发者可能使用了Java的Java Cryptography Extension (JCE) 来实现RSA算法，这是一种非对称加密...

			
		

	





	

		

			

				
					
RSAUtils工具类

				
			

			

				

					05-24
				

			

		

		

			
				
RSAUtils工具类,有公钥生成方法，可以直接下载使用！使用模和指数生成RSA公钥

			
		

	





	

		

			

				
					
RSAUtils.zip

				
			

			

				

					12-08
				

			

		

		

			
				
jsp服务器和js客户端RSA非对称加密技术。

			
		

	





	

		

			

				
					
Android，java实现RSA加密

				
			

			

				

					07-23
				

			

		

		

			
				
RSA加密算法，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。在公开密钥密码体制中，加密密钥（即公开密钥）PK是公开信息，而解密密钥（即秘密密钥）SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的，由于无法计算出大数n的欧拉函数phi(N)，所以不能根据PK计算出SK。本资源是通过Android、java实现的RSA加密的例子，可供大家参考学习。

			
		

	





	

		

			

				
					
Android RSA加密jar包

				
			

			

				

					11-01
				

			

		

		

			
				
Android RSA加密jar包，提供RSA加密与解密的java类，便于开发使用。

			
		

	





	

		

			

				
					
androidRSA加密

				
			

			

				

					10-30
				

			

		

		

			
				
RSA封装类 ，完整的RSA加密和解密
public class RSAUtilEncrypt {
	public static final String KEY_ALGORTHM = "RSA";//
	public static final String KEY_ALGORTHM_RSA_ECB_PKCS1PADDING = "RSA/ECB/PKCS1Padding";
	public static String RSA_PUBLIC_KEY = "rsa_public_key";
	public static String RSA_PRIVATE_KEY = "rsa_private_key";
	private int KeySize = 1024;
	private Map keyMap;
	private static String RSA = "RSA";
	private static PublicKey publickey;

	public RSAUtilEncrypt(int KeySize,String publickey) {
		this.KeySize = KeySize;
		try {
			this.publickey=generatePublicKeyByString(publickey);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}
	
	

	private RSAPublicKey generatePublicKeyByString(String publicKeyStr)
			throws Exception {
		try {
			BASE64Decoder base64Decoder = new BASE64Decoder();
			byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr);
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
			return (RSAPublicKey) keyFactory.generatePublic(keySpec);
		} catch (NoSuchAlgorithmException e) {
			throw new Exception("No Algorthm,Checked by cemung!");
		} catch (InvalidKeySpecException e) {
			throw new Exception("InvalidKeySpec!");
		} catch (IOException e) {
			throw new Exception("Io exception!");
		} catch (NullPointerException e) {
			throw new Exception("Illegle pointer reference!");
		}

	}



	// Encypt
	public byte[] RSAEncrypt(byte[] data, RSAPublicKey publickey)
			throws Exception {
		Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING);
		cipher.init(Cipher.ENCRYPT_MODE, this.publickey);
		byte[] cipherbytes = cipher.doFinal(data);
		return cipherbytes;

	}
	
	// Encypt
	public byte[] RSAEncrypt(byte[] data)
			throws Exception {
		Cipher cipher = Cipher.getInstance(KEY_ALGORTHM_RSA_ECB_PKCS1PADDING);
		cipher.init(Cipher.ENCRYPT_MODE, this.publickey);
		byte[] cipherbytes = cipher.doFinal(data);
		return cipherbytes;

	}



	// Get Public key with format byte[]
	public byte[] getPublicKeyByte() {
		RSAPublicKey pubkey = (RSAPublicKey) keyMap.get(RSA_PUBLIC_KEY);
		return pubkey.getEncoded();
	}


	public static byte[] decryptBASE64(String key) throws Exception {
		return (new BASE64Decoder()).decodeBuffer(key);
	}


	public static String encryptBASE64(byte[] key) throws Exception {
		return (new BASE64Encoder()).encodeBuffer(key);
	}





	public static byte[] decryptByPrivateKey(byte[] data, String key)
			throws Exception {
		byte[] keyBytes = decryptBASE64(key);

		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
				keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}


	public static byte[] encryptByPublicKey(byte[] data, String key)
			throws Exception {
		byte[] keyBytes = decryptBASE64(key);
		X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}


	public static byte[] decryptByPublicKey(byte[] data, String key)
			throws Exception {
		byte[] keyBytes = decryptBASE64(key);
		X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}



使用方法


	private RSAUtilEncrypt 	rsa = new RSAUtilEncrypt(1024, publikey);
	/*
	 * 给信息加密,获取密文
	 */
	public String getCiphertext(String str_encrode) {
		try {
			byte[] estr = rsa.RSAEncrypt(str_encrode.getBytes());
			// 密文
			String ciphertext = Base64.encodeToString(estr, Base64.DEFAULT);
			return ciphertext;

		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;

	}

有疑问的留言

			
		

	





	

		

			

				
					
Android  RSA加密解密

				
			

			

				

					打字打不快的屌丝
				

				

					09-17
					
					1536
					
				

			

		

		

			
				
转载自： http://blog.csdn.net/bbld_/article/details/38777491

			
		

	





	

		

			

				
					
RSAUtil

				
			

			

				

					由零开始。
				

				

					08-03
					
					2798
					
				

			

		

		

			
				
RSA

			
		

	





	

		

			

				
					
android rsa 示例

				
			

			

				

					banyinlve3147的博客
				

				

					03-05
					
					196
					
				

			

		

		

			
				
1.参考资料
1.1 android的Cipher官方文档
　　https://developer.android.com/reference/javax/crypto/Cipher
　　其中 构造Cipher实例时要提供加密算法参数transformation 它的格式有两种：


"algorithm/mode/padding"
"algorithm"


　...

			
		

	





	

		

			

				
					
Android RSA加密

				
			

			

				

					weixin_41315081的博客
				

				

					04-29
					
					1966
					
				

			

		

		

			
				
Android RSA加密，通过模数和指数生成公钥，再通过公钥进行加密1.RSA加密简介2.废话不说，先上结果3.首先我们先通过模数和指数获取公钥2.然后我们通过生成的公钥来对字符串进行加密[通过RSA的模数和指数获取公钥然后对字符串进行加密的Demo](https://github.com/17801094126/RSADemo)
1.RSA加密简介
RSA加密算法是一种非对称加密算法,是目前最...

			
		

	





	

		

			

				
					
hutool 公钥加密私钥解密

				
			

			

				

					04-01
				

			

		

		

			
				
要使用Hutool进行公钥加密私钥解密，需要使用Java Cryptography Extension (JCE)提供的加密算法，同时需要使用Bouncy Castle提供的加密库。  下面是一个简单的示例代码，用于使用Hutool进行公钥加密私钥解密：  ```...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值