java实现几种加密算法

合集下载

SpringBoot中_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使用Cipher类实现加密,包括DES,DES3,AES和RSA加密

Java使用Cipher类实现加密,包括DES,DES3,AES和RSA加密

Java使⽤Cipher类实现加密,包括DES,DES3,AES和RSA加密⼀、先看⼀个简单加密,解密实现1.1 加密/*** content: 加密内容* slatKey: 加密的盐,16位字符串* vectorKey: 加密的向量,16位字符串*/public String encrypt(String content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);byte[] encrypted = cipher.doFinal(content.getBytes());return Base64.encodeBase64String(encrypted);}1.2 解密/*** content: 解密内容(base64编码格式)* slatKey: 加密时使⽤的盐,16位字符串* vectorKey: 加密时使⽤的向量,16位字符串*/public String decrypt(String base64Content, String slatKey, String vectorKey) throws Exception {Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");SecretKey secretKey = new SecretKeySpec(slatKey.getBytes(), "AES");IvParameterSpec iv = new IvParameterSpec(vectorKey.getBytes());cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);byte[] content = Base64.decodeBase64(base64Content);byte[] encrypted = cipher.doFinal(content);return new String(encrypted);}1.3 代码解释上⾯简单实现了AES("AES/CBC/PKCS5Padding")的加密和解密。

java卡密登录验证算法

java卡密登录验证算法

java卡密登录验证算法Java卡密登录验证算法通常使用加密算法来保护卡密的安全性。

以下是一些常见的Java卡密登录验证算法:1、MD5加密算法:MD5是一种常用的哈希函数,可以将任意长度的消息转换为固定长度的摘要。

在Java中,可以使用MessageDigest类来实现MD5加密算法。

例如:import java.security.MessageDigest;import java.security.NoSuchAlgorithmException; public class MD5Util {public static String getMD5(String input) throws NoSuchAlgorithmException {MessageDigest md = MessageDigest.getInstance("MD5"); md.update(input.getBytes());byte[] digest = md.digest();StringBuilder sb = new StringBuilder();for (byte b : digest) {sb.append(Integer.toHexString((b & 0xFF) |0x100).substring(1, 3));}return sb.toString();}}2、SHA-256加密算法:SHA-256是一种比MD5更安全的哈希函数,可以生成更长的摘要。

在Java中,可以使用MessageDigest类来实现SHA-256加密算法。

例如:import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class SHA256Util {public static String getSHA256(String input) throws NoSuchAlgorithmException {MessageDigest sha256 =MessageDigest.getInstance("SHA-256");sha256.update(input.getBytes());byte[] digest = sha256.digest();StringBuilder sb = new StringBuilder();for (byte b : digest) {sb.append(Integer.toHexString(b & 0xFF)); }return sb.toString();}}3、HMAC加密算法:HMAC是一种基于密钥的消息认证码算法,可以用于验证消息的完整性和真实性。

如何利用java程序实现加密所需的公钥、密钥、数字证书

如何利用java程序实现加密所需的公钥、密钥、数字证书

如何利⽤java程序实现加密所需的公钥、密钥、数字证书本篇的主要⽬的在于实现pdf的数字签名问题,只是作为我学习知识的总结。

1、数字签名算法的概述数字签名:私钥⽤于签名,公钥⽤于验证。

数字签名的作⽤:验证数据的完整性,认证数据来源,抗否认。

数字签名实现的具体原理:1、将报⽂按双⽅约定的HASH算法计算得到⼀个固定位数的报⽂摘要。

在数学上保证,只要改动报⽂中任何⼀位,重新计算出的报⽂摘要值就会与原先的值不相符。

这样就保证了报⽂的不可更改性。

(详见参考资料的"公钥密码技术原理"章节)2、将该报⽂摘要值⽤发送者的私⼈密钥加密,然后连同原报⽂和数字证书(包含公钥)⼀起发送给接收者⽽产⽣的报⽂即称数字签名。

3、接收⽅收到数字签名后,⽤同样的HASH算法对报⽂计算摘要值,然后与⽤发送者的公开密钥进⾏解密解开的报⽂摘要值相⽐较,如相等则说明报⽂确实来⾃所称的发送者。

4、同时通过证书颁发机构CA确认证书的有效性即可确认发送的真实⾝份。

常⽤的数字签名有:RSA、DSA、ECDSA2、RSA算法概述RSA是⽬前为⽌应⽤最为⼴泛的⾮对称加密算法。

⾮对称加密算法简单的说就是分成公钥和私钥。

加密和解密采⽤不同的算法实现,这样的好处是不需要像传统对称加密算法⼀样将相同算法的密钥分发给对⽅,从⽽减少密钥被获取所带来的严重危害,⽬前基本上都是采⽤⾮对称算法,⽽RSA是最为⼴泛的。

理论上1024位以上的RSA是⽆法破解的(或者未公开)。

基本原理:⾮对称算法将密码将密码分为公钥和私钥,公钥发送给⽤户(可以是多个),⽤户⽤公钥加密想要发送的数据,然后发送给服务器,服务器通过私钥解密加密后的数据。

基本步骤:⽣成公钥和私钥步骤:1. 随机选择两个不相等的质数p和q2. 计算p和q的乘积n (n的长度就是密钥长度。

3233写成⼆进制是110010100001,⼀共有12位,所以这个密钥就是12位。

实际应⽤中,RSA密钥⼀般是1024位,重要场合则为2048位。

JAVA实现AES的加密和解密算法

JAVA实现AES的加密和解密算法

JAVA实现AES的加密和解密算法JAVA实现AES的加密和解密算法加密模式为 AES-128-CBC1import javax.crypto.Cipher;2import javax.crypto.spec.IvParameterSpec;3import javax.crypto.spec.SecretKeySpec;45import sun.misc.BASE64Decoder;6import sun.misc.BASE64Encoder;78/**AES 是⼀种可逆加密算法,对⽤户的敏感信息加密处理9* 对原始数据进⾏AES加密后,在进⾏Base64编码转化;10*/11public class AESOperator {12/*13* 加密⽤的Key 可以⽤26个字母和数字组成14* 此处使⽤AES-128-CBC加密模式,key需要为16位。

15*/16private String sKey=”0123456789abcdef”;17private String ivParameter=”0123456789abcdef”;18private static AESOperator instance=null;19private AESOperator(){2021 }22public static AESOperator getInstance(){23if (instance==null)24 instance= new AESOperator();25return instance;26 }27// 加密28public String encrypt(String sSrc) throws Exception {29 Cipher cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”);30byte[] raw = sKey.getBytes();31 SecretKeySpec skeySpec = new SecretKeySpec(raw, “AES”);32 IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());//使⽤CBC模式,需要⼀个向量iv,可增加加密算法的强度33 cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);34byte[] encrypted = cipher.doFinal(sSrc.getBytes(“utf-8″));35return new BASE64Encoder().encode(encrypted);//此处使⽤BASE64做转码。

java 加密解密简单实现

java 加密解密简单实现

java 加密解密简单实现加密算法有很多种:这里只大约列举几例:1:消息摘要:(数字指纹):既对一个任意长度的一个数据块进行计算,产生一个唯一指纹。

MD5/SHA1发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要,最后进行比较摘要是否相同。

2:单匙密码体制:DES:比较简便高效,密钥简短,加解密速度快,破译极其困难,但其安全性依赖于密匙的安全性。

DES(Data Encryption Standard)是发明最早的最广泛使用的分组对称加密算法。

DES算法的入口参数有三个:Key、Data、Mode。

其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据(或称数字指纹)进行RSA算法操作,以保证发信人无法抵赖曾发过该信息(即不可抵赖性),同时也确保信息报文在经签名后末被篡改(即完整性)。

当信息接收者收到报文后,就可以用发送者的公钥对数字签名进行验证。

代表:DSA4:非对称密匙密码体制(公匙体系):加密密匙不同于解密密匙,加密密匙公之于众,谁都可以使用,解密密匙只有解密人自己知道。

代表:RSA下面是对上面几个例子进行的简单实现:Java代码1.package test;2.import java.io.FileInputStream;3.import java.io.FileOutputStream;4.import java.io.IOException;5.import java.io.ObjectInputStream;6.import java.io.ObjectOutputStream;7.import java.security.*;8.import javax.crypto.Cipher;9.import javax.crypto.KeyGenerator;10.import javax.crypto.SecretKey;11./**12. * 加密解密13. *14. * @author shy.qiu15. * @since /qiushyfm16. */17.public class CryptTest {18. /**19. * 进行MD5加密20. *21. * @param info22. * 要加密的信息23. * @return String 加密后的字符串24. */25. public String encryptToMD5(String info) {26. byte[] digesta = null;27. try {28. // 得到一个md5的消息摘要29. MessageDigest alga = MessageDigest.getInstance("MD5");30. // 添加要进行计算摘要的信息31. alga.update(info.getBytes());32. // 得到该摘要33. digesta = alga.digest();34. } catch (NoSuchAlgorithmException e) {35. e.printStackTrace();36. }37. // 将摘要转为字符串38. String rs = byte2hex(digesta);39. return rs;40. }41. /**42. * 进行SHA加密43. *44. * @param info45. * 要加密的信息46. * @return String 加密后的字符串47. */48. public String encryptToSHA(String info) {49. byte[] digesta = null;50. try {51. // 得到一个SHA-1的消息摘要52. MessageDigest alga = MessageDigest.getInstance("SHA-1");53. // 添加要进行计算摘要的信息54. alga.update(info.getBytes());55. // 得到该摘要56. digesta = alga.digest();57. } catch (NoSuchAlgorithmException e) {58. e.printStackTrace();59. }60. // 将摘要转为字符串61. String rs = byte2hex(digesta);62. return rs;63. }64. // //////////////////////////////////////////////////////////////////////////65. /**66. * 创建密匙67. *68. * @param algorithm69. * 加密算法,可用 DES,DESede,Blowfish70. * @return SecretKey 秘密(对称)密钥71. */72. public SecretKey createSecretKey(String algorithm) {73. // 声明KeyGenerator对象74. KeyGenerator keygen;75. // 声明密钥对象76. SecretKey deskey = null;77. try {78. // 返回生成指定算法的秘密密钥的 KeyGenerator 对象79. keygen = KeyGenerator.getInstance(algorithm);80. // 生成一个密钥81. deskey = keygen.generateKey();82. } catch (NoSuchAlgorithmException e) {83. e.printStackTrace();84. }85. // 返回密匙86. return deskey;87. }88. /**89. * 根据密匙进行DES加密90. *91. * @param key92. * 密匙93. * @param info94. * 要加密的信息95. * @return String 加密后的信息96. */97. public String encryptToDES(SecretKey key, String info) {98. // 定义加密算法,可用 DES,DESede,Blowfish99. String Algorithm = "DES";100. // 加密随机数生成器 (RNG),(可以不写)101. SecureRandom sr = new SecureRandom();102. // 定义要生成的密文103. byte[] cipherByte = null;104. try {105. // 得到加密/解密器106. Cipher c1 = Cipher.getInstance(Algorithm); 107. // 用指定的密钥和模式初始化Cipher对象108. // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE) 109. c1.init(Cipher.ENCRYPT_MODE, key, sr); 110. // 对要加密的内容进行编码处理,111. cipherByte = c1.doFinal(info.getBytes()); 112. } catch (Exception e) {113. e.printStackTrace();114. }115. // 返回密文的十六进制形式116. return byte2hex(cipherByte);117. }118. /**119. * 根据密匙进行DES解密120. *121. * @param key122. * 密匙123. * @param sInfo124. * 要解密的密文125. * @return String 返回解密后信息126. */127. public String decryptByDES(SecretKey key, String sInfo ) {128. // 定义加密算法,129. String Algorithm = "DES";130. // 加密随机数生成器 (RNG)131. SecureRandom sr = new SecureRandom();132. byte[] cipherByte = null;133. try {134. // 得到加密/解密器135. Cipher c1 = Cipher.getInstance(Algorithm); 136. // 用指定的密钥和模式初始化Cipher对象137. c1.init(Cipher.DECRYPT_MODE, key, sr); 138. // 对要解密的内容进行编码处理139. cipherByte = c1.doFinal(hex2byte(sInfo)); 140. } catch (Exception e) {141. e.printStackTrace();142. }143. // return byte2hex(cipherByte);144. return new String(cipherByte);145. }146. // /////////////////////////////////////////////////// //////////////////////////147. /**148. * 创建密匙组,并将公匙,私匙放入到指定文件中149. *150. * 默认放入mykeys.bat文件中151. */152. public void createPairKey() {153. try {154. // 根据特定的算法一个密钥对生成器155. KeyPairGenerator keygen = KeyPairGenerator.get Instance("DSA");156. // 加密随机数生成器 (RNG)157. SecureRandom random = new SecureRandom(); 158. // 重新设置此随机对象的种子159. random.setSeed(1000);160. // 使用给定的随机源(和默认的参数集合)初始化确定密钥大小的密钥对生成器161. keygen.initialize(512, random);// keygen.initi alize(512);162. // 生成密钥组163. KeyPair keys = keygen.generateKeyPair(); 164. // 得到公匙165. PublicKey pubkey = keys.getPublic();166. // 得到私匙167. PrivateKey prikey = keys.getPrivate(); 168. // 将公匙私匙写入到文件当中169. doObjToFile("mykeys.bat", new Object[] { prike y, pubkey });170. } catch (NoSuchAlgorithmException e) {171. e.printStackTrace();172. }173. }174. /**175. * 利用私匙对信息进行签名把签名后的信息放入到指定的文件中176. *177. * @param info178. * 要签名的信息179. * @param signfile180. * 存入的文件181. */182. public void signToInfo(String info, String signfile) {183. // 从文件当中读取私匙184. PrivateKey myprikey = (PrivateKey) getObjFromFile( "mykeys.bat", 1);185. // 从文件中读取公匙186. PublicKey mypubkey = (PublicKey) getObjFromFile("m ykeys.bat", 2);187. try {188. // Signature 对象可用来生成和验证数字签名189. Signature signet = Signature.getInstance("DSA");190. // 初始化签署签名的私钥191. signet.initSign(myprikey);192. // 更新要由字节签名或验证的数据193. signet.update(info.getBytes());194. // 签署或验证所有更新字节的签名,返回签名195. byte[] signed = signet.sign();196. // 将数字签名,公匙,信息放入文件中197. doObjToFile(signfile, new Object[] { signed, m ypubkey, info });198. } catch (Exception e) {199. e.printStackTrace();200. }201. }202. /**203. * 读取数字签名文件根据公匙,签名,信息验证信息的合法性204. *205. * @return true 验证成功 false 验证失败206. */207. public boolean validateSign(String signfile) { 208. // 读取公匙209. PublicKey mypubkey = (PublicKey) getObjFromFile(si gnfile, 2);210. // 读取签名211. byte[] signed = (byte[]) getObjFromFile(signfile,1);212. // 读取信息213. String info = (String) getObjFromFile(signfile, 3) ;214. try {215. // 初始一个Signature对象,并用公钥和签名进行验证216. Signature signetcheck = Signature.getInstance( "DSA");217. // 初始化验证签名的公钥218. signetcheck.initVerify(mypubkey);219. // 使用指定的 byte 数组更新要签名或验证的数据220. signetcheck.update(info.getBytes());221. System.out.println(info);222. // 验证传入的签名223. return signetcheck.verify(signed);224. } catch (Exception e) {225. e.printStackTrace();226. return false;227. }228. }229. /**230. * 将二进制转化为16进制字符串231. *232. * @param b233. * 二进制字节数组234. * @return String235. */236. public String byte2hex(byte[] b) {237. String hs = "";238. String stmp = "";239. for (int n = 0; n < b.length; n++) {240. stmp = (ng.Integer.toHexString(b[n] & 0 XFF));241. if (stmp.length() == 1) {242. hs = hs + "0" + stmp;243. } else {244. hs = hs + stmp;245. }246. }247. return hs.toUpperCase();248. }249. /**250. * 十六进制字符串转化为2进制251. *252. * @param hex253. * @return254. */255. public byte[] hex2byte(String hex) {256. byte[] ret = new byte[8];257. byte[] tmp = hex.getBytes();258. for (int i = 0; i < 8; i++) {259. ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1] );260. }261. return ret;262. }263. /**264. * 将两个ASCII字符合成一个字节;如:"EF"--> 0xEF 265. *266. * @param src0267. * byte268. * @param src1269. * byte270. * @return byte271. */272. public static byte uniteBytes(byte src0, byte src1) {273. byte _b0 = Byte.decode("0x" + new String(new byte[ ] { src0 }))274. .byteValue();275. _b0 = (byte) (_b0 << 4);276. byte _b1 = Byte.decode("0x" + new String(new byte[ ] { src1 }))277. .byteValue();278. byte ret = (byte) (_b0 ^ _b1);279. return ret;280. }281. /**282. * 将指定的对象写入指定的文件283. *284. * @param file285. * 指定写入的文件286. * @param objs287. * 要写入的对象288. */289. public void doObjToFile(String file, Object[] objs) {290. ObjectOutputStream oos = null;291. try {292. FileOutputStream fos = new FileOutputStream(fi le);293. oos = new ObjectOutputStream(fos);294. for (int i = 0; i < objs.length; i++) { 295. oos.writeObject(objs[i]);296. }297. } catch (Exception e) {298. e.printStackTrace();299. } finally {300. try {301. oos.close();302. } catch (IOException e) {303. e.printStackTrace();304. }305. }306. }307. /**308. * 返回在文件中指定位置的对象309. *310. * @param file311. * 指定的文件312. * @param i313. * 从1开始314. * @return315. */316. public Object getObjFromFile(String file, int i) { 317. ObjectInputStream ois = null;318. Object obj = null;319. try {320. FileInputStream fis = new FileInputStream(file );321. ois = new ObjectInputStream(fis);322. for (int j = 0; j < i; j++) {323. obj = ois.readObject();324. }325. } catch (Exception e) {326. e.printStackTrace();327. } finally {328. try {329. ois.close();330. } catch (IOException e) {331. e.printStackTrace();332. }333. }334. return obj;335. }336. /**337. * 测试338. *339. * @param args340. */341. public static void main(String[] args) {342. CryptTest jiami = new CryptTest();343. // 执行MD5加密"Hello world!"344. System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));345. // 生成一个DES算法的密匙346. SecretKey key = jiami.createSecretKey("DES"); 347. // 用密匙加密信息"Hello world!"348. String str1 = jiami.encryptToDES(key, "Hello"); 349. System.out.println("使用des加密信息Hello 为:" + str1);350. // 使用这个密匙解密351. String str2 = jiami.decryptByDES(key, str1); 352. System.out.println("解密后为:" + str2);353. // 创建公匙和私匙354. jiami.createPairKey();355. // 对Hello world!使用私匙进行签名356. jiami.signToInfo("Hello", "mysign.bat");357. // 利用公匙对签名进行验证。

hutool-all 密码加密方法

hutool-all 密码加密方法

hutool-all 密码加密方法全文共四篇示例,供读者参考第一篇示例:在应用程序开发中,密码加密是一项非常重要的安全措施。

Hutool是一个Java工具类库,提供了一系列简便易用的密码加密方法,可以帮助开发者轻松实现数据加密和解密的功能。

本文将介绍Hutool-all中的一些常用密码加密方法,并讨论如何在实际项目中应用这些方法保护用户数据安全。

Hutool-all是一个功能强大的Java工具类库,其中包含了丰富的工具方法和类,可以帮助开发者简化程序开发过程。

在密码加密方面,Hutool-all提供了多种加密算法,包括MD5、SHA-1、SHA-256、AES等。

接下来,我们将逐一介绍这些加密算法的用法和特点。

我们来看一下最常用的MD5加密算法。

MD5是一种消息摘要算法,可以将任意长度的数据转换为一个128位的数字指纹。

在Hutool-all中,可以通过如下代码来实现对字符串进行MD5加密:```String password = "123456";String md5Password = SecureUtil.md5(password);System.out.println("MD5加密后的密码:" + md5Password);```通过上面的代码,我们可以看到将字符串"123456"加密为MD5后的密码。

MD5是一种单向加密算法,不可逆,但可以用于验证原始数据的完整性。

在实际应用中,可以将用户的密码存储为MD5加密后的值,确保数据安全。

除了MD5之外,Hutool-all还提供了SHA系列的加密算法,包括SHA-1和SHA-256。

这些算法可以生产更长的摘要结果,提高了加密的安全性。

下面是一个使用SHA-256加密算法的示例代码:通过以上代码,我们可以看到将密码"123456"使用SHA-256算法加密后的结果。

DES加密算法代码

DES加密算法代码

DES加密算法代码java实现DES加密1.准备算法所需要的密钥在Java中,DES加密算法需要一个8字节长的密钥,这里使用原始的8字节长的密钥来实现DES加密算法,同时,还有一种是“密钥扩展”,可以将8字节长的密钥扩展为16字节长,只需要多添加8个字节,后面8个字节可以跟前面8字节保持一致即可,即扩展后的密钥和原始密钥共享后八个字节即可。

byte [] keyBytes = {0x11, 0x22, 0x4F, 0x58, (byte) 0x88,0x10, 0x40, 0x38,0x28, 0x25, 0x79, 0x51, (byte) 0xCB, (byte) 0xDD, 0x55, 0x66, 0x77, 0x29, 0x74, (byte) 0x98, 0x30, 0x40, 0x36, (byte)0xE2};下面介绍如何用Java来实现原始的8字节长的密钥:// 生成keyKeyGenerator keyGenerator = KeyGenerator.getInstance("DES");keyGenerator.init(new SecureRandom(keyBytes));SecretKey key = keyGenerator.generateKey(;2. 设置加密模式(Cipher Block Chaining Mode,简称CBC模式)在Java中,DES加密算法可以支持三种不同的加密模式:ECB,CBC,CFB。

其中ECB模式为最原始的模式,它不需要任何附加的参数,而CBC模式需要一个8字节的初始向量(Initial Vector,IV)参数,CFB模式需要一个1字节或8字节的变量参数,它们用来增加加密的强度。

这里,我们使用CBC模式,它是最常用的DES加密模式,下面是设置CBC模式所需要的参数:// 创建Cipher对象,指定其支持的DES算法Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");// 用密匙初始化Cipher对象IvParameterSpec param = new IvParameterSpec(iv);cipher.init(Cipher.ENCRYPT_MODE, key,param);3.加密。

java 实现pbkdf2withhmacsha256算法

java 实现pbkdf2withhmacsha256算法

java 实现pbkdf2withhmacsha256算法全文共四篇示例,供读者参考第一篇示例:如今,信息安全已成为互联网时代不可忽视的重要问题。

在日常工作和生活中,我们需要保护重要的加密信息,以确保其不被未经授权的人员访问或篡改。

在这种情况下,密码学就显得尤为重要,而密码学中的哈希函数也是至关重要的一部分。

哈希函数是将任意长度的输入数据映射为固定长度的输出数据的数学函数,它们广泛应用于数据完整性校验、数字签名和加密等安全相关领域。

在密码学中,哈希函数的一个主要应用就是密码存储和身份验证。

用户通常不直接存储密码,而是存储其哈希值,以提高密码安全性。

传统的哈希函数如MD5和SHA-1等已经相继被证明存在一定的安全性问题,因此越来越多的应用开始采用更安全的哈希函数来提高密码的安全性。

PBKDF2就是一种基于哈希函数的密码推导函数,它可以有效地提高密码的强度。

PBKDF2(Password-Based Key Derivation Function 2)是一种用于从密码派生密钥的标准方法,通常用于增加密码的安全性。

PBKDF2本质上是一个伪随机函数的迭代应用,其设计初衷是为了解决普通哈希函数在密码存储中的安全性问题。

PBKDF2通过多次调用一个伪随机函数来增加密码的强度,使得破解密码变得更加困难。

在Java中,我们可以使用PBKDF2算法结合HMAC-SHA256哈希函数来实现密码的强化存储。

HMAC(Hash-based Message Authentication Code)是一种基于哈希函数和密钥的消息认证码算法,常用于数据完整性校验和身份验证。

在PBKDF2中,我们可以选择不同的哈希函数作为伪随机函数,其中HMAC-SHA256是其中一种常用的选择。

下面,我们将演示如何在Java中使用PBKDF2算法结合HMAC-SHA256哈希函数来实现密码的强化存储:```javaimport java.security.spec.KeySpec;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.PBEKeySpec;import javax.crypto.spec.SecretKeySpec;import java.security.SecureRandom;import java.util.Base64;SecureRandom random = new SecureRandom();byte[] saltBytes = new byte[16];random.nextBytes(saltBytes);在上面的代码中,我们首先定义了密码和盐值,然后指定了迭代次数和密钥长度。

用java编程实现RSA加密算法

用java编程实现RSA加密算法

用java编程实现RSA加密算法RSA加密算法是目前应用最广泛的公钥加密算法,特别适用于通过Internet传送的数据,常用于数字签名和密钥交换。

那么我今天就给大家介绍一下如何利用Java编程来实现RSA加密算法。

一、RSA加密算法描述RSA加密算法是1978年提出的。

经过多年的分析和研究,在众多的公开密钥加密算法中,RSA加密算法最受推崇,它也被推荐为公开密钥数据加密标准。

由数论知识可知,若将一个具有大素数因子的合数进行分解是很困难的,或者说这个问题的计算量是令人望而生畏的,而RSA加密算法正是建立在这个基础上的。

在RSA加密算法中,—个用户A可根据以下步骤来选择密钥和进行密码转换:(1)随机的选取两个不同的大素数p和q(一般为100位以上的十进制数),予以保密;(2)计算n=p*q,作为用户A的模数,予以公开;(3)计算欧拉(Euler)函数z=(p-1)*(q-1),予以保密;(4)随机的选取d与z互质,作为A的公开密钥;(5)利用Euclid算法计算满足同余方程e*d≡1modz的解d,作为用户A的保密密钥;(6)任何向用户A发送信息M的用户,可以用A的公开模数D和公开密钥e根据C=Me mod n得到密文C;RSA加密算法的安全性是基于大素数分解的困难性。

攻击者可以分解已知的n,得到p和q,然后可得到z;最后用Euclid算法,由e和z得到d。

然而要分解200位的数,需要大约40亿年。

二、用Java语言描述RSA加密算法的原理假设我们需要将信息从机器A传到机器B,首先由机器B随机确定一个private_kcy(我们称之为密钥),可将这个private_key始终保存在机器B中而不发出来。

然后,由这个private_key计算出public_key(我们称之为公钥)。

这个public_key的特性是:几乎不可能通过该public_key计算生成它的priyate_key。

接下来通过网络把这个public_key 传给机器A,机器A收到public_key后,利用public_key将信息加密,并把加密后的信息通过网络发送到机器B,最后机器B利用已知的pri.rate_key,就可以解开加密信息。

国密算法java语言的实现

国密算法java语言的实现

国密算法java语言的实现国密算法是我国自主研发的密码算法标准,被广泛应用于信息安全领域。

在本文中,将介绍国密算法在Java语言中的实现。

一、国密算法简介国密算法是指中国密码技术及标准化研究中心(简称“国密中心”)发布的一系列密码算法,包括SM1、SM2、SM3和SM4。

其中,SM1是对称加密算法,SM2是非对称加密算法,SM3是哈希算法,SM4是对称加密算法。

二、国密算法的Java实现1. SM1算法的Java实现SM1算法是一种对称加密算法,它使用了Feistel结构和S盒代换。

在Java中,可以通过使用Bouncy Castle库来实现SM1算法。

以下是使用Bouncy Castle库实现SM1算法的代码示例:```javaimport org.bouncycastle.crypto.CipherParameters;import org.bouncycastle.crypto.engines.SM1Engine;import org.bouncycastle.crypto.params.KeyParameter;public class SM1Example {public static void main(String[] args) {byte[] key = new byte[]{/* 密钥 */};byte[] plaintext = new byte[]{/* 明文 */};SM1Engine engine = new SM1Engine();CipherParameters params = new KeyParameter(key);engine.init(true, params);byte[] ciphertext = new byte[plaintext.length];engine.processBlock(plaintext, 0, ciphertext, 0);System.out.println("密文:" + new String(ciphertext));}}```2. SM2算法的Java实现SM2算法是一种非对称加密算法,它基于椭圆曲线密码体制。

java aes gcm加密模式原理

java aes gcm加密模式原理

Java AES GCM加密模式原理一、引言在数字信息安全领域,加密技术是一项非常重要的技术,它能够保护数据的隐私性和完整性。

而在加密技术中,AES(Advanced Encryption Standard)是一种广泛使用的对称加密算法,它使用相同的密钥进行加密和解密,保证了数据的保密性。

而GCM(Galois/Counter Mode)是一种在AES加密算法基础上增加消息完整性校验的加密模式,它提供了加密和认证功能,同时保护数据不被篡改。

本文将介绍Java语言中AES GCM加密模式的原理及实现方式。

二、AES加密算法简介1. AES算法概述AES是一种对称加密算法,它使用相同的密钥进行加密和解密。

AES算法支持128位、192位和256位的密钥长度,分别对应AES-128、AES-192和AES-256。

在加密过程中,明文通过密钥和AES算法产生密文,而在解密过程中,密文通过密钥和AES算法产生明文。

2. AES加密算法流程(1)密钥扩展:AES算法会将输入的密钥扩展成多个轮密钥,以便对每一轮进行子密钥的应用。

(2)初始轮密钥加:将初始轮密钥与明文进行异或运算。

(3)多轮次的轮函数应用:将初始轮密钥与明文进行多轮次的轮函数应用,每次应用都包括字节替换、行移位、列混淆和轮密钥加。

(4)最终轮函数应用:在最后一轮进行轮函数应用,但不包括列混淆。

(5)密文输出:得到加密后的密文。

三、GCM加密模式简介1. GCM加密模式概述GCM是一种在AES加密算法基础上增加消息完整性校验的加密模式,它提供了加密和认证功能,同时保护数据不被篡改。

GCM加密模式使用一个128位的初始化向量(IV)和一个128位的认证密钥,其中IV 用于加密过程,认证密钥用于认证标签(Tag)的生成。

GCM加密模式不需要进行填充操作,因此更适合对块大小固定的数据进行加密。

2. GCM加密模式流程(1)初始处理:GCM加密模式将IV、认证密钥和明文块作为输入,并进行初始处理,得到初始计数器值。

java中decrypt和encrypt方法

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实现MD5算法

java实现MD5算法

java实现MD5算法MD5(Message-Digest Algorithm 5)是一种常用的哈希算法,用于对数据进行加密和摘要处理。

Java提供了相关的工具类和方法,可以轻松地实现MD5算法。

下面是一个Java实现MD5算法的示例代码:```javaimport java.math.BigInteger;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class MD5Examplepublic static void main(String[] args)String input = "Hello, World!";String md5Hash = getMD5Hash(input);System.out.println("Input: " + input);System.out.println("MD5 Hash: " + md5Hash);}public static String getMD5Hash(String input)try//创建一个MD5算法实例MessageDigest md = MessageDigest.getInstance("MD5"); //将输入转换为字节数组byte[] inputBytes = input.getBytes(;//计算MD5散列值byte[] hashBytes = md.digest(inputBytes);//将散列值转换为十六进制字符串BigInteger hashInt = new BigInteger(1, hashBytes); String hashString = hashInt.toString(16);//补全前导零,使字符串长度为32while (hashString.length( < 32)hashString = "0" + hashString;}return hashString;} catch (NoSuchAlgorithmException e)e.printStackTrace(;return null;}}```在上面的示例代码中,首先定义了一个`getMD5Hash`方法,用于计算输入字符串的MD5散列值。

java国密的原理

java国密的原理

Java国密的基本原理1. 国密算法简介国密算法是指由中国密码学专家自主研发的密码算法,主要包括SM1对称加密算法、SM2椭圆曲线公钥密码算法、SM3杂凑算法和SM4分组密码算法。

这些算法已经成为中国密码应用的基石,被广泛应用于电子商务、金融支付、公共安全等领域。

2. Java国密的基本原理Java国密是指在Java平台上实现的国密算法。

Java国密的基本原理涉及到以下几个方面:2.1 JDK版本选择Java国密的实现需要选择支持国密算法的JDK版本。

目前,Oracle JDK不直接支持国密算法,因此可以选择使用由中国密码局发布的BC-JDK(Bouncy Castle JDK)或者由阿里巴巴开源的Alibaba JDK。

2.2 密钥管理Java国密的密钥管理基于Java Cryptography Architecture (JCA)。

JCA提供了密钥管理的API,可以生成、存储和管理密钥。

对于国密算法,可以通过JCA生成国密算法所需的密钥对、密钥对的导入导出、密钥的存储等操作。

2.3 加密和解密Java国密的加密和解密是基于JCA提供的Cipher类实现的。

Cipher类提供了加密和解密的功能,可以通过指定国密算法的名称来创建Cipher对象。

对于SM1和SM4算法,可以使用ECB、CBC、CTR等模式进行加密和解密。

2.4 签名和验签Java国密的签名和验签是基于JCA提供的Signature类实现的。

Signature类提供了数字签名和验签的功能,可以通过指定国密算法的名称来创建Signature对象。

对于SM2算法,可以使用ECDSA算法进行签名和验签。

2.5 杂凑算法Java国密的杂凑算法是基于JCA提供的MessageDigest类实现的。

MessageDigest类提供了杂凑算法的功能,可以通过指定国密算法的名称来创建MessageDigest对象。

对于SM3算法,可以使用MessageDigest类进行杂凑计算。

Java常见摘要算法——md5、sha1、sha256

Java常见摘要算法——md5、sha1、sha256

Java常见摘要算法——md5、sha1、sha256⽬录实现sha256的代码和sha1的代码相似摘要算法简介 摘要算法,也是加密算法的⼀种,还有另外⼀种叫法:指纹。

摘要算法就是对指定的数据进⾏⼀系列的计算,然后得出⼀个串内容,该内容就是该数据的摘要。

不同的数据产⽣的摘要是不同的,所以,可以⽤它来进⾏⼀些数据加密的⼯作:通过对⽐两个数据加密后的摘要是否相同,来判断这两个数据是否相同。

还可以⽤来保证数据的完整性,常见的软件在发布之后,会同时发布软件的md5和sha值,这个md5和sha值就是软件的摘要。

当⽤户将软件下载之后,然后去计算软件的摘要,如果计算所得的摘要和软件发布⽅提供的摘要相同,则证明下载的软件和发布的软件⼀模⼀样,否则,就是下载过程中数据(软件)被篡改了。

常见的摘要算法包括:md、sha这两类。

md包括md2、md4、md5;sha包括sha1、sha224、sha256、sha384、sha512。

md5 md摘要算法包括多种算法:分别是md2、md4、md5。

现在⼀般都是使⽤md5进⾏加密。

Java中实现md5加密,有三种⽅式: 使⽤jdk内置的⽅法实现实现md5加密package cn.ganlixin.security;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import mons.codec.binary.Hex;public class JdkMD5 {public static void main(String[] args) throws NoSuchAlgorithmException {String plainText = "this is plain text";// 通过调⽤MessageDigest(数据摘要类)的getInstance()静态⽅法,传⼊加密算法的名称,获取数据摘要对象。

在JAVA中使用DES算法

在JAVA中使用DES算法

在JAVA中使⽤DES算法DES算法提供CBC, OFB, CFB, ECB四种模式,MAC是基于ECB实现的。

⼀、数据补位DES数据加解密就是将数据按照8个字节⼀段进⾏DES加密或解密得到⼀段8个字节的密⽂或者明⽂,最后⼀段不⾜8个字节,按照需求补⾜8个字节(通常补00或者FF,根据实际要求不同)进⾏计算,之后按照顺序将计算所得的数据连在⼀起即可。

这⾥有个问题就是为什么要进⾏数据补位?主要原因是DES算法加解密时要求数据必须为8个字节。

⼆、ECB模式DES ECB(电⼦密本⽅式)其实⾮常简单,就是将数据按照8个字节⼀段进⾏DES加密或解密得到⼀段8个字节的密⽂或者明⽂,最后⼀段不⾜8个字节,按照需求补⾜8个字节进⾏计算,之后按照顺序将计算所得的数据连在⼀起即可,各段数据之间互不影响。

三、CBC模式DES CBC(密⽂分组链接⽅式)有点⿇烦,它的实现机制使加密的各段数据之间有了联系。

其实现的机理如下:加密步骤如下:1)⾸先将数据按照8个字节⼀组进⾏分组得到D1D2......Dn(若数据不是8的整数倍,⽤指定的PADDING数据补位)2)第⼀组数据D1与初始化向量I异或后的结果进⾏DES加密得到第⼀组密⽂C1(初始化向量I为全零)3)第⼆组数据D2与第⼀组的加密结果C1异或以后的结果进⾏DES加密,得到第⼆组密⽂C24)之后的数据以此类推,得到Cn5)按顺序连为即为加密结果。

解密是加密的逆过程,步骤如下:1)⾸先将数据按照8个字节⼀组进⾏分组得到2)将第⼀组数据进⾏解密后与初始化向量I进⾏异或得到第⼀组明⽂D1(注意:⼀定是先解密再异或)3)将第⼆组数据C2进⾏解密后与第⼀组密⽂数据进⾏异或得到第⼆组数据D24)之后依此类推,得到Dn5)按顺序连为D1D2D3......Dn即为解密结果。

