Java加密解密方法大全(ChinaSEI)
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类创建一个加密对象,并使用指定的算法和模式进行初始化。
javasm4国密算法加密、解密

javasm4国密算法加密、解密1.准备⼯作 所需jar包: bcprov-jdk15on-1.59.jar commons-lang3-3.1.jar 20200901 对应的maven依赖<!--sm3,sm4加密算法--><dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.66</version></dependency> import java.security.Key;import java.security.NoSuchAlgorithmException;import java.security.NoSuchProviderException;import java.security.SecureRandom;import java.security.Security;import java.util.Arrays;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.spec.SecretKeySpec;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;/*** sm4加密算法⼯具类* @explain sm4加密、解密与加密结果验证* 可逆算法* @author Marydon* @creationTime 2018年7⽉6⽇上午11:46:59* @version 1.0* @since*@*****************************/public class Sm4Util {static {Security.addProvider(new BouncyCastleProvider());}private static final String ENCODING = "UTF-8";public static final String ALGORITHM_NAME = "SM4";// 加密算法/分组加密模式/分组填充⽅式// PKCS5Padding-以8个字节为⼀组进⾏分组加密// 定义分组加密模式使⽤:PKCS5Paddingpublic static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";// 128-32位16进制;256-64位16进制public static final int DEFAULT_KEY_SIZE = 128;/*** ⽣成ECB暗号* @explain ECB模式(电⼦密码本模式:Electronic codebook)* @param algorithmName* 算法名称* @param mode* 模式* @param key* @return* @throws Exception*/private static Cipher generateEcbCipher(String algorithmName, int mode, byte[] key) throws Exception {Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);Key sm4Key = new SecretKeySpec(key, ALGORITHM_NAME);cipher.init(mode, sm4Key);return cipher;}}2.SM4加密 第⼀步:产⽣密钥 ⽅式⼀:系统⽣成密钥/*** ⾃动⽣成密钥* @explain* @return* @throws NoSuchAlgorithmException* @throws NoSuchProviderException*/public static byte[] generateKey() throws Exception {return generateKey(DEFAULT_KEY_SIZE);}/*** @explain* @param keySize* @returnpublic static byte[] generateKey(int keySize) throws Exception {KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME); kg.init(keySize, new SecureRandom());return kg.generateKey().getEncoded();} ⽅法⼆:⾃⼰提供16进制的密钥 第⼆步:加密/*** sm4加密* @explain 加密模式:ECB* 密⽂长度不固定,会随着被加密字符串长度的变化⽽变化* @param hexKey* 16进制密钥(忽略⼤⼩写)* @param paramStr* 待加密字符串* @return 返回16进制的加密字符串* @throws Exception*/public static String encryptEcb(String hexKey, String paramStr) throws Exception {String cipherText = "";// 16进制字符串-->byte[]byte[] keyData = ByteUtils.fromHexString(hexKey);// String-->byte[]byte[] srcData = paramStr.getBytes(ENCODING);// 加密后的数组byte[] cipherArray = encrypt_Ecb_Padding(keyData, srcData);// byte[]-->hexStringcipherText = ByteUtils.toHexString(cipherArray);return cipherText;}/*** 加密模式之Ecb* @explain* @param key* @param data* @return* @throws Exception*/public static byte[] encrypt_Ecb_Padding(byte[] key, byte[] data) throws Exception {Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);return cipher.doFinal(data);}3.SM4解密/*** sm4解密* @explain 解密模式:采⽤ECB* @param hexKey* 16进制密钥* @param cipherText* 16进制的加密字符串(忽略⼤⼩写)* @return 解密后的字符串* @throws Exception*/public static String decryptEcb(String hexKey, String cipherText) throws Exception {// ⽤于接收解密后的字符串String decryptStr = "";// hexString-->byte[]byte[] keyData = ByteUtils.fromHexString(hexKey);// hexString-->byte[]byte[] cipherData = ByteUtils.fromHexString(cipherText);// 解密byte[] srcData = decrypt_Ecb_Padding(keyData, cipherData);// byte[]-->StringdecryptStr = new String(srcData, ENCODING);return decryptStr;}/*** 解密* @explain* @param key* @param cipherText* @return* @throws Exception*/public static byte[] decrypt_Ecb_Padding(byte[] key, byte[] cipherText) throws Exception {Cipher cipher = generateEcbCipher(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);return cipher.doFinal(cipherText);} 4.加密数据校验/*** 校验加密前后的字符串是否为同⼀数据* @explain* @param hexKey* 16进制密钥(忽略⼤⼩写)* @param cipherText* 16进制加密后的字符串* @param paramStr* 加密前的字符串* @return 是否为同⼀数据。
Java加密解密方法大全(ChinaSEI)

如前所述,对称加密算法过程中,发送方将明文和加密密钥一起经过加密算法处理, 变成密文,发送出去;接收方收到密文后,使用加密密钥及相同算法的逆算法对密文解密, 恢复为明文。双方使用的密钥相同,要求解密方事先必须知道加密密钥。从这里可以得出 几个结论:
1:加密时使用什么密钥,解密时必须使用相同密钥,否则无法解密。 2:对同样的信息,不同的密钥,加密结果和解密结果理论上不相同。 本节介绍三种流行的对称加密算法:DES、3DES 和 AES。
〖2-1〗用Java实现DES
DES 是数据加密标准(Data Encryption Standard)的简称,出自 IBM 的研究工作,
x2x
并在 1977 年被美国政府正式采纳。它是使用较为广泛的密钥系统,最初开发 DES 是嵌 入硬件中,DES 特别是在保护金融数据的安全,如自动取款机中,使用较多。
在 DES 中,使用了一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的 分组大小。加密过程中,将加密的文本块分成两半。使用子密钥对其中一半应用循环功能, 然后将输出与另一半进行“异或”运算;接着交换这两半。循环往复。DES 使用 16 个循 环,但最后一个循环不交换。
攻击 DES,一般只能使用穷举的密钥搜索,即重复尝试各种密钥直到有一个符合为 止。如果 DES使用 56 位的密钥,则可能的密钥数量是 256个,穷举难度较大。IBM曾对 DES拥有几年的专利权,但在 1983 年到期。
public P12_01() {
Security.addProvider(new com.sun.crypto.provider.SunJCE()); try {
//实例化支持DES算法的密钥生成器(算法名称命名需按规定,否则抛出异常) keygen = KeyGenerator.getInstance("DES");
java接收文件加密解密方法

java接收文件加密解密方法
在Java中接收加密文件并进行解密可以通过多种方式实现。
下面我将从多个角度介绍几种常见的方法:
1. 使用对称加密算法:
可以使用Java的javax.crypto包中的类来实现对称加密算法,如AES。
首先,接收加密文件后,可以使用FileInputStream 读取文件内容,然后使用Cipher类进行解密操作,最后使用FileOutputStream将解密后的内容写入新文件。
2. 使用非对称加密算法:
如果发送方使用了公钥加密文件,接收方可以使用私钥进行解密。
可以使用Java的java.security包中的类来实现非对称加密算法,如RSA。
首先,接收加密文件后,可以使用PrivateKey类进行解密操作,最后使用FileOutputStream将解密后的内容写入新文件。
3. 使用第三方库:
除了Java自带的加密算法外,也可以使用第三方库来简化加密解密操作,例如Bouncy Castle或者Apache Commons Crypto 等。
这些库提供了更多的加密选项和更简单的API,可以更容易地实现文件的加密和解密操作。
无论使用哪种方法,都需要注意文件的安全传输和存储,以及密钥的安全管理。
另外,要确保在解密文件时处理可能出现的异常情况,如文件损坏或者密码错误等。
希望这些信息能够帮助你实现在Java中接收文件并进行加密解密的操作。
java进行字符串加密解密算法

// 每个byte用两个字符才能表示,所以字符串的长度是数组长度的两倍
StringBuffer sb = newStringBuffer(iLen * 2);
for(inti = 0; i < iLen; i++) {
intintTmp = arrB[i];
privatestaticString strDefaultKey = "tourhb";
/** 加密工具 */
privateCipher encryptCipher = null;
/** 解密工具 */
privateCipher decryptCipher = null;
/**
* 将byte数组转换为表示16进制值的字符串, 如:byte[]{8,18}转换为:0813, 和public static byte[]
* hexStr2ByteArr(String strIn) 互为可逆的转换过程
*
* @param arrB
* 需要转换的byte数组
* @return 转换后的字符串
* @throws Exception
*
*/
publicstaticString byteArr2HexStr(byte[] arrB) throwsException {
arrB[i] = arrBTmp[i];
}
// 生成密钥
Key key = newjavax.crypto.spec.SecretKeySpec(arrB, "DES");
returnkey;
}
// 把负数转换为正数
while(intTmp < 0) {
java相关加密解密方法

java相关加密解密方法Java加密解密方法是保护数据安全的重要手段,本文将详细介绍几种常见的Java加密解密方法。
一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。
这种加密方式简单高效,但存在密钥管理的问题,因为所有用户都必须知道密钥。
在Java中,常用的对称加密算法有DES、3DES、AES等。
1. DES:Data Encryption Standard,数据加密标准,是一种使用56位密钥的对称块密码算法。
在Java中,我们可以使用javax.crypto.Cipher类来实现DES 加密解密。
2. 3DES:Triple Data Encryption Algorithm,三重数据加密算法,是DES的增强版本,使用三个不同的56位密钥进行三次加密。
在Java中,我们同样可以使用Cipher类来实现3DES加密解密。
3. AES:Advanced Encryption Standard,高级加密标准,是一种使用128、192或256位密钥的对称块密码算法。
在Java中,我们可以使用Cipher类来实现AES加密解密。
二、非对称加密算法非对称加密算法是一种使用一对密钥(公钥和私钥)进行加密和解密的算法。
公钥可以公开给所有人,而私钥需要保密。
在Java中,常用的非对称加密算法有RSA、DSA等。
1. RSA:Rivest-Shamir-Adleman,一种基于大数因子分解难题的非对称加密算法。
在Java中,我们可以使用java.security.KeyPairGenerator类生成RSA密钥对,然后使用Cipher类进行RSA加密解密。
2. DSA:Digital Signature Algorithm,数字签名算法,是一种基于整数有限域离散对数难题的非对称加密算法。
在Java中,我们可以使用KeyPairGenerator类生成DSA密钥对,然后使用Signature类进行DSA签名和验证。
中文的加密与解密算法之java篇

实验四:用java实现的中文的加密与解密实验日期:2012年5月29日至2012年5月30日一.实验目的加深对密码的加密与解密过程。
二.实验软件Eclipse IDE for Java EE Developers。
三.实验原理Java中char(字符)类型的变量的编码方式是UTF-16,一个文字用5位的10进制表示,如“中”=20013。
加密过程如下:解密过程如下:四.实验结果及分析:为了让实验结果更加直观,我将密码的校验位也输出在控制台上.一个文字用了5位10进制表示密码输入正确时,可以正确解密密码输入不正确时,将不能获得原信息五.实验总结:对于中文字的加密,这个算法可以起到较好的效果,但对于中文以外的字符只能加密而不能解密。
接下去的首要工作就是把加密算法扩展到所有类型的字符,还可以扩展性的将密码校验位增加。
如今社会密码是越来越多,秘密却越来越少,网络亦是如此。
有必要的话可以在会话的双方约定一种自己设计的算法进行加密和解密。
这种算法对会话双方来说是公钥,但对于会话之外的人和事来说就是私钥中的私钥,破解难度相当大。
六.附上源代码:package wwi2012_5_15;import java.util.Arrays;import java.util.Scanner;public class EncryptVersion2 {public static void main(String[] args) {jiaMi();//加密的方法jieMi();//解密的方法}private static void jiaMi() {Scanner console = new Scanner(System.in);System.out.println("输入密码:");String password = console.nextLine();double pw = 0;for(int i=0; i<password.length(); i++){pw += (double)(password.charAt(i));}int check = (int)pw % 5;//由输入的密码计算出一个校验位进行加密System.out.println(check);System.out.println("输入需加密的中文字:");String in = console.nextLine();int[] chinaInt = new int[]{};//将中文转成int型放到数组中int[] china = new int[5];//将单个中文的5位编码取出System.out.println("加密后:");for(int i=0; i<in.length(); i++){chinaInt=Arrays.copyOf(chinaInt,chinaInt.length+1);chinaInt[chinaInt.length - 1] = (int)in.charAt(i);//对转成int型的中文字5位编码,每位加上check,再对10取余数for(int i=0; i<chinaInt.length; i++){china[0] = (chinaInt[i] / 10000 + check) % 10;china[1] = ((chinaInt[i] / 1000) % 10 + check) % 10;china[2] = ((chinaInt[i] / 100) % 10 + check) % 10;china[3] = ((chinaInt[i] / 10) % 10 + check) % 10;china[4] = (chinaInt[i] % 10 + check) % 10;for(int j=0; j<5; j++)System.out.print(china[j]);}}private static void jieMi() {Scanner console = new Scanner(System.in);System.out.println("输入密码:");String password = console.nextLine();double pw = 0;for(int i=0; i<password.length(); i++){pw += (double)(password.charAt(i));}int check = (int)pw % 5;//由输入的密码计算出一个校验位进System.out.println(check);System.out.println("输入密文:");String in = console.nextLine();int[] x = new int[5];System.out.print("解密后:");for(int j=0; j<in.length()/5; j++){int one = 0;//一个中文的密文for(int i=0; i<5; i++){//取出5个int judge = in.charAt(i+5*j)-'0';if(judge >= 0 && judge < check)one = (((in.charAt(i+5*j)-'0') + 10) - check) +one*10;elseone= ((in.charAt(i+5*j)-'0') - check )+one*10;}System.out.print((char)one);}}}。
java语句加密解密案例

java语句加密解密案例Java语言是一种面向对象的编程语言,具有很好的可读性和可维护性。
在实际应用中,我们常常需要对一些敏感信息进行加密和解密,以保证数据的安全性。
本文将以Java语句加密解密案例为题,介绍10个常见的加密解密算法及其实现方法。
一、Caesar加密解密算法Caesar算法是一种简单的替换加密算法,也称为凯撒密码。
它通过将明文中的每个字母按照指定的偏移量进行替换,从而得到密文。
解密过程则是将密文中的每个字母按照相反的偏移量进行替换,恢复成明文。
二、DES加密解密算法DES算法是一种对称密钥加密算法,使用相同的密钥进行加密和解密。
它将明文数据按照固定长度的数据块进行分组,并使用密钥对每个数据块进行加密,最后得到密文。
解密过程则是使用相同的密钥对密文进行解密,恢复成明文。
三、AES加密解密算法AES算法是一种对称密钥加密算法,与DES算法相比,它具有更高的安全性和更快的加解密速度。
AES算法将明文数据按照固定长度的数据块进行分组,并使用密钥对每个数据块进行加密,最后得到密文。
解密过程与加密过程相反,使用相同的密钥对密文进行解密,恢复成明文。
四、RSA加密解密算法RSA算法是一种非对称密钥加密算法,它使用一对密钥,即公钥和私钥。
公钥用于加密数据,私钥用于解密数据。
RSA算法的安全性基于大数分解的难题,即将一个大数分解成两个较小的质数的乘积。
五、哈希算法哈希算法是一种将任意长度的数据映射成固定长度哈希值的算法。
常用的哈希算法有MD5、SHA-1和SHA-256等。
哈希算法通常用于验证数据的完整性,一般不可逆,无法从哈希值恢复出原始数据。
六、Base64编码Base64是一种将二进制数据转换成可打印字符的编码方式。
它将3个字节的数据编码成4个可打印字符,从而减少了数据的长度。
Base64编码通常用于在网络传输中传递二进制数据,如图片、音频等。
七、URL编码URL编码是一种将URL中的特殊字符转换成%加上十六进制表示的字符的过程。
java加密解密方式

java加密解密⽅式1、MD5(Message Digest Algorithm)加密算法是⼀种单向加密算法,只能加密不能解密,⽰例/*** MD5简单加密* @param content 加密内容* @return String*/public static String md5Encrypt(final String content) {MessageDigest md5 = null;try {md5 = MessageDigest.getInstance(ALGORITHM_MD5);} catch (NoSuchAlgorithmException e) {e.printStackTrace();}// md5.update(text.getBytes());//digest()最后返回md5 hash值,返回值为8位字符串。
因为md5 hash值是16位的hex值,实际上就是8位的字符//BigInteger函数则将8位的字符串转换成16位hex值,⽤字符串来表⽰;得到字符串形式的hash值BigInteger digest = new BigInteger(md5.digest(content.getBytes()));//32位return digest.toString(16);}2、BASE64进⾏加密/解密通常⽤作对⼆进制数据进⾏加密,⽰例/*** base64加密* @param content 待加密内容* @return byte[]*/public static byte[] base64Encrypt(final String content) {return Base64.getEncoder().encode(content.getBytes());}/*** base64解密* @param encoderContent 已加密内容* @return byte[]*/public static byte[] base64Decrypt(final byte[] encoderContent) {return Base64.getDecoder().decode(encoderContent);}3、DES(Data Encryption Standard)对称加密/解密数据加密标准算法,和BASE64最明显的区别就是有⼀个⼯作密钥,该密钥既⽤于加密、也⽤于解密,并且要求密钥是⼀个长度⾄少⼤于8位的字符串,⽰例/*** DES加密* @param key 秘钥key* @param content 待加密内容* @return byte[]*/public static byte[] DESEncrypt(final String key, final String content) {return processCipher(content.getBytes(), getSecretKey(key), Cipher.ENCRYPT_MODE , ALGORITHM_DES);}/*** DES解密* @param key 秘钥key* @param encoderContent 已加密内容* @return byte[]*/public static byte[] DESDecrypt(final String key, final byte[] encoderContent) {return processCipher(encoderContent, getSecretKey(key), Cipher.DECRYPT_MODE, ALGORITHM_DES);}4、RSA⾮对称加密/解密⾮对称加密算法的典型代表,既能加密、⼜能解密。
java后台加密解密方法

java后台加密解密方法Java后台加密解密方法在当今互联网安全领域中具有重要意义。
为了保护数据的安全,各种加密算法应运而生。
本文将介绍几种常见的Java后台加密解密方法,包括RSA、AES、DES和SM2。
1.RSA加密解密原理及实现RSA是一种非对称加密算法,其公钥和私钥是成对存在的。
使用公钥加密后的数据只能通过私钥进行解密。
在Java中,我们可以使用KeyPairGenerator生成一对公私钥,然后使用RSAPrivateKey对数据进行解密。
2.AES加密解密原理及实现AES是一种对称加密算法,加密和解密过程使用相同的密钥。
在Java中,我们可以使用Java的加密库如Java Cryptography Extension (JCE)实现AES 加密解密。
3.DES加密解密原理及实现DES是一种对称加密算法,其加密过程和解密过程使用不同的密钥。
在Java中,我们可以使用Java Cryptography Extension (JCE)实现DES加密解密。
4.SM2加密解密原理及实现SM2是一种国密算法,具有非对称加密和对称加密的特点。
在前端,我们可以使用SM2加密请求参数,然后在后台使用对应的私钥进行解密。
在Java 中,我们可以使用Hutool库实现SM2加密解密。
5.总结:选择合适的加密解密方法及注意事项在实际应用中,选择合适的加密解密方法至关重要。
需要考虑数据安全性、算法复杂度、性能和兼容性等因素。
此外,还需注意以下几点:- 加密解密算法应根据实际需求进行选择,如对称加密算法适用于加密大量数据,非对称加密算法适用于加密少量数据;- 加密密钥和解密密钥应妥善保管,避免泄露;- 在传输加密数据时,应注意防范中间人攻击,可以使用SSL/TLS等安全协议进行保护;- 定期更新和升级加密算法,以应对潜在的安全威胁。
本文介绍了Java后台加密解密方法,包括RSA、AES、DES和SM2。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
【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) {