Java加密解密方法大全(ChinaSEI)
【1】加密概述
〖1-1〗加密的应用
加密是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密 的信息，但因不知解密的方法，仍然无法了解信息的内容。数据加密技术已经广泛应用于 因特网电子商务、手机网络和银行自动取款机等领域。加密系统中有如下重要概念：
1：明文。被隐蔽的消息称作明文（plaintext）。 2：密文。隐蔽后的消息称作密文（ciphertext）。 3．加密。将明文变换成密文的过程称作加密(encryption)。 4：解密。由密文恢复出原明文的过程称作解密(decryption)。 5：敌方。主要指非授权者，通过各种办法，窃取机密信息。 6：被动攻击。获密文进行分析，这类攻击称作被动攻击(passive attack) 。 7：主动攻击。非法入侵者(tamper)采用篡改、伪造等手段向系统注入假消息，称为主 动攻击(active attack)。 8：加密算法。对明文进行加密时采用的算法。 9：解密算法。对密文进行解密时采用算法。 10：加密密钥和解密密钥。加密算法和解密算法的操作通常是在一组密钥（ key）的 控制下进行的，分别称为加密密钥(encryption key)和解密密钥(decryption key)。 在加密系统中，加密算法和密钥是最重要的两个概念。在这里需要对加密算法和密钥 进行一个解释。以最简单的“恺撒加密法”为例。 《高卢战记》有描述恺撒曾经使用密码来传递信息，即所谓的“恺撒密码”。它是一种 替代密码，通过将字母按顺序推后 3 位起到加密作用，如将字母 A 换作字母 D，将字母 B 换作字母 E。如“China”可以变为“Fklqd”；解密过程相反。 在这个简单的加密方法中，“向右移位”，可以理解为加密算法；“3”可以理解为加密 密钥。对于解密过程，“向左移位”，可以理解为解密算法；“3”可以理解为解密密钥。显 然，密钥是一种参数，它是在明文转换为密文或将密文转换为明文的算法中输入的数据。 恺撒加密法的安全性来源于两个方面：第一，对加密算法的隐藏；第二，对密钥的隐 蔽。单单隐蔽加密算法以保护信息，在学界和业界已有相当讨论，一般认为是不够安全的。 公开的加密算法是给黑客长年累月攻击测试，对比隐蔽的加密算法要安全多。一般说来， 加密之所以安全，是因为其加密的密钥的隐藏，并非加密解密算法的保密。而流行的一些 加密解密算法一般是完全公开的。敌方如果取得已加密的数据，即使得知加密算法，若没 有密钥，也不能进行解密。
catch(NoSuchPaddingException ex) {
ex.printStackTrace(); } } /*对字符串str加密*/ public byte[] createEncryptor(String str) { try {
//根据密钥，对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式 c.init(Cipher.ENCRYPT_MODE, deskey); byte[] src = str.getBytes(); //加密，结果保存进cipherByte cipherByte = c.doFinal(src); } catch(java.security.InvalidKeyException ex) { ex.printStackTrace(); } catch(javax.crypto.BadPaddingException ex) { ex.printStackTrace(); } catch(javax.crypto.IllegalBlockSizeException ex) { ex.printStackTrace(); } return cipherByte; } /*对字节数组buff解密*/
public P12_01() {
Security.addProvider(new com.sun.crypto.provider.SunJCE()); try {
//实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常) keygen = KeyGenerator.getInstance("DES");
P12_01.java import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKey; import java.security.NoSuchAlgorithmException; import java.security.Security;
〖1-2〗常见的加密算法
加密技术从本质上说是对信息进行编码和解码的技术。加密是将可读信息（明文）变 为代码形式（密文）；解密是加密的逆过程，相当于将密文变为明文。加密算法有很多种， 一般可分为对称加密、非对称加密和单向加密三类算法。
对称加密算法应用较早，技术较为成熟。其过程如下：
安全编程技术
1：发送方将明文和加密密钥一起经过加密算法处理，变成密文，发送出去。 2：接收方收到密文后，使用加密密钥及相同算法的逆算法对密文解密，恢复为明文。 在对称加密算法中，双方使用的密钥相同，要求解密方事先必须知道加密密钥。其特 点是算法公开、计算量小、加密速度快、加密效率高。不足之处是，通信双方都使用同样 的密钥，安全性得不到保证。此外，用户每次使用该算法，需要保证密钥的唯一性，使得 双方所拥有的密钥数量很大，密钥管理较为困难。对称加密算法中，目前流行的算法有： DES、3DES 和 IDEA 等，美国国家标准局倡导的 AES 即将作为新标准取代 DES。 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有 密钥（privatekey）。每个人拥有这两个密钥，公开密钥对外公开，私有密钥不公开。如果 用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进 行加密，那么只有用对应的公开密钥才能解密。 非对称加密算法的基本过程是： 1：通信前，接收方随机生成的公钥，发送给发送方，自己保留私钥。 2：发送方利用接收方的公钥加密明文，使其变为密文。 3：接收方收到密文后，使用自己的私钥解密密文。 广泛应用的非对称加密算法有 RSA 算法和美国国家标准局提出的 DSA。非对称加密 算法的保密性比较好，它消除了最终用户交换密钥的需要，但加密和解密花费时间长、速 度慢，它不适合于对文件加密而只适用于对少量数据进行加密。 另一类是单向加密算法。该算法在加密过程中不需要使用密钥，输入明文后由系统直 接经过加密算法处理成密文，密文无法解密。只有重新输入明文，并经过同样的加密算法 处理，得到相同的密文并被系统重新识别后，才能真正解密。该方法计算复杂，通常只在 数据量有限的情形下使用，如广泛应用在计算机系统中的口令加密。近年来，单向加密的 应用领域正在逐渐增大。应用较多单向加密算法的有 RSA 公司发明的 MD5 算法和美国国 家 安 全 局 (NSA) 设 计 ， 美 国 国 家 标 准 与 技 术 研 究 院 (NIST) 发 布 SHA (Secure Hash Algorithm，安全散列算法)。 大多数语言体系（如.net、Java）都具有相关的 API 支持各种加密算法。本章以 Java 语言为例来阐述加密解密过程，这些算法在其他语言中的实现，读者可以参考相关资料。
x4x
public byte[] createDecryptor(byte[] buff) {
try {
//根据密钥，对Cipher对象进行初始化,ENCRYPT_MODE表示解密模式 c.init(Cipher.DECRYPT_MODE, deskey); //得到明文，存入cipherByte字符数组 cipherByte = c.doFinal(buff); } catch(java.security.InvalidKeyException ex) {
public class P12_01 {
//KeyGenerator提供对称密钥生成器的功能，支持各种算法 private KeyGenerator keygen; //SecretKey负责保存对称密钥 private SecretKey deskey; //Cipher负责完成加密或解密工作 private Cipher c; //该字节数组负责保存加密的结果 private byte[] cipherByte;
P12_01 p12_01 = new P12_01(); String msg = "郭克华_安全编程技术"; System.out.println("明文是：" + msg); byte[] enc = p12_0பைடு நூலகம்.createEncryptor(msg); System.out.println("密文是：" + new String(enc)); byte[] dec = p12_01.createDecryptor(enc); System.out.println("解密后的结果是：" + new String(dec)); } } 运行，界面如下：
【2】实现对称加密
如前所述，对称加密算法过程中，发送方将明文和加密密钥一起经过加密算法处理， 变成密文，发送出去；接收方收到密文后，使用加密密钥及相同算法的逆算法对密文解密， 恢复为明文。双方使用的密钥相同，要求解密方事先必须知道加密密钥。从这里可以得出 几个结论：
1：加密时使用什么密钥，解密时必须使用相同密钥，否则无法解密。 2：对同样的信息，不同的密钥，加密结果和解密结果理论上不相同。 本节介绍三种流行的对称加密算法：DES、3DES 和 AES。
ex.printStackTrace(); } catch(javax.crypto.BadPaddingException ex) {
ex.printStackTrace(); } catch(javax.crypto.IllegalBlockSizeException ex) {
Java加密与解密方法详解
Java加密与解密方法详解1. 引言在当今数字化时代，保护数据的安全性成为了一项重要的任务。
无论是在个人使用还是企业应用中，数据的加密和解密都是必不可少的环节。
而Java作为一门广泛应用于软件开发的编程语言，其提供了丰富的加密和解密方法，本文将对Java中的加密与解密方法进行详细的介绍和分析。
2. 对称加密算法对称加密算法是指加密和解密使用相同的密钥的算法。
Java中常用的对称加密算法有DES、AES等。
其中，DES是一种较早期的对称加密算法，它使用56位的密钥对数据进行加密和解密。
而AES是一种更加安全和高效的对称加密算法，它使用128位、192位或256位的密钥对数据进行加密和解密。
在Java中，使用对称加密算法进行加密和解密的步骤如下：（1）生成密钥：通过密钥生成器(KeyGenerator)生成一个密钥(Key)。
（2）初始化加密/解密器：通过Cipher类的getInstance方法获取加密/解密器，并设置加密/解密模式和密钥。
（3）加密/解密数据：调用加密/解密器的方法对数据进行加密/解密操作。
3. 非对称加密算法非对称加密算法是指加密和解密使用不同的密钥的算法。
Java中常用的非对称加密算法有RSA、DSA等。
其中，RSA是一种基于大数因子分解的非对称加密算法，它使用公钥和私钥对数据进行加密和解密。
在Java中，使用非对称加密算法进行加密和解密的步骤如下：（1）生成密钥对：通过密钥对生成器(KeyPairGenerator)生成一个密钥对(KeyPair)。
（2）获取公钥和私钥：通过密钥对获取公钥和私钥。
（3）初始化加密/解密器：通过Cipher类的getInstance方法获取加密/解密器，并设置加密/解密模式和密钥。
（4）加密/解密数据：调用加密/解密器的方法对数据进行加密/解密操作。
4. 哈希算法哈希算法是一种将任意长度的数据映射为固定长度的数据的算法。
Java中常用的哈希算法有MD5、SHA-1、SHA-256等。
如何在Java中进行数据的加密和解密
如何在Java中进行数据的加密和解密在Java中，有多种加密和解密的算法可供选择，如对称加密算法、非对称加密算法和哈希算法等。
下面将介绍几种常见的加密和解密方法。
1.对称加密算法对称加密算法指的是使用相同密钥进行加密和解密的算法，常见的对称加密算法有DES、3DES、AES等。
DES加密算法是一种对称密钥算法，加密解密使用相同的密钥，密钥长度为56位。
以下是使用DES加密和解密的示例代码：```javaimport javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class DESExample {public static void main(String[] args) throws Exception { String plainText = "Hello World";String key = "abcdefgh"; //密钥必须是8位长度byte[] encryptedBytes = desEncrypt(plainText.getBytes(), key.getBytes());byte[] decryptedBytes = desDecrypt(encryptedBytes,key.getBytes());String decryptedText = new String(decryptedBytes);System.out.println("解密后的文本：" + decryptedText);}public static byte[] desEncrypt(byte[] plainText, byte[] keyBytes) throws Exception {SecretKey key = new SecretKeySpec(keyBytes, "DES");Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.ENCRYPT_MODE, key);return cipher.doFinal(plainText);}public static byte[] desDecrypt(byte[] cipherText, byte[] keyBytes) throws Exception {SecretKey key = new SecretKeySpec(keyBytes, "DES");Cipher cipher = Cipher.getInstance("DES");cipher.init(Cipher.DECRYPT_MODE, key);return cipher.doFinal(cipherText);}}```3DES加密算法是DES的一种改进版，使用3个不同的密钥对数据进行3次加密。
java 密码加密解密方法
java 密码加密解密方法在Java中，密码的加密和解密可以通过多种方式实现。
其中，常用的方法包括使用MessageDigest类进行加密，以及使用对称加密和非对称加密算法进行加密和解密。
一种常见的密码加密方法是使用MessageDigest类进行加密。
这可以通过以下步骤实现：首先，将密码转换为字节数组。
然后，使用MessageDigest类的getInstance方法获取特定的加密算法实例，例如SHA-256或MD5。
接下来，使用update方法将密码的字节数组传递给MessageDigest实例。
最后，使用digest方法获得加密后的字节数组，并将其转换为十六进制字符串或其他格式存储在数据库或其他地方。
另一种常见的方法是使用对称加密算法，例如AES或DES。
这些算法使用相同的密钥进行加密和解密。
在Java中，可以使用javax.crypto包中的类来实现对称加密。
通常，需要生成一个密钥并将其存储在安全的地方，然后使用该密钥对密码进行加密和解密。
此外，还可以使用非对称加密算法，例如RSA。
这种方法使用公钥对数据进行加密，然后使用私钥进行解密。
在Java中，可以使用java.security包中的类来实现非对称加密。
无论使用哪种方法，都需要注意密码安全的问题。
例如，密钥的安全存储和管理，以及密码传输过程中的安全性。
另外，还需要考虑密码的哈希加盐等技术来增加密码的安全性。
总之，在Java中实现密码的加密和解密有多种方法，开发人员可以根据实际需求和安全要求选择合适的加密算法和实现方式。
希望这些信息能够帮助你更好地理解Java中密码加密解密的方法。
java的加密解密
bytealgorithm加密string解密importimport java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.security.spec.InvalidKeySpecException;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException;import javax.crypto.KeyGenerator;import javax.crypto.NoSuchPaddingException;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;public class DESEncryptTest {private static final String DES_ALGORITHM = "DES";/*** DES加密* @param plainData* @param secretKey* @return* @throws Exception*/public String encryption(String plainData, String secretKey) throws Exception{Cipher cipher = null;try {cipher = Cipher.getInstance(DES_ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, generateKey(secretKey));} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();}catch(InvalidKeyException e){}try {// 为了防止解密时报javax.crypto.IllegalBlockSizeException: Input length must be multiple of 8 when decrypting with padded cipher异常，// 不能把加密后的字节数组直接转换成字符串byte[] buf = cipher.doFinal(plainData.getBytes());return Base64Utils.encode(buf);} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new Exception("IllegalBlockSizeException", e);} catch (BadPaddingException e) {e.printStackTrace();throw new Exception("BadPaddingException", e);}}/*** DES解密* @param secretData* @param secretKey* @return* @throws Exception*/public String decryption(String secretData, String secretKey) throws Exception{Cipher cipher = null;try {cipher = Cipher.getInstance(DES_ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, generateKey(secretKey));} catch (NoSuchAlgorithmException e) {e.printStackTrace();throw new Exception("NoSuchAlgorithmException", e);} catch (NoSuchPaddingException e) {e.printStackTrace();throw new Exception("NoSuchPaddingException", e);}catch(InvalidKeyException e){e.printStackTrace();throw new Exception("InvalidKeyException", e);}try {byte[] buf = cipher.doFinal(Base64Utils.decode(secretData.toCharArray()));return new String(buf);} catch (IllegalBlockSizeException e) {e.printStackTrace();throw new Exception("IllegalBlockSizeException", e);} catch (BadPaddingException e) {e.printStackTrace();throw new Exception("BadPaddingException", e);}}/*** 获得秘密密钥** @param secretKey* @return* @throws NoSuchAlgorithmException*/private SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{ SecureRandom secureRandom = new SecureRandom(secretKey.getBytes());// 为我们选择的DES算法生成一个KeyGenerator对象KeyGenerator kg = null;try {kg = KeyGenerator.getInstance(DES_ALGORITHM);} catch (NoSuchAlgorithmException e) {}kg.init(secureRandom);//kg.init(56, secureRandom);// 生成密钥return kg.generateKey();}public static void main(String[] a) throws Exception{String input = "cy11Xlbrmzyh:604:301:1353064296";String key = "37d5aed075525d4fa0fe635231cba447";DESEncryptTest des = new DESEncryptTest();String result = des.encryption(input, key);System.out.println(result);System.out.println(des.decryption(result, key));}static class Base64Utils {static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();static private byte[] codes = new byte[256];static {for (int i = 0; i < 256; i++)codes[i] = -1;for (int i = 'A'; i <= 'Z'; i++)codes[i] = (byte) (i - 'A');for (int i = 'a'; i <= 'z'; i++)codes[i] = (byte) (26 + i - 'a');for (int i = '0'; i <= '9'; i++)codes[i] = (byte) (52 + i - '0');codes['+'] = 62;codes['/'] = 63;}/*** 将原始数据编码为base64编码*/static public String encode(byte[] data) {char[] out = new char[((data.length + 2) / 3) * 4];for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {boolean quad = false;boolean trip = false;int val = (0xFF & (int) data[i]);val <<= 8;if ((i + 1) < data.length) {val |= (0xFF & (int) data[i + 1]);trip = true;}val <<= 8;if ((i + 2) < data.length) {val |= (0xFF & (int) data[i + 2]);quad = true;}out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];val >>= 6;out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];val >>= 6;out[index + 1] = alphabet[val & 0x3F];val >>= 6;out[index + 0] = alphabet[val & 0x3F];}return new String(out);}/*** 将base64编码的数据解码成原始数据*/static public byte[] decode(char[] data) {int len = ((data.length + 3) / 4) * 3;if (data.length > 0 && data[data.length - 1] == '=')--len;if (data.length > 1 && data[data.length - 2] == '=')--len;byte[] out = new byte[len];int shift = 0;int accum = 0;int index = 0;for (int ix = 0; ix < data.length; ix++) {int value = codes[data[ix] & 0xFF];if (value >= 0) {accum <<= 6;shift += 6;accum |= value;if (shift >= 8) {shift -= 8;out[index++] = (byte) ((accum >> shift) & 0xff);}}}if (index != out.length)throw new Error("miscalculated data length!");return out;}}}KKKKkkkkKKKKKKKKKKKKKKK /*在java中调用sun公司提供的3DES加密解密算法时，需要使用到$JAVA_HOME/jre/lib/目录下如下的4个jar包：jce.jarsecurity/US_export_policy.jarsecurity/local_policy.jarext/sunjce_provider.jarJava运行时会自动加载这些包，因此对于带main函数的应用程序不需要设置到CLASSPATH环境变量中。
java密码加密与解密
java密码加密与解密2013-04-29 14:24:53 我来说两句作者：红豆糕收藏我要投稿以下两个类可以很方便的完成字符串的加密和解密：加密：CryptHelper.encrypt(password)解密：CrypHelper.decrypt(password)代码如下：CryptUtils.java[java]package b.crypt;import java.io.IOException;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import .apache.xerces.internal.impl.dv.util.Base64;public class CryptUtils {private static String Algorithm = "DES";private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};private static String VALUE_ENCODING="UTF-8";/*** 生成密钥** @return byte[] 返回生成的密钥* @throws exception* 扔出异常.*/public static byte[] getSecretKey() throws Exception {KeyGenerator keygen = KeyGenerator.getInstance(Algorithm); SecretKey deskey = keygen.generateKey();// if (debug ) System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded// ()));return deskey.getEncoded();}/*** 将指定的数据根据提供的密钥进行加密** @param input* 需要加密的数据* @param key* 密钥* @return byte[] 加密后的数据* @throws Exception*/public static byte[] encryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);// if (debug )// {// System.out.println ("加密前的二进串:"+byte2hex (input )); // System.out.println ("加密前的字符串:"+new String (input )); //// }Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.ENCRYPT_MODE, deskey);byte[] cipherByte = c1.doFinal(input);// if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));return cipherByte;}public static byte[] encryptData(byte[] input) throws Exception { return encryptData(input, DEFAULT_KEY);}/*** 将给定的已加密的数据通过指定的密钥进行解密** @param input* 待解密的数据* @param key* 密钥* @return byte[] 解密后的数据* @throws Exception*/public static byte[] decryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key,Algorithm);// if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.DECRYPT_MODE, deskey);byte[] clearByte = c1.doFinal(input);// if (debug )// {// System.out.println ("解密后的二进串:"+byte2hex (clearByte )); // System.out.println ("解密后的字符串:"+(new String(clearByte )));//// }return clearByte;}public static byte[] decryptData(byte[] input) throws Exception {return decryptData(input, DEFAULT_KEY);}/*** 字节码转换成16进制字符串** @param byte[] b 输入要转换的字节码* @return String 返回转换后的16进制字符串*/public static String byte2hex(byte[] bytes) {StringBuilder hs = new StringBuilder();for(byte b : bytes)hs.append(String.format("%1$02X", b));return hs.toString();}public static byte[] hex2byte(String content) {int l=content.length()>>1;byte[] result=new byte[l];for(int i=0;i<l;i++) {int j=i<<1;String s=content.substring(j, j+2);result[i]=Integer.valueOf(s, 16).byteValue(); }return result;}/*** 将字节数组转换为base64编码字符串* @param buffer* @return*/public static String bytesToBase64(byte[] buffer) { //BASE64Encoder en=new BASE64Encoder();return Base64.encode(buffer);// return encoder.encode(buffer);}/*** 将base64编码的字符串解码为字节数组* @param value* @return* @throws IOException*/public static byte[] base64ToBytes(String value) throws IOException { //return Base64.decodeToByteArray(value);// System.out.println(decoder.decodeBuffer(value));// return decoder.decodeBuffer(value);return Base64.decode(value);}/*** 加密给定的字符串* @param value* @return 加密后的base64字符串*/public static String encryptString(String value) {return encryptString(value, DEFAULT_KEY);}/*** 根据给定的密钥加密字符串* @param value 待加密的字符串* @param key 以BASE64形式存在的密钥* @return 加密后的base64字符串* @throws IOException*/public static String encryptString(String value, String key) throws IOException {return encryptString(value, base64ToBytes(key));}/*** 根据给定的密钥加密字符串* @param value 待加密的字符串* @param key 字节数组形式的密钥* @return 加密后的base64字符串*/public static String encryptString(String value, byte[] key) { try {byte[] data=value.getBytes(VALUE_ENCODING);data=CryptUtils.encryptData(data, key);return bytesToBase64(data);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();return null;}}/*** 解密字符串* @param value base64形式存在的密文* @return 明文*/public static String decryptString(String value) {return decryptString(value, DEFAULT_KEY);}/*** 解密字符串* @param value base64形式存在的密文* @param key base64形式存在的密钥* @return 明文* @throws IOException*/public static String decryptString(String value, String key) throws IOException {String s=decryptString(value, base64ToBytes(key));return s;}/*** 解密字符串* @param value base64形式存在的密文* @param key 字节数据形式存在的密钥* @return 明文*/public static String decryptString(String value, byte[] key) {try {byte[] data=base64ToBytes(value);data=CryptUtils.decryptData(data, key);return new String(data, VALUE_ENCODING);}catch(Exception e) {e.printStackTrace();return null;}}}package b.crypt;import java.io.IOException;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import .apache.xerces.internal.impl.dv.util.Base64;public class CryptUtils {private static String Algorithm = "DES";private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};private static String VALUE_ENCODING="UTF-8";/*** 生成密钥** @return byte[] 返回生成的密钥* @throws exception* 扔出异常.*/public static byte[] getSecretKey() throws Exception {KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);SecretKey deskey = keygen.generateKey();// if (debug ) System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded // ()));return deskey.getEncoded();}/*** 将指定的数据根据提供的密钥进行加密** @param input* 需要加密的数据* @param key* 密钥* @return byte[] 加密后的数据* @throws Exception*/public static byte[] encryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm); // if (debug )// {// System.out.println ("加密前的二进串:"+byte2hex (input ));// System.out.println ("加密前的字符串:"+new String (input ));//// }Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.ENCRYPT_MODE, deskey);byte[] cipherByte = c1.doFinal(input);// if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));return cipherByte;}public static byte[] encryptData(byte[] input) throws Exception {return encryptData(input, DEFAULT_KEY);}/*** 将给定的已加密的数据通过指定的密钥进行解密** @param input* 待解密的数据* @param key* 密钥* @return byte[] 解密后的数据* @throws Exception*/public static byte[] decryptData(byte[] input, byte[] key) throws Exception {SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm); // if (debug ) System.out.println ("解密前的信息:"+byte2hex (input )); Cipher c1 = Cipher.getInstance(Algorithm);c1.init(Cipher.DECRYPT_MODE, deskey);byte[] clearByte = c1.doFinal(input);// if (debug )// {// System.out.println ("解密后的二进串:"+byte2hex (clearByte ));// System.out.println ("解密后的字符串:"+(new String (clearByte )));//// }return clearByte;}public static byte[] decryptData(byte[] input) throws Exception {return decryptData(input, DEFAULT_KEY);}/*** 字节码转换成16进制字符串** @param byte[] b 输入要转换的字节码* @return String 返回转换后的16进制字符串*/public static String byte2hex(byte[] bytes) {StringBuilder hs = new StringBuilder();for(byte b : bytes)hs.append(String.format("%1$02X", b));return hs.toString();}public static byte[] hex2byte(String content) {int l=content.length()>>1;byte[] result=new byte[l];for(int i=0;i<l;i++) {int j=i<<1;String s=content.substring(j, j+2);result[i]=Integer.valueOf(s, 16).byteValue();}return result;}/*** 将字节数组转换为base64编码字符串* @param buffer* @return*/public static String bytesToBase64(byte[] buffer) {//BASE64Encoder en=new BASE64Encoder();return Base64.encode(buffer);// return encoder.encode(buffer);}/*** 将base64编码的字符串解码为字节数组* @param value* @return* @throws IOException*/public static byte[] base64ToBytes(String value) throws IOException {//return Base64.decodeToByteArray(value);// System.out.println(decoder.decodeBuffer(value));// return decoder.decodeBuffer(value);return Base64.decode(value);}/*** 加密给定的字符串* @param value* @return 加密后的base64字符串*/public static String encryptString(String value) {return encryptString(value, DEFAULT_KEY);}/*** 根据给定的密钥加密字符串* @param value 待加密的字符串* @param key 以BASE64形式存在的密钥* @return 加密后的base64字符串* @throws IOException*/public static String encryptString(String value, String key) throws IOException {return encryptString(value, base64ToBytes(key));}/*** 根据给定的密钥加密字符串* @param value 待加密的字符串* @param key 字节数组形式的密钥* @return 加密后的base64字符串*/public static String encryptString(String value, byte[] key) {try {byte[] data=value.getBytes(VALUE_ENCODING);data=CryptUtils.encryptData(data, key);return bytesToBase64(data);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();return null;}}/*** 解密字符串* @param value base64形式存在的密文* @return 明文*/public static String decryptString(String value) {return decryptString(value, DEFAULT_KEY);}/*** 解密字符串* @param value base64形式存在的密文* @param key base64形式存在的密钥* @return 明文* @throws IOException*/public static String decryptString(String value, String key) throwsIOException {String s=decryptString(value, base64ToBytes(key));return s;}/*** 解密字符串* @param value base64形式存在的密文* @param key 字节数据形式存在的密钥* @return 明文*/public static String decryptString(String value, byte[] key) { try {byte[] data=base64ToBytes(value);data=CryptUtils.decryptData(data, key);return new String(data, VALUE_ENCODING);}catch(Exception e) {e.printStackTrace();return null;}}}CryptHelper.java[java]package b.crypt;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvParameterSpec;import org.springframework.util.DigestUtils;public class CryptHelper{private static String CRYPT_KEY = "zhongqian";//加密private static Cipher ecip;//解密private static Cipher dcip;static {try {String KEY =DigestUtils.md5DigestAsHex(CRYPT_KEY.getBytes()).toUpperCase();KEY = KEY.substring(0, 8);byte[] bytes = KEY.getBytes();DESKeySpec ks = new DESKeySpec(bytes);SecretKeyFactory skf = SecretKeyFactory.getInstance("DES"); SecretKey sk = skf.generateSecret(ks);IvParameterSpec iv2 = new IvParameterSpec(bytes);ecip = Cipher.getInstance("DES/CBC/PKCS5Padding");ecip.init(Cipher.ENCRYPT_MODE, sk, iv2);dcip = Cipher.getInstance("DES/CBC/PKCS5Padding");dcip.init(Cipher.DECRYPT_MODE, sk, iv2);}catch(Exception ex) {ex.printStackTrace();}}public static String encrypt(String content) throws Exception { byte[] bytes = ecip.doFinal(content.getBytes("ascii"));return CryptUtils.byte2hex(bytes);}public static String decrypt(String content) throws Exception { byte[] bytes = CryptUtils.hex2byte(content);bytes = dcip.doFinal(bytes);return new String(bytes, "ascii");}//testpublic static void main(String[] args) throws Exception {String password = "gly";String en = encrypt(password);System.out.println(en);System.out.println(decrypt(en));}}package b.crypt;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvParameterSpec;import org.springframework.util.DigestUtils;public class CryptHelper{private static String CRYPT_KEY = "zhongqian";//加密private static Cipher ecip;//解密private static Cipher dcip;static {try {String KEY =DigestUtils.md5DigestAsHex(CRYPT_KEY.getBytes()).toUpperCase(); KEY = KEY.substring(0, 8);byte[] bytes = KEY.getBytes();DESKeySpec ks = new DESKeySpec(bytes);SecretKeyFactory skf = SecretKeyFactory.getInstance("DES"); SecretKey sk = skf.generateSecret(ks);IvParameterSpec iv2 = new IvParameterSpec(bytes);ecip = Cipher.getInstance("DES/CBC/PKCS5Padding");ecip.init(Cipher.ENCRYPT_MODE, sk, iv2);dcip = Cipher.getInstance("DES/CBC/PKCS5Padding");dcip.init(Cipher.DECRYPT_MODE, sk, iv2);}catch(Exception ex) {ex.printStackTrace();}}public static String encrypt(String content) throws Exception { byte[] bytes = ecip.doFinal(content.getBytes("ascii"));return CryptUtils.byte2hex(bytes);}public static String decrypt(String content) throws Exception { byte[] bytes = CryptUtils.hex2byte(content);bytes = dcip.doFinal(bytes);return new String(bytes, "ascii");}//testpublic static void main(String[] args) throws Exception {String password = "gly";String en = encrypt(password);System.out.println(en);System.out.println(decrypt(en));}}。
java 字符串加密解密常见方法
java 字符串加密解密常见方法在Java中，我们经常需要对字符串进行加密和解密操作以确保数据的安全性。
下面我将介绍一些常见的字符串加密和解密方法。
1. 使用Base64编码：Base64是一种常用的编码方式，它可以将任意二进制数据编码为纯文本字符串。
在Java中，可以借助Java提供的Base64类对字符串进行加密和解密操作。
例如：```javaimport java.util.Base64;public class Base64Util {// 字符串加密public static String encrypt(String str) {byte[] bytes = str.getBytes();byte[] encodedBytes = Base64.getEncoder().encode(bytes);return new String(encodedBytes);}// 字符串解密public static String decrypt(String str) {byte[] bytes = str.getBytes();byte[] decodedBytes = Base64.getDecoder().decode(bytes);return new String(decodedBytes);}}```2. 使用AES算法：AES（Advanced Encryption Standard）是一种对称加密算法，它可以对数据进行加密和解密。
在Java中，可以使用javax.crypto包提供的类来实现AES加密和解密。
例如：```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;public class AESUtil {// 生成AES密钥private static SecretKeySpec generateKey(String key) throws Exception {KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");keyGenerator.init(128);SecretKey secretKey = keyGenerator.generateKey();byte[] encodedKey = secretKey.getEncoded();return new SecretKeySpec(encodedKey, "AES");}// 字符串加密public static String encrypt(String str, String key) throws Exception {Cipher cipher = Cipher.getInstance("AES");cipher.init(Cipher.ENCRYPT_MODE, generateKey(key));byte[] encryptedBytes = cipher.doFinal(str.getBytes());return new String(encryptedBytes);}// 字符串解密public static String decrypt(String str, String key) throws Exception {Cipher cipher = Cipher.getInstance("AES");cipher.init(Cipher.DECRYPT_MODE, generateKey(key));byte[] decryptedBytes = cipher.doFinal(str.getBytes());return new String(decryptedBytes);}}```这是两种常见的字符串加密和解密方法。
java实现加密-位加密解密算法
java实现加密-位加密解密算法import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.Scanner;public class demo {static char[] bitcode(char[] str, char n) //位加密解密算法{int i, len;char[] wen;len = str.length;if ((wen = new char[len + 1]) == null) {System.out.print("申请内存失败!\n");System.exit(1);}for (i = 0; i < len; i++) {wen[i] = (char) (str[i] ^ n); //异或运算}wen[len] = '\0';return wen;}public static void main(String[] args) throws IOException {int i;char ch;char[] srcstr = new char[100];char[] miwen;String go;System.out.print("位加密解密算法演⽰！\n");do {System.out.print("\n请先输⼊替换加密解密算法中的密钥：");Scanner input = new Scanner(System.in);ch = input.next().charAt(0); //密钥System.out.print("请输⼊明⽂字符串：");BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));String str = bufferedReader.readLine();srcstr = str.toCharArray(); //明⽂字符串System.out.print("输⼊的明⽂为：");for (i = 0; i < srcstr.length; i++) {System.out.print(srcstr[i]);}miwen = bitcode(srcstr, ch); //加密System.out.print("\n加密后的密⽂为：");for (i = 0; i < srcstr.length; i++) {System.out.print(miwen[i]);}miwen = bitcode(miwen, ch); //解密System.out.print("\n解密出的明⽂为：");for (i = 0; i < srcstr.length; i++) {System.out.print(miwen[i]);}System.out.print("\n继续执⾏(y/n)?");go = input.next();} while (go.equalsIgnoreCase("y"));System.out.println("演⽰结束！");}}。
java相关加密解密方法
java相关加密解密方法
Java提供了许多加密解密方法，包括对称加密、非对称加密、
哈希加密等。
下面我将从多个角度来介绍一些常见的加密解密方法。
1. 对称加密：
对称加密使用相同的密钥进行加密和解密。
Java中常用的对称
加密算法包括AES、DES和3DES。
使用这些算法可以通过Java的Cipher类来实现加密和解密操作。
对称加密算法适合于对数据进行
加密保护，但需要注意密钥的安全存储和传输。
2. 非对称加密：
非对称加密使用公钥和私钥进行加密和解密。
Java中常用的非
对称加密算法包括RSA和DSA。
可以使用Java的KeyPairGenerator
类生成密钥对，并使用Cipher类进行加密和解密操作。
非对称加密
算法适合于数据的签名和加密传输，可以实现安全的数据通信。
3. 哈希加密：
哈希加密算法将数据转换为固定长度的哈希值，不可逆。
Java 中常用的哈希加密算法包括MD5和SHA系列算法。
可以使用Java的MessageDigest类进行哈希加密操作。
哈希加密适合于对数据进行完整性校验和摘要计算。
除了以上的加密解密方法，Java还提供了许多其他的加密解密工具和框架，如Bouncy Castle、JCE（Java Cryptography Extension）等，可以满足不同场景下的加密解密需求。
在实际应用中，需要根据具体的安全需求和性能要求选择合适的加密解密方法，并且注意密钥管理、安全传输等安全实践，以保障数据的安全性和完整性。
希望以上介绍对你有所帮助。
java国密加密与解密流程
java国密加密与解密流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 引入国密相关的依赖库在 Java 项目中，需要引入国密相关的依赖库，例如 Bouncy Castle 库。
java enc解密方法
java enc解密方法在Java中，可以使用Java内置的加密和解密库来实现加密和解密操作。
以下是一个简单的示例，演示如何使用Java内置的加密和解密库进行加密和解密操作：```javaimport ;import ;import ;import ;public class EncryptionExample {public static void main(String[] args) throws Exception {// 原始字符串String original = "Hello, World!";// 加密密钥String key = "secretkey";// 加密操作Cipher cipher = ("AES/ECB/PKCS5Padding");SecretKeySpec secretKey = new SecretKeySpec((_8), "AES");(_MODE, secretKey);byte[] encrypted = ((_8));String encryptedString = ().encodeToString(encrypted);("加密后的字符串: " + encryptedString);// 解密操作(_MODE, secretKey);byte[] decrypted = (().decode(encryptedString));String decryptedString = new String(decrypted, _8);("解密后的字符串: " + decryptedString);}}```在这个示例中，我们使用AES算法进行加密和解密操作。
我们首先定义了一个原始字符串和加密密钥。
然后，我们使用Cipher类创建一个加密对象，并使用指定的算法和模式进行初始化。