这⾥注意⼀点,解密的结果并不⼀定是我们原来的加密数据,可能还含有你补得位,⼀定要把补位去掉才是你的原来的数据。

JAVA实现AES加密算法代码

JAVA实现AES加密算法代码

JAVA实现AES加密算法代码JA V A实现AES加密算法代码近些年DES使用越来越少,原因就在于其使用56位密钥,比较容易被破解,近些年来逐渐被AES替代,AES已经变成目前对称加密中最流行算法之一;AES可以使用128、192、和256位密钥,并且用128位分组加密和解密数据。

本文就简单介绍如何通过JA V A实现AES加密。

1. JA V A 实现闲话少许,掠过AES加密原理及算法,关于这些直接搜索专业网站吧,我们直接看JA V A的具体实现。

1.1 加密代码有详细解释,不多废话。

/*** 加密** @param content 需要加密的内容*@param password 加密密码* @return*/public static byte[] encrypt(String content, String password) {try {KeyGenerator kgen =KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器cipher.init(Cipher.DECRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(content);return result; //加密} catch (NoSuchAlgorithmException e){ e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}/**解密* @param content 待解密内容* @param password 解密密钥* @return*/public static byte[] decrypt(byte[] content, String password) {try {KeyGenerator kgen =KeyGenerator.getInstance("AES");kgen.init(128, new SecureRandom(password.getBytes()));SecretKey secretKey = kgen.generateKey();byte[] enCodeFormat = secretKey.getEncoded();SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");Cipher cipher = Cipher.getInstance("AES");// 创建密码器cipher.init(Cipher.DECRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(content);return result; //加密} catch (NoSuchAlgorithmException e){ e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}2.3 测试代码String content = "test";String password = "12345678";//加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);//解密byte[] decryptResult = decrypt(encryptResult,password); System.out.println("解密后:" + new String(decryptResult)); String content = "test";String password = "12345678"; //加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);//解密byte[] decryptResult =decrypt(encryptResult,password);System.out.println("解密后:" + new String(decryptResult));输出结果如下:加密前:test解密后:test 2.4 容易出错的地方但是如果我们将测试代码修改一下,如下:String content = "test";String password = "12345678";//加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);try {String encryptResultStr = newString(encryptResult,"utf-8");//解密byte[] decryptResult =decrypt(encryptResultStr.getBytes("utf-8"),password); System.out.println("解密后:" + newString(decryptResult));} catch (UnsupportedEncodingException e){ e.printStackTrace();}String content = "test"; String password = "12345678";//加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);try {String encryptResultStr = newString(encryptResult,"utf-8");//解密byte[] decryptResult =decrypt(encryptResultStr.getBytes("utf-8"),password); System.out.println("解密后:" + newString(decryptResult));} catch(UnsupportedEncodingException e){ e.printStackTrace();}则,系统会报出如下异常:javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher atcom.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA 13*..)at javax.crypto.Cipher.doFinal(DashoA13*..)这主要是因为加密后的byte数组是不能强制转换成字符串的,换言之:字符串和byte数组在这种情况下不是互逆的;要避免这种情况,我们需要做一些修订,可以考虑将二进制数据转换成十六进制表示,主要有如下两个方法: 2.4.1将二进制转换成16进制/**将二进制转换成16进制* @param buf* @return*/public static String parseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}returnsb.toString();}/**将二进制转换成16进制*@param buf* @return*/public static StringparseByte2HexStr(byte buf[]) {StringBuffer sb = new StringBuffer();for (int i = 0; i String hex = Integer.toHexString(buf[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}sb.append(hex.toUpperCase());}returnsb.toString();} 2.4.2 将16进制转换为二进制/**将16进制转换为二进制* @param hexStr*@return*/public static byte[]parseHexStr2Byte(String hexStr) {if (hexStr.length() return null;byte[] result = new byte[hexStr.length()/2]; for (int i = 0;i int high =Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);intlow = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16); result[i] = (byte) (high * 16 + low);}return result;}/**将16进制转换为二进制* @param hexStr*@return*/public static byte[]parseHexStr2Byte(String hexStr) {if (hexStr.length() return null;byte[] result = new byte[hexStr.length()/2]; for (int i = 0;i int high =Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);intlow = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);result[i] = (byte) (high * 16 + low);}return result;}然后,我们再修订以上测试代码,如下:String content = "test";String password = "12345678"; //加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后:" + encryptResultStr);//解密byte[] decryptFrom =parseHexStr2Byte(encryptResultStr);byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后:" + new String(decryptResult)); String content = "test";String password = "12345678"; //加密System.out.println("加密前:" + content);byte[] encryptResult = encrypt(content, password);String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后:" + encryptResultStr);//解密byte[] decryptFrom =parseHexStr2Byte(encryptResultStr);byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后:" + new String(decryptResult));测试结果如下:加密前:test加密后:73C58BAFE578C59366D8C995CD0B9D6D解密后:test2.5 另外一种加密方式还有一种加密方式,大家可以参考如下:/*** 加密** @param content 需要加密的内容* @param password 加密密码*@return*/public static byte[] encrypt2(String content, String password) {try {SecretKeySpec key = new SecretKeySpec(password.getBytes(), "AES");Cipher cipher =Cipher.getInstance("AES/ECB/NoPadding");byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) { e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (UnsupportedEncodingException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}/*** 加密** @param content 需要加密的内容* @param password 加密密码* @return*/ public static byte[] encrypt2(String content, String password) {try {SecretKeySpec key = newSecretKeySpec(password.getBytes(), "AES");Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");byte[] byteContent = content.getBytes("utf-8");cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化byte[] result = cipher.doFinal(byteContent);return result; // 加密} catch (NoSuchAlgorithmException e) { e.printStackTrace();} catch (NoSuchPaddingException e) { e.printStackTrace();} catch (InvalidKeyException e){ e.printStackTrace();} catch (UnsupportedEncodingException e){ e.printStackTrace();} catch (IllegalBlockSizeException e) { e.printStackTrace();} catch (BadPaddingException e){ e.printStackTrace();}return null;}这种加密方式有两种限制密钥必须是16位的待加密内容的长度必须是16的倍数,如果不是16的倍数,就会出如下异常:javax.crypto.IllegalBlockSizeException: Input length not multiple of 16 bytes atcom.sun.crypto.provider.SunJCE_f.a(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA 13*..)at javax.crypto.Cipher.doFinal(DashoA13*..)要解决如上异常,可以通过补全传入加密内容等方式进行避免。

java密码加密方法

java密码加密方法

java密码加密方法在现今的网络世界中,安全性是非常重要的一个问题,其中密码的安全性就尤为重要。

许多网站和应用程序都需要用户进行登录,需要输入用户名和密码来验证身份。

但是,用户往往习惯使用简单的密码,如生日、常用英文单词等。

这使得密码的安全性降低了很多,给黑客攻击、身份盗窃等带来了很大的风险。

为了提高密码安全性,需要对密码进行加密。

Java是一种非常流行的编程语言之一,有许多加密方法可以用来加密密码。

本文将介绍Java密码加密的几种方法。

1.MD5加密算法MD5是最常见的一种密码加密算法之一。

它可以将一个明文字符串加密成一个128位的哈希值,通常用32位的十六进制数字表示。

MD5被广泛使用,因为它是一个不可逆的算法,使用同样的密码加密出来的哈希值是唯一的,且不可反向推导出原始字符串。

以下是MD5加密的Java代码示例:```import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;StringBuffer sb = new StringBuffer();for (int i = 0; i < b.length; i++) {int v = b[i] & 0xFF;if (v < 16) {sb.append("0");}sb.append(Integer.toHexString(v));}return sb.toString();}在以上代码中,toMD5方法接受一个明文字符串,返回一个MD5哈希串,可以在一个数据库中保存。

在登陆时,将用户输入的密码进行MD5加密,然后和数据库中的加密串比较,若相等则表示输入的密码是正确的。

需要注意的是,MD5算法虽然被广泛使用,但是安全性并不是十分高,因为它在被攻击时容易被破解。

因此,在一些敏感性较高的场合下,建议使用更加复杂的加密算法,如SHA-1、SHA-256等。

java相关加密解密方法

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签名和验证。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

作业6:有短句“Sun Yat-sen University is a vibrant community of scholarship”,请用下列方法加密:–简单代替密码(移位密码),k=5,q=26;–多表代替密码,其中m=6, K=cipher;–纵行置换密码,假定每行10个字节。

请写出加密后密文。

加密结果:简单代替加密:Xzs Dfy-xjs Zsnajwxnyd nx f angwfsy htrrzsnyd tk xhmtqfwxmnu 多表代替加密:Ucc Crv-hlr Wvxciiuqif zu p zzdzpux ewbtyekbn sw aroscczhomg 纵向置换加密:Sntbucu yrnhnU aio nintlYistyaav rteacos-r ofhssvm ieiimsp本作业是使用java编程求解的,以为是求解算法(java语言描述):/** 简单代替加密*/public class Ssc {private String name;private int k;private int q;public Ssc(){this.k = 5;this.q = 26; = "简单代替加密";}/*** k为位移量,q为字母表长度* @param k* @param q*/public Ssc(int k, int q){this.k = k;this.q = q; = "简单代替加密";}/*** 加密* @param str* @return*/public String encrypt(String str){String code = "";char[] c = str.toCharArray();for (int i = 0; i < c.length; i++) { int hc = (int)c[i];if(hc >= 97 && hc <= 122){int t = hc - 97;int tt = (t + k) % q;hc = 97 + tt;}if(hc >= 65 && hc <= 90){int t = hc - 65;int tt = (t + k) % q;hc = 65 + tt;}char temp = (char)hc;code += temp;}return code;}public int getK() {return k;}public void setK(int k) {this.k = k;}public int getQ() {return q;}public void setQ(int q) {this.q = q;}public String getName() {return name;}public void setName(String name) { = name;}}/** 多表代替加密*/public class Psc {private String name;private int m;private String K;public Psc(){this.m = 6;this.K = "run"; = "多表代替加密";}/*** m为密钥长度,K为密钥* @param m* @param K*/public Psc(int m, String K){this.m = m;this.K = K; = "多表代替加密";}/*** 加密* @param str* @return*/public String encrypt(String str){String code = "";char[] c = str.toCharArray();char[] k = K.toCharArray();for (int i = 0; i < c.length; i++) { int hc = (int)c[i];int ki = i;if(i >= k.length){ki = i % k.length;}int kt = k[ki] - 97;if(hc >= 97 && hc <= 122){int t = hc - 97;int tt = (t + kt) % 26;hc = 97 + tt;}if(hc >= 65 && hc <= 90){int t = hc - 65;int tt = (t + kt) % 26;hc = 65 + tt;}char temp = (char) hc;code += temp;}return code;}public int getM() {return m;}public void setM(int m) {this.m = m;}public String getK() {return K;}public void setK(String k) {K = k;}public String getName() {return name;}public void setName(String name) { = name;}}/** 纵向置换加密*/public class Wrc {private String name;private int skip;public Wrc(){this.skip = 10; = "纵向置换加密";}/*** skip为间隔* @param skip*/public Wrc(int skip){this.skip = skip; = "纵向置换加密";}/*** 加密* @param str* @return*/public String encrypt(String str){String code = "";int len = str.length();int group_len = ((len%skip)==0)? len/skip : len/skip + 1;char groups[][] = new char[100][100];char[] c = str.toCharArray();int cc = c.length / skip;int cr = c.length % skip;if(cr != 0){for (int i = 0; i < skip - cr; i++) {c[c.length + i] = 0;}}for (int i = 0; i < group_len; i++) {for (int j = 0; j < skip; j++) {groups[i][j] = c[i*skip + j];// System.out.print(groups[i][j]);}}for (int j = 0; j < skip; j++){for (int i = 0; i < group_len; i++) {code += groups[i][j];}}return code;}public int getSkip() {return skip;}public void setSkip(int skip) {this.skip = skip;}public String getName() {return name;}public void setName(String name) { = name;}}/** main方法*/public class Main {public static void main(String[] args) {String str ="Sun Yat-sen University is a vibrant community of scholarship";Ssc ssc = new Ssc(5, 26);System.out.println(ssc.getName() + ":" + ssc.encrypt(str));Psc psc = new Psc(6, "cipher");System.out.println(psc.getName() + ":" + psc.encrypt(str) );Wrc wrc = new Wrc(10);System.out.println(wrc.getName() + ":" + wrc.encrypt(str));}}。

相关文档
最新文档