Java方法加密与解密
java 密码加密解密方法
java 密码加密解密方法在Java中,密码的加密和解密可以通过多种方式实现。
其中,常用的方法包括使用MessageDigest类进行加密,以及使用对称加密和非对称加密算法进行加密和解密。
一种常见的密码加密方法是使用MessageDigest类进行加密。
这可以通过以下步骤实现:首先,将密码转换为字节数组。
然后,使用MessageDigest类的getInstance方法获取特定的加密算法实例,例如SHA-256或MD5。
接下来,使用update方法将密码的字节数组传递给MessageDigest实例。
最后,使用digest方法获得加密后的字节数组,并将其转换为十六进制字符串或其他格式存储在数据库或其他地方。
另一种常见的方法是使用对称加密算法,例如AES或DES。
这些算法使用相同的密钥进行加密和解密。
在Java中,可以使用javax.crypto包中的类来实现对称加密。
通常,需要生成一个密钥并将其存储在安全的地方,然后使用该密钥对密码进行加密和解密。
此外,还可以使用非对称加密算法,例如RSA。
这种方法使用公钥对数据进行加密,然后使用私钥进行解密。
在Java中,可以使用java.security包中的类来实现非对称加密。
无论使用哪种方法,都需要注意密码安全的问题。
例如,密钥的安全存储和管理,以及密码传输过程中的安全性。
另外,还需要考虑密码的哈希加盐等技术来增加密码的安全性。
总之,在Java中实现密码的加密和解密有多种方法,开发人员可以根据实际需求和安全要求选择合适的加密算法和实现方式。
希望这些信息能够帮助你更好地理解Java中密码加密解密的方法。
SpringBoot中_JAVA利用国密算法_实现内容的加密_解密
首先来看一下什么是国密算法:国密即国家密码局认定的国产密码算法,即商用密码。
国密主要有SM1,SM2,SM3,SM4。
密钥长度和分组长度均为128位。
1、SM1 为对称加密。
其加密强度与AES(高级加密标准,Advanced Encryption Standard)相当。
该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用。
2、SM2为非对称加密,基于ECC。
该算法已公开。
由于该算法基于ECC,故其签名速度与秘钥生成速度都快于RSA。
ECC 256位(SM2采用的就是ECC 256位的一种)安全强度比RSA 2048位高,但运算速度快于RSA。
3、SM3为消息摘要。
可以用MD5作为对比理解。
该算法已公开。
校验结果为256位。
4、SM4为无线局域网标准的分组数据算法。
对称加密,密钥长度和分组长度均为128位。
由于SM1、SM4加解密的分组大小为128bit,故对消息进行加解密时,若消息长度过长,需要进行分组,要消息长度不足,则要进行填充。
在很多地方还是会用到的,这里说一下这个:SM21.在pom.xml中引入依赖jar包:<dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>2.然后来写一个工具类,用来生成国密的,公钥和私钥这个密码对.import org.bouncycastle.jce.provider.BouncyCastleProvider;import java.security.*;import java.security.spec.ECGenParameterSpec;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.Base64;/*** @author hulala* @Description 国密公私钥对工具类public class KeyUtils {/*** 生成国密公私钥对** @return* @throws Exception*/public static String[] generateSmKey() throws Exception {KeyPairGenerator keyPairGenerator = null;SecureRandom secureRandom = new SecureRandom();ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");keyPairGenerator = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());keyPairGenerator.initialize(sm2Spec);keyPairGenerator.initialize(sm2Spec, secureRandom);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();PublicKey publicKey = keyPair.getPublic();//String[0] 公钥//String[1] 私钥String[] result = {new String(Base64.getEncoder().encode(publicKey.getEncoded())), new String(Base64.getEncoder().encode(privateKey.getEncoded())) };return result;}/*** 将Base64转码的公钥串,转化为公钥对象** @param publicKey* @return*/public static PublicKey createPublicKey(String publicKey) {PublicKey publickey = null;try {X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePublic(publicKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}/*** 将Base64转码的私钥串,转化为私钥对象** @param privateKey* @return*/public static PrivateKey createPrivateKey(String privateKey) {PrivateKey publickey = null;try {PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}}3.根据公钥和私钥工具类,生成的密钥对,对数据,进行加密和解密操作import org.bouncycastle.asn1.gm.GMObjectIdentifiers;import org.bouncycastle.crypto.InvalidCipherTextException;import org.bouncycastle.crypto.engines.SM2Engine;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;import org.bouncycastle.crypto.params.ParametersWithRandom;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.jce.spec.ECParameterSpec;import java.security.*;/*** @author hulala* @Description SM2实现工具类*/public class Sm2Util {static {Security.addProvider(new BouncyCastleProvider());}/*** 根据publicKey对原始数据data,使用SM2加密** @param data* @param publicKey* @return*/public static byte[] encrypt(byte[] data, PublicKey publicKey) {ECPublicKeyParameters localECPublicKeyParameters = null;if (publicKey instanceof BCECPublicKey) {BCECPublicKey localECPublicKey = (BCECPublicKey) publicKey;ECParameterSpec localECParameterSpec = localECPublicKey.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());localECPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(), localECDomainParameters);}SM2Engine localSM2Engine = new SM2Engine();localSM2Engine.init(true, new ParametersWithRandom(localECPublicKeyParameters, new SecureRandom()));byte[] arrayOfByte2;try {arrayOfByte2 = localSM2Engine.processBlock(data, 0, data.length);return arrayOfByte2;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 根据privateKey对加密数据encodedata,使用SM2解密** @param encodedata* @param privateKey* @return*/public static byte[] decrypt(byte[] encodedata, PrivateKey privateKey) {SM2Engine localSM2Engine = new SM2Engine();BCECPrivateKey sm2PriK = (BCECPrivateKey) privateKey;ECParameterSpec localECParameterSpec = sm2PriK.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());ECPrivateKeyParameters localECPrivateKeyParameters = new ECPrivateKeyParameters(sm2PriK.getD(),localECDomainParameters);localSM2Engine.init(false, localECPrivateKeyParameters);try {byte[] arrayOfByte3 = localSM2Engine.processBlock(encodedata, 0, encodedata.length);return arrayOfByte3;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 私钥签名** @param data* @param privateKey* @return* @throws Exception*/public static byte[] signByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception { Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initSign(privateKey);sig.update(data);byte[] ret = sig.sign();return ret;}/*** 公钥验签** @param data* @param publicKey* @param signature* @return* @throws Exception*/public static boolean verifyByPublicKey(byte[] data, PublicKey publicKey, byte[] signature) throws Exception {Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initVerify(publicKey);sig.update(data);boolean ret = sig.verify(signature);return ret;}}4.来测试一下,对数据进行加密解密import org.junit.Test;import java.util.Base64;/*** @author hulala* @Description Sm2Util 的测试类*/public class Sm2UtilTest {private String testStr = "wangjing";java.security.PublicKey publicKey = null;java.security.PrivateKey privateKey = null;@Testpublic void test() throws Exception {//生成公私钥对String[] keys = KeyUtils.generateSmKey();System.out.println("原始字符串:" + testStr);System.out.println("公钥:" + keys[0]);publicKey = KeyUtils.createPublicKey(keys[0]);System.out.println("私钥:" + keys[1]);privateKey = KeyUtils.createPrivateKey(keys[1]);System.out.println("");byte[] encrypt = Sm2Util.encrypt(testStr.getBytes(), publicKey);String encryptBase64Str = Base64.getEncoder().encodeToString(encrypt);System.out.println("加密数据:" + encryptBase64Str);byte[] decode = Base64.getDecoder().decode(encryptBase64Str);byte[] decrypt = Sm2Util.decrypt(decode, privateKey);System.out.println("解密数据:" + new String(decrypt));byte[] sign = Sm2Util.signByPrivateKey(testStr.getBytes(), privateKey);System.out.println("数据签名:" + Base64.getEncoder().encodeToString(sign));boolean b = Sm2Util.verifyByPublicKey(testStr.getBytes(), publicKey, sign);System.out.println("数据验签:" + b);}}5.这样就实现了利用国密,SM2进行加密解密了.。
Java实现DES加密解密
Java实现DES加密解密DES(Data Encryption Standard)是⼀种对称加密算法,所谓对称加密就是加密和解密都是使⽤同⼀个密钥加密原理:DES 使⽤⼀个 56 位的密钥以及附加的 8 位奇偶校验位,产⽣最⼤ 64 位的分组⼤⼩。
这是⼀个迭代的分组密码,使⽤称为 Feistel 的技术,其中将加密的⽂本块分成两半。
使⽤⼦密钥对其中⼀半应⽤循环功能,然后将输出与另⼀半进⾏"异或"运算;接着交换这两半,这⼀过程会继续下去,但最后⼀个循环不交换。
DES 使⽤ 16 个循环,使⽤异或,置换,代换,移位操作四种基本运算。
不过,DES已可破解,所以针对保密级别特别⾼的数据推荐使⽤⾮对称加密算法。
下⾯介绍基于Java实现的DES加解密⽅法,该⽅法同样适⽤于Android平台,使⽤的是JDK1.8。
public class DESUtil {/*** 偏移变量,固定占8位字节*/private final static String IV_PARAMETER = "12345678";/*** 密钥算法*/private static final String ALGORITHM = "DES";/*** 加密/解密算法-⼯作模式-填充模式*/private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";/*** 默认编码*/private static final String CHARSET = "utf-8";/*** ⽣成key** @param password* @return* @throws Exception*/private static Key generateKey(String password) throws Exception {DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);return keyFactory.generateSecret(dks);}/*** DES加密字符串** @param password 加密密码,长度不能够⼩于8位* @param data 待加密字符串* @return 加密后内容*/public static String encrypt(String password, String data) {if (password== null || password.length() < 8) {throw new RuntimeException("加密失败,key不能⼩于8位");}if (data == null)return null;try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));//JDK1.8及以上可直接使⽤Base64,JDK1.7及以下可以使⽤BASE64Encoder//Android平台可以使⽤android.util.Base64return new String(Base64.getEncoder().encode(bytes));} catch (Exception e) {e.printStackTrace();return data;}}/*** DES解密字符串** @param password 解密密码,长度不能够⼩于8位* @param data 待解密字符串* @return 解密后内容*/public static String decrypt(String password, String data) {if (password== null || password.length() < 8) {throw new RuntimeException("加密失败,key不能⼩于8位");}if (data == null)return null;try {Key secretKey = generateKey(password);Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET); } catch (Exception e) {e.printStackTrace();return data;}}/*** DES加密⽂件** @param srcFile 待加密的⽂件* @param destFile 加密后存放的⽂件路径* @return 加密后的⽂件路径*/public static String encryptFile(String password, String srcFile, String destFile) {if (password== null || password.length() < 8) {throw new RuntimeException("加密失败,key不能⼩于8位");}try {IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, generateKey(key), iv);InputStream is = new FileInputStream(srcFile);OutputStream out = new FileOutputStream(destFile);CipherInputStream cis = new CipherInputStream(is, cipher);byte[] buffer = new byte[1024];int r;while ((r = cis.read(buffer)) > 0) {out.write(buffer, 0, r);}cis.close();is.close();out.close();return destFile;} catch (Exception ex) {ex.printStackTrace();}return null;}/*** DES解密⽂件** @param srcFile 已加密的⽂件* @param destFile 解密后存放的⽂件路径* @return 解密后的⽂件路径*/public static String decryptFile(String password, String srcFile, String destFile) {if (password== null || password.length() < 8) {throw new RuntimeException("加密失败,key不能⼩于8位");}try {File file = new File(destFile);if (!file.exists()) {file.getParentFile().mkdirs();file.createNewFile();}IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, generateKey(key), iv);InputStream is = new FileInputStream(srcFile);OutputStream out = new FileOutputStream(destFile);CipherOutputStream cos = new CipherOutputStream(out, cipher);byte[] buffer = new byte[1024];int r;while ((r = is.read(buffer)) >= 0) {cos.write(buffer, 0, r);}cos.close();is.close();out.close();return destFile;} catch (Exception ex) { ex.printStackTrace(); }return null;}}。
javamd5加密和解密算法实例 -回复
javamd5加密和解密算法实例-回复Javamd5加密和解密算法实例在计算机领域中,数据的安全性是非常重要的。
为了保护数据免受未经授权的访问,数据通常需要进行加密。
MD5是一种常用的加密算法之一,它可以将数据转换为一串固定长度的密文。
在本文中,将详细介绍Java 中的MD5加密和解密算法的实例。
MD5(Message Digest algorithm 5)是一种单向加密算法,它将任意长度的数据块转换为固定长度的密文,通常为128位。
与传统的加密算法不同,MD5无法逆向解密,因此被广泛应用于密码存储和验证等领域。
在Java中,我们可以使用Java.security包中的MessageDigest类实现MD5加密和解密。
首先,我们需要确定要加密的数据,然后创建一个MessageDigest对象并将其初始化为使用MD5算法。
接下来,通过调用update()方法将数据传递给MessageDigest对象,并使用digest()方法获得加密后的结果。
下面是一个使用Java MD5算法加密的示例:javaimport java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class MD5Example {public static void main(String[] args) {String data = "Hello, World!";String encryptedData = encryptMD5(data);System.out.println("Encrypted data: " + encryptedData);}public static String encryptMD5(String data) {try {MessageDigest md =MessageDigest.getInstance("MD5");md.update(data.getBytes());byte[] encryptedBytes = md.digest();StringBuilder sb = new StringBuilder();for (byte b : encryptedBytes) {sb.append(String.format("02x", b & 0xff));}return sb.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}return null;}}在上面的示例中,我们定义了一个名为MD5Example的类,其中包含了一个名为encryptMD5的静态方法。
Java 加密、解密Word文档
Java加密、解密Word文档对一些重要文档,我们为保证其文档内容不被泄露,常需要对文件进行加密,查看文件时,需要正确输入密码才能打开文件。
下面介绍了一种比较简单的方法给Word文件添加密码保护以及如何给已加密的Word文件取消密码保护。
使用工具:Free Spire.Doc for Java 2.0.0(免费版)Jar文件导入:方法1:通过官网下载控件包。
在程序下新建一个directory目录,并命名(本示例中命名为lib);将控件包lib文件夹下的jar(如下图1)复制到程序中新建的目录下。
复制jar文件后,鼠标右键点击jar文件,选择”Add as Library”。
完成导入(如下图2)。
图1:图2:方法2:通过maven导入。
参考导入方法。
Java代码示例【示例1】设置Word密码保护import com.spire.doc.*;public class Encrypt {public static void main(String[] args){//加载测试文档String input = "test.docx";String output= "result.docx";Document doc = new Document(input);//调用方法加密文档doc.encrypt("123");//保存加密后的文档doc.saveToFile(output);}}文件加密结果:【示例2】取消Word密码保护import com.spire.doc.*;public class Decrypt {public static void main(String[] args){//加载带密码的文件,输入原密码并解除Document doc = new Document();doc.loadFromFile("result.docx",FileFormat.Docx_2013,"123");//将解密后的文档另存doc.saveToFile("Decrypt.docx",FileFormat.Docx_2013);}}运行程序后,生成的文件将不再有密码保护。
java中sha256加解密方法
java中sha256加解密方法SHA256是一种常用的加密算法,它可以对数据进行加密和解密操作。
在Java中,我们可以使用Java的安全库提供的功能来实现SHA256的加解密。
我们需要导入Java的安全库,这可以通过在代码中添加以下语句来实现:```import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;```接下来,我们需要定义一个方法来实现SHA256的加密功能,可以命名为sha256Encrypt。
该方法接受一个字符串作为参数,并返回一个加密后的字符串。
具体代码如下:```public static String sha256Encrypt(String input) {try {MessageDigest digest = MessageDigest.getInstance("SHA-256");byte[] hash = digest.digest(input.getBytes("UTF-8"));StringBuilder hexString = new StringBuilder();for (byte b : hash) {String hex = Integer.toHexString(0xff & b);if (hex.length() == 1) hexString.append('0');hexString.append(hex);}return hexString.toString();} catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {e.printStackTrace();}return null;}```在这个方法中,我们首先通过调用MessageDigest.getInstance("SHA-256")来获取SHA-256算法的实例。
java常用加密和解密工具类EncryptUtil.java
java常⽤加密和解密⼯具类EncryptUtil.java 1package cn.util;23import java.io.UnsupportedEncodingException;4import java.security.MessageDigest;5import java.security.NoSuchAlgorithmException;6import java.security.SecureRandom;78import javax.crypto.Cipher;9import javax.crypto.SecretKey;10import javax.crypto.SecretKeyFactory;11import javax.crypto.spec.DESKeySpec;1213/**14 * 加密⼯具类15 *16 * md5加密出来的长度是32位17 *18 * sha加密出来的长度是40位19 *20 * @author伍⽟林21 *22*/23public final class EncryptUtil {2425private static final String PASSWORD_CRYPT_KEY = "88444488";2627private final static String DES = "DES";2829/**30 * ⼆次加密先sha-1加密再⽤MD5加密31 *32 * @param src33 * @return34*/35public final static String md5AndSha(String src) {36return md5(sha(src));37 }3839/**40 * ⼆次加密先MD5加密再⽤sha-1加密41 *42 * @param src43 * @return44*/45public final static String shaAndMd5(String src) {46return sha(md5(src));47 }4849/**50 * md5加密51 *52 * @param src53 * @return54*/55public final static String md5(String src) {56return encrypt(src, "md5");57 }5859/**60 * sha-1加密61 *62 * @param src63 * @return64*/65public final static String sha(String src) {66return encrypt(src, "sha-1");67 }6869/**70 * md5或者sha-1加密71 *72 * @param src73 * 要加密的内容74 * @param algorithmName75 * 加密算法名称:md5或者sha-1,不区分⼤⼩写76 * @return77*/78private final static String encrypt(String src, String algorithmName) {79if (src == null || "".equals(src.trim())) {80throw new IllegalArgumentException("请输⼊要加密的内容");81 }82if (algorithmName == null || "".equals(algorithmName.trim())) {83 algorithmName = "md5";84 }85 String encryptText = null;86try {87 MessageDigest m = MessageDigest.getInstance(algorithmName);88 m.update(src.getBytes("UTF8"));89byte s[] = m.digest();90// m.digest(src.getBytes("UTF8"));91return hex(s);92 } catch (NoSuchAlgorithmException e) {93 e.printStackTrace();94 } catch (UnsupportedEncodingException e) {95 e.printStackTrace();96 }97return encryptText;98 }99100/**101 * 密码解密102 *103 * @param data104 * @return105 * @throws Exception106*/107public final static String decrypt(String src) {108try {109return new String(decrypt(hex2byte(src.getBytes()), PASSWORD_CRYPT_KEY.getBytes())); 110 } catch (Exception e) {111 }112return null;113 }114115/**116 * 密码加密117 *118 * @param password119 * @return120 * @throws Exception121*/122public final static String encrypt(String src) {123try {124return byte2hex(encrypt(src.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));125 } catch (Exception e) {126 }127return null;128 }129130/**131 * 加密132 *133 * @param src134 * 数据源135 * @param key136 * 密钥,长度必须是8的倍数137 * @return返回加密后的数据138 * @throws Exception139*/140private static byte[] encrypt(byte[] src, byte[] key) throws Exception {141// DES算法要求有⼀个可信任的随机数源142 SecureRandom sr = new SecureRandom();143// 从原始密匙数据创建DESKeySpec对象144 DESKeySpec dks = new DESKeySpec(key);145// 创建⼀个密匙⼯⼚,然后⽤它把DESKeySpec转换成⼀个SecretKey对象146 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);147 SecretKey securekey = keyFactory.generateSecret(dks);148// Cipher对象实际完成加密操作149 Cipher cipher = Cipher.getInstance(DES);150// ⽤密匙初始化Cipher对象151 cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);152// 现在,获取数据并加密正式执⾏加密操作153return cipher.doFinal(src);154 }155156/**157 * 解密158 *159 * @param src160 * 数据源161 * @param key162 * 密钥,长度必须是8的倍数163 * @return返回解密后的原始数据164 *165 * @throws Exception166*/167private final static byte[] decrypt(byte[] src, byte[] key) throws Exception {168// DES算法要求有⼀个可信任的随机数源169 SecureRandom sr = new SecureRandom();170// 从原始密匙数据创建⼀个DESKeySpec对象171 DESKeySpec dks = new DESKeySpec(key);172// 创建⼀个密匙⼯⼚,然后⽤它把DESKeySpec对象转换成⼀个SecretKey对象173 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);174 SecretKey securekey = keyFactory.generateSecret(dks);175// Cipher对象实际完成解密操作176 Cipher cipher = Cipher.getInstance(DES);177// ⽤密匙初始化Cipher对象178 cipher.init(Cipher.DECRYPT_MODE, securekey, sr);179// 现在,获取数据并解密正式执⾏解密操作180return cipher.doFinal(src);181 }182183private final static byte[] hex2byte(byte[] b) {184if ((b.length % 2) != 0)185throw new IllegalArgumentException("长度不是偶数");186byte[] b2 = new byte[b.length / 2];187for (int n = 0; n < b.length; n += 2) {188 String item = new String(b, n, 2);189 b2[n / 2] = (byte) Integer.parseInt(item, 16);190 }191return b2;192 }193194/**195 * ⼆⾏制转字符串196 *197 * @param b198 * @return199*/200private final static String byte2hex(byte[] b) {201 String hs = "";202 String stmp = "";203for (int n = 0; n < b.length; n++) {204 stmp = (ng.Integer.toHexString(b[n] & 0XFF));205if (stmp.length() == 1)206 hs = hs + "0" + stmp;207else208 hs = hs + stmp;209 }210return hs.toUpperCase();211 }212213/**214 * 返回⼗六进制字符串215 *216 * @param arr217 * @return218*/219private final static String hex(byte[] arr) {220 StringBuffer sb = new StringBuffer();221for (int i = 0; i < arr.length; ++i) {222 sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1, 3)); 223 }224return sb.toString();225 }226227 }。
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数据库密码解密方法
在Java中,数据库密码解密的方法通常涉及使用安全的加密算法对存储的加密密码进行解密。
以下是一种常见的解密方法:1.使用加密算法对密码进行加密:在连接数据库之前,可以使用一种安全的加密算法(如AES或RSA)对密码进行加密,并将加密后的密码存储在配置文件或数据库中。
确保在此过程中,使用了安全的密钥管理和存储方法,以防止密码泄露。
2.在应用程序中使用解密算法解密密码:在应用程序中,您可以使用相应的解密算法以及正确的密钥来解密数据库密码。
以下是一种简单的示例:import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;public class DatabasePasswordDecryptor {private static final String ENCRYPTION_KEY ="YourEncryptionKey";/ / 替换为加密密钥public static String decrypt(String encryptedPassword)throws Excep tion{byte[] decodedKey = Base64.getDecoder().decode(ENCRYPTION_KEY);SecretKeySpec keySpec =new SecretKeySpec(decodedKey,"AES");Cipher cipher =Cipher.getInstance("AES");cipher.init(Cipher.DECRYPT_MODE, keySpec);byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(en cryptedPassword));return new String(decrypted);}public static void main(String[] args){try{String encryptedPassword ="YourEncryptedPassword";// 替换为加密密码String decryptedPassword =decrypt(encryptedPassword);System.out.println("Decrypted Password: "+ decryptedPasswo rd);}catch(Exception e){e.printStackTrace();}}}在这个例子中,需要替换ENCRYPTION_KEY和encryptedPassword为实际的加密密钥和加密后的密码。
java 实现浮点数字加密 和 减密的方法
java 实现浮点数字加密和减密的方法文章标题:深入探讨Java实现浮点数字加密和解密的方法一、引言在现代信息时代,数据加密和解密变得越来越重要。
而对于浮点数数据的加密和解密,尤为关键。
本文将从Java语言的角度,探讨如何实现对浮点数进行加密和解密的方法。
二、浮点数字加密的实现方法1. 对浮点数进行位运算在Java中,可以通过位运算的方式对浮点数进行加密。
通过对浮点数的二进制表示进行位运算,可以实现加密的目的。
可以使用异或操作对浮点数的二进制位进行加密,从而保护数据的安全性。
2. 使用加密算法对浮点数进行处理Java中提供了丰富的加密算法库,可以通过这些算法对浮点数进行加密处理。
可以使用MD5、SHA等哈希算法对浮点数进行加密,实现数据的安全存储和传输。
3. 自定义加密算法除了使用Java已有的加密算法外,也可以自定义加密算法对浮点数进行加密。
通过与他人不可知的复杂算法,可以更好地保护浮点数数据的安全性。
三、浮点数字解密的实现方法1. 逆向位运算对于使用位运算进行浮点数加密的情况,可以通过进行逆向位运算的方式进行解密。
通过与加密时相反的位运算,可以还原出原始的浮点数数据。
2. 使用解密算法对浮点数进行处理与加密算法类似,Java中同样提供了丰富的解密算法库。
可以通过这些算法对加密过的浮点数进行解密,获取原始数据。
3. 自定义解密算法倘若使用了自定义的加密算法,那么也需要相应的自定义解密算法。
通过对加密过的浮点数数据进行逆向运算,可以实现解密的目的。
四、个人观点和理解在实际项目中,对浮点数进行加密和解密是一项非常重要的任务。
通过对浮点数数据进行加密,可以有效地保护数据的安全性,防止数据被未经授权的访问。
合理的加密和解密算法的选择,也是保证系统数据安全的重要一环。
总结与回顾通过本文的介绍,我们了解到了Java实现浮点数加密和解密的方法。
无论是通过位运算、使用加密算法,还是自定义加密算法,都可以实现对浮点数数据的安全处理。
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中decrypt和encrypt方法
java中decrypt和encrypt方法在Java中,加密(encrypt)和解密(decrypt)是非常常见和重要的操作。
加密是将明文数据转换为密文数据,以保护数据的安全性。
而解密是将密文数据重新转换为明文数据,以便于使用和理解。
本文将介绍Java中的加密和解密方法,包括常见的加密算法和使用示例。
在Java中,加密和解密操作通常使用加密算法来完成。
常用的加密算法包括对称加密和非对称加密。
对称加密是一种使用同一个密钥进行加密和解密的算法。
常见的对称加密算法有DES(Data Encryption Standard)、AES(Advanced Encryption Standard)等。
其中,AES是目前最常用和最安全的对称加密算法。
对称加密的特点是速度快,但密钥的传输和管理相对较复杂。
非对称加密是一种使用两个不同的密钥进行加密和解密的算法,分别为公钥和私钥。
公钥用于加密数据,私钥用于解密数据。
常见的非对称加密算法有RSA(Rivest-Shamir-Adleman)、DSA(DigitalSignature Algorithm)等。
非对称加密的特点是安全性较高,但速度相对较慢。
下面是一些常用的加密和解密方法的示例:1.对称加密:对称加密的示例中,我们使用AES算法和密钥来加密和解密数据。
```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import java.security.SecureRandom;public class SymmetricEncryptionExample {public static void main(String[] args) throws Exception { //生成AES密钥KeyGenerator keyGenerator =KeyGenerator.getInstance("AES");keyGenerator.init(128, new SecureRandom());SecretKey secretKey = keyGenerator.generateKey();//创建加密和解密的实例Cipher cipher = Cipher.getInstance("AES");//加密数据String plainText = "Hello, World!";cipher.init(Cipher.ENCRYPT_MODE, secretKey);byte[] encryptedText =cipher.doFinal(plainText.getBytes());System.out.println("加密后的数据:" + newString(encryptedText));//解密数据cipher.init(Cipher.DECRYPT_MODE, secretKey);byte[] decryptedText = cipher.doFinal(encryptedText);System.out.println("解密后的数据:" + newString(decryptedText));}}```在上面的示例中,我们首先使用AES算法生成一个128位的密钥。
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) {
JAVAAES加密与解密
其中的getKey()
public static Key getKey(String keySeed) { if (keySeed == null) { keySeed = System.getenv("AES_SYS_KEY"); } if (keySeed == null) { keySeed = System.getProperty("AES_SYS_KEY"); } if (keySeed == null || keySeed.trim().length() == 0) { keySeed = "abcd1234!@#$";// 默认种子 } try { SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG"); secureRandom.setSeed(keySeed.getBytes()); KeyGenerator generator = KeyGenerator.getInstance("AES"); generator.init(secureRandom); return generator.generateKey(); } catch (Exception e) { throw new RuntimeException(e); } }
AES/PCBC/PKCS5Padding 32 16 AES/PCBC/ISO10126Padding 32 16
可以看到,在原始数据长度为16的整数倍时,假如原始数据长度等于16*n,则使用NoPadding时加密后数据长度等于16*n,其它情况下加 密数据长 度等于16*(n+1)。在不足16的整数倍的情况下,假如原始数据长度等于16*n+m[其中m小于16],除了NoPadding填充之外的任何方 式,加密数据长度都等于16*(n+1);NoPadding填充情况下,CBC、ECB和PCBC三种模式是不支持的,CFB、OFB两种模式下则加密 数 据长度等于原始数据长度。
Java的MD5盐值加密,Des加密解密和base64加密解密使用方法
Java的MD5盐值加密,Des加密解密和base64加密解密使⽤⽅法java⽀持md5盐值加密和des加密。
做项⽬时,某些模块添加加密功能可以提⾼⽤户个⼈信息安全性,防⽌信息泄露,其中des⽀持加密解密,MD5⽬前只⽀持加密(多⽤于⽤户登录密码验证,所以⽆需解密展⽰)。
⼀、MD5盐值加密1.在pom⽂件中导⼊相关jar包<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-core</artifactId><version>1.3.2</version></dependency>2.编写MD5类import org.apache.shiro.crypto.hash.SimpleHash;/*** 加密⼯具类* @author john**/public class MD5 {//加密类型private static String hashName="MD5";//加密次数private static int hashNum=1024;//pwd是需要加密的字符,salt是盐值(⾃定义),hashNum是加密次数,次数越多越安全public static Object getMD5(String pwd,String salt){Object obj=new SimpleHash(hashName, pwd, salt, hashNum);return obj;}}加密⽅法是静态⽅法,使⽤时直接MD5.getMD5(pwd,salt).toString();即可。
暂⽆解密⽅法。
⼆、Base64加密1.同样第⼀步也是导⼊base相关jar包<!-- Base64 --><dependency><groupId>commons-codec</groupId><artifactId>commons-codec</artifactId><version>1.14</version></dependency>2.编写base64类import mons.codec.binary.Base64;public class Base64Utils {/*** 加密** @param plainText* @return*/public static String encodeStr(String plainText) {byte[] b = plainText.getBytes();Base64 base64 = new Base64();b = base64.encode(b);return new String(b);}/*** 解密** @param encodeStr* @return*/public static String decodeStr(String encodeStr) {byte[] b = encodeStr.getBytes();Base64 base64 = new Base64();b = base64.decode(b);return new String(b);}}加密解密的⽅法同样是静态⽅法,直接类名.⽅法名调⽤即可。
Java使用Hutool实现AES、DES加密解密的方法
Java使⽤Hutool实现AES、DES加密解密的⽅法在Java世界中,AES、DES加密解密需要使⽤Cipher对象构建加密解密系统,Hutool中对这⼀对象做再包装,简化了加密解密过程。
介绍AES和DES同属对称加密算法,数据发信⽅将明⽂(原始数据)和加密密钥⼀起经过特殊加密算法处理后,使其变成复杂的加密密⽂发送出去。
收信⽅收到密⽂后,若想解读原⽂,则需要使⽤加密⽤过的密钥及相同算法的逆算法对密⽂进⾏解密,才能使其恢复成可读明⽂。
在对称加密算法中,使⽤的密钥只有⼀个,发收信双⽅都使⽤这个密钥对数据进⾏加密和解密,这就要求解密⽅事先必须知道加密密钥。
在Java世界中,AES、DES加密解密需要使⽤Cipher对象构建加密解密系统,Hutool中对这⼀对象做再包装,简化了加密解密过程。
引⼊Hutool<dependency><groupId>com.xiaoleilu</groupId><artifactId>hutool-all</artifactId><version>3.0.9</version></dependency>使⽤AES加密解密String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();//构建AES aes = SecureUtil.aes(key);//加密byte[] encrypt = aes.encrypt(content);//解密byte[] decrypt = aes.decrypt(encrypt);//加密为16进制表⽰String encryptHex = des.encryptHex(content);//解密为原字符串String decryptStr = des.decryptStr(encryptHex);DES加密解密DES的使⽤⽅式与AES基本⼀致String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue()).getEncoded();//构建DES des = SecureUtil.des(key);//加密解密byte[] encrypt = des.encrypt(content);byte[] decrypt = des.decrypt(encrypt);//加密为16进制,解密为原字符串String encryptHex = des.encryptHex(content);String decryptStr = des.decryptStr(encryptHex);更多Hutool中针对JDK⽀持的所有对称加密算法做了封装,封装为SymmetricCrypto类,AES和DES两个类是此类的简化表⽰。
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后台加密解密方法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)。
我们在Web开发中,经常要保证密码的安全性,那么怎么对密码进行处理了?首先得进行加密吧!下面我介绍下Java提供的SHA加密方式;SHA (Secure Hash Algorithm,译作安全散列算法) 是美国国家安全局(NSA) 设计,美国国家标准与技术研究院(NIST) 发布的一系列密码散列函数。
正式名称为SHA 的家族第一个成员发布于1993年。
然而人们给它取了一个非正式的名称SHA-0 以避免与它的后继者混淆。
两年之后,SHA-1,第一个SHA 的后继者发布了。
另外还有四种变体,曾经发布以提升输出的范围和变更一些细微设计:SHA-224, SHA-256, SHA-384 和SHA-512 (这些有时候也被称做SHA-2)。
[java]view plain copy1.package com.chinadatapay.util;2.3.import java.security.MessageDigest;4.5./**6. * SHA 加密算法7. * @author DELL8. *9. */10.11.public class SHAencrypt {12.13./**14. * 定义加密方式15. */16.private final static String KEY_SHA = "SHA";17.private final static String KEY_SHA1 = "SHA-1";18.19./**20. * 全局数组21. */22.private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",23."6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };24.25./**26. * 构造函数27. */28.public SHAencrypt() {29.30. }31.32./**33. * SHA 加密34. * @param data 需要加密的字节数组35. * @return 加密之后的字节数组36. * @throws Exception37. */38.public static byte[] encryptSHA(byte[] data) throws Exception {39.// 创建具有指定算法名称的信息摘要40.// MessageDigest sha = MessageDigest.getInstance(KEY_SHA);41. MessageDigest sha = MessageDigest.getInstance(KEY_SHA1);42.// 使用指定的字节数组对摘要进行最后更新43. sha.update(data);44.// 完成摘要计算并返回45.return sha.digest();46. }47.48./**49. * SHA 加密50. * @param data 需要加密的字符串51. * @return 加密之后的字符串52. * @throws Exception53. */54.public static String encryptSHA(String data) throws Exception {55.// 验证传入的字符串56.if (data == null || data.equals("")) {57.return"";58. }59.// 创建具有指定算法名称的信息摘要60. MessageDigest sha = MessageDigest.getInstance(KEY_SHA);61.// 使用指定的字节数组对摘要进行最后更新62. sha.update(data.getBytes());63.// 完成摘要计算64.byte[] bytes = sha.digest();65.// 将得到的字节数组变成字符串返回66.return byteArrayToHexString(bytes);67. }68.69./**70. * 将一个字节转化成十六进制形式的字符串71. * @param b 字节数组72. * @return 字符串73. */74.private static String byteToHexString(byte b) {75.int ret = b;76.//System.out.println("ret = " + ret);77.if (ret < 0) {78. ret += 256;79. }80.int m = ret / 16;81.int n = ret % 16;82.return hexDigits[m] + hexDigits[n];83. }84.85./**86. * 转换字节数组为十六进制字符串87. * @param bytes 字节数组88. * @return 十六进制字符串89. */90.private static String byteArrayToHexString(byte[] bytes) {91. StringBuffer sb = new StringBuffer();92.for (int i = 0; i < bytes.length; i++) {93. sb.append(byteToHexString(bytes[i]));94. }95.return sb.toString();96. }97.}添加一个用户,调用方法对密码进行加密操作,登陆的时候,对登陆的用户输入的密码进行加密,然后通过数据中的密码密码与用户登陆输入的密码进行比较;比如输入密码:Yan230KdString encryptSHA = SahTest.encryptSHA("Yan230Kd");加密后的密码:1dc3a28e6949b07918f3613fa3a2c9342c4e79f4package com.henii.test;import Java.security.MessageDigest;/***先通过MD5加密之后,再来一次可逆的加密。
*顺序可以调整,可以选择先用可逆加密,然后再用MD5加密*/public class MD5andKL{//MD5加密。
32位public static String MD5(String inStr) {MessageDigest md5 = null;try {md5 = MessageDigest.getInstance("MD5");} catch (Exception e) {System.out.println(e.toString());e.printStackTrace();return "";}char[] charArray = inStr.toCharArray();byte[] byteArray = new byte[charArray.length];for (int i = 0; i < charArray.length; i++)byteArray[i] = (byte) charArray[i];byte[] md5Bytes = md5.digest(byteArray);StringBuffer hexValue = new StringBuffer();for (int i = 0; i < md5Bytes.length; i++) {int val = ((int) md5Bytes[i]) & 0xff;if (val < 16)hexValue.append("0");hexValue.append(Integer.toHexString(val));}return hexValue.toString();}//可逆的加密算法public static String KL(String inStr){//String s = new String(inStr);char[] a = inStr.toCharArray();for (int i = 0;i <a.length;i++) {a[i] = (char)(a[i]^'t');}String s=new String(a);return s;}//加密后解密public static String JM(String inStr){char[] a=inStr.toCharArray();for (int i = 0;i <a.length;i++) {a[i]= (char)(a[i]^'t');}String k=new String(a);return k;}//测试主函数public static void main (String args[]){String s = new String("admin");System.out.println("原始:"+s);System.out.println("MD5后:"+MD5(s));System.out.println("MD5后再加密:"+KL(MD5(s)));System.out.println("解密为MD5后的:"+JM(KL(MD5(s))));}}、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、Java 自带的数据加密类MessageDigest(MD5或SHA加密)说明:在网站中,为了保护网站会员的用户名和密码等隐私信息,所以我们在用户注册时就直接进行MD5方式或其他方式进行加密,即使是数据库管理员也不能查看该会员的密码等信息,在数据库中查看密码效果如:8e830882f03b2cb84d1a657f346dd41a效果。
因为MD5算法是不可逆的,所以被很多网站广泛使用,普遍使用的三种加密方式方式一:使用位运算符,将加密后的数据转换成16进制方式二:使用格式化方式,将加密后的数据转换成16进制(推荐)方式三:使用算法,将加密后的数据转换成16进制import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;/*** 使用Java自带的MessageDigest类* @author xiaokui*/public class EncryptionUtil {/*** 由于MD5 与SHA-1均是从MD4 发展而来,它们的结构和强度等特性有很多相似之处* SHA-1与MD5 的最大区别在于其摘要比MD5 摘要长32 比特(1byte=8bit,相当于长4byte,转换16进制后比MD5多8个字符)。