Java安全之安全加密算法

0x00 前言

本篇文来谈谈关于常见的一些加密算法,其实在此之前,对算法的了解并不是太多。了解的层次只是基于加密算法的一些应用上。也来浅谈一下加密算法在安全领域中的作用。写本篇文也是基于算法的应用和实现,也是我的基本原则,能用就行。

0x01 算法体制

在加密算法里面大致分为四大类:对称加密算法、非对称加密算法、散列函数、组合加密。

对称加密:指的是加密的密钥和解密的密钥相同。

非对称加密:指的是加密的密钥和加密的密钥不同。分为公钥和私钥。

散列函数:主要用于验证数据的完整性,长度不受限制,hash值容易计算,散列运算过程不可逆如:MD5、SHA

0x02 散列算法

Hash,一般翻译做散列、杂凑,或音译为哈希,是把任意长度的输入(又叫做预映射pre-image)通过散列算法变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

MD5

md5的运用范围也比较广,比如在一些数据库存储密码的时候会去使用到该算法去进行加密存储。当然也可以看到网上的一些md5破解的。但是他们都是基于彩虹表去跑,使用字典进行md5加密,然后把加密的值进行对比,从而判断该md5值的明文。

代码实例:

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; public class MD5demo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException {
MessageDigest md5 = MessageDigest.getInstance("MD5");//设置要返回的摘要算法对象
byte[] digest = md5.digest(name.getBytes()); //计算hash值
System.out.println(HexBin.encode(digest));//输出hash结果
}
}

SHA

安全散列算法(英语:Secure Hash Algorithm,缩写为SHA)是一个密码散列函数家族,是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的,长度固定的字符串(又称消息摘要)的算法。且若输入的消息不同,它们对应到不同字符串的机率很高。

SHA家族的五个算法,分别是SHA-1、SHA-224、SHA-256、SHA-384,和SHA-512

下面是一张对照图。

代码实例:

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; public class jdksha1 {
private static String name = "xiaoming"; public static void main(String[] args) throws NoSuchAlgorithmException {
MessageDigest sha = MessageDigest.getInstance("SHA");
byte[] digest = sha.digest(name.getBytes());
System.out.println(HexBin.encode(digest)); }
}

0x03 对称加密算法

对称加密算法,他的加解密密钥都是一样的。而对称加密的算法又分两大类,一种是每次对明文中的字节使用密钥进行加密,而第二种是对一组明文使用密钥进行加密。

先来看看分组加密的工作模式。

分组加密的工作模式

1. ECB:电子密码本(最常用的,每次加密均产生独立的密文分组,并且对其他的密文分组不会产生影响,也就是相同的明文加密后产生相同的密文)
2. CBC:密文链接(常用的,明文加密前需要先和前面的密文进行异或运算,也就是相同的明文加密后产生不同的密文)
除了这两种常用的工作模式,还有:
3. CFB:密文反馈
4. OFB:输出反馈
5. CTR:计数器

分组密码填充方式

1. NoPadding:无填充
2. PKCS5Padding:
3. ISO10126Padding

常用的加密方式DES、3DES、AES。可以来对比一下,这几个算法的区别。

BASE64

因为BASE64的加密解密算法是公开的,所以加密数据是没有任何安全性可言。先来看看API文档中提供的BASE64加密的类。除了在JDK中内置的也有一些第三方类会提供BASE64加密的类。

代码实例:

package com.demo;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder; import java.io.IOException; public class base64demo {
public static void main(String[] args) throws IOException {
String name = "xiaoming";
BASE64Encoder encoder = new BASE64Encoder//实例化BASE64Encoder对象
String encode = encoder.encode(name.getBytes());//调用encode进行加密
System.out.println(encode);
BASE64Decoder base64Decoder = new BASE64Decoder();//实例化BASE64Decoder对象
byte[] bytes = base64Decoder.decodeBuffer(encode);//进行解密
System.out.println(bytes);
String s = new String(bytes);
System.out.println(s); }
}

BASE64的加解密比较简单,在这里就不细说了。

DES

DES的算法其实已经被公开了,其实是不太安全的。

代码实例:

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException; public class desdemo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, InvalidKeySpecException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException { //1.生成密钥
KeyGenerator des = KeyGenerator.getInstance("DES");//设置获取des的密钥
des.init(56);//初始化密钥生成器,设置为56长度的密钥
SecretKey secretKey = des.generateKey();//获取密钥
// System.out.println(secretKey);
byte[] deskey = secretKey.getEncoded(); //获取密钥的byte数组 //2.密钥转换
DESKeySpec desKeySpec = new DESKeySpec(deskey);
SecretKeyFactory des1 = SecretKeyFactory.getInstance("DES");
SecretKey secretKey1 = des1.generateSecret(desKeySpec);
// System.out.println(secretKey1); //3.加密
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");//选择算法、工作模式和填充方式
cipher.init(Cipher.ENCRYPT_MODE,secretKey1);//选择加密模式和密钥进行加密
byte[] res = cipher.doFinal(name.getBytes());//加密数据
// System.out.println(res);
// String s = new String(res);
System.out.println(HexBin.encode(res));//输出加密后结果 //4.解密
cipher.init(Cipher.DECRYPT_MODE,secretKey1);//选择密钥,并使用解密模式
byte[] bytes = cipher.doFinal(res);//解密加密后的结果
String s1 = new String(bytes);
System.out.println(s1); }
}

3DES

3DES也被叫做DESede,也就是基于DES三次加密。其实也有四层和两层DES,但是平时中用的最多的还是3DES。

上面的图是他的一个算法的说明图。

其实3DES和DES在代码中的实现方式很相似。但是要注意的一点是密钥长度要选择正确,否则会报错。或者是可以使用SecureRandom()类,让他根据选择的加密算法使用默认的密钥长度。

代码实例:

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException; public class jdk3des {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, InvalidKeySpecException, BadPaddingException, IllegalBlockSizeException {
//1.生成密钥
KeyGenerator des = KeyGenerator.getInstance("DESede");//设置获取des的密钥
// des.init(168);//初始化密钥生成器,设置为168长度的密钥
des.init(new SecureRandom());//根据加密算法使用默认密钥长度
SecretKey secretKey = des.generateKey();//获取密钥
// System.out.println(secretKey);
byte[] deskey = secretKey.getEncoded(); //获取密钥的byte数组 //2.密钥转换
DESedeKeySpec desKeySpec = new DESedeKeySpec(deskey);
SecretKeyFactory des1 = SecretKeyFactory.getInstance("DESede");
SecretKey secretKey1 = des1.generateSecret(desKeySpec);
// System.out.println(secretKey1); //3.加密
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");//选择算法、工作模式和填充方式
cipher.init(Cipher.ENCRYPT_MODE,secretKey1);//选择加密模式和密钥进行加密
byte[] res = cipher.doFinal(name.getBytes());//加密数据
// System.out.println(res);
// String s = new String(res);
System.out.println(HexBin.encode(res));//输出加密后结果 //4.解密
cipher.init(Cipher.DECRYPT_MODE,secretKey1);//选择密钥,并使用解密模式
byte[] bytes = cipher.doFinal(res);//解密加密后的结果
String s1 = new String(bytes);
System.out.println(s1); }
}

AES

AES是目前用的最多的对称加密算法,一般用于移动通讯系统加密或者是基于SSH协议的软件

代码实例:

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;
import com.sun.xml.internal.messaging.saaj.util.Base64;
import sun.misc.BASE64Encoder; import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom; public class aesdemo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
//1.获取密钥
KeyGenerator aes = KeyGenerator.getInstance("AES");
aes.init(128);
SecretKey secretKey = aes.generateKey();
byte[] encoded = secretKey.getEncoded(); //2.密钥转换
Key key = new SecretKeySpec(encoded, "AES"); //3.加密
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] bytes = cipher.doFinal(name.getBytes());
System.out.println(new BASE64Encoder().encode(bytes));//加密完成后,再使用base64进行加密 //4.解密
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1)); }
}

下面来放一张基于AES加解密的流程图。

PBE

PBE算法(Password Based Encryption,基于口令加密)是一种基于口令的加密算法,其特点是使用口令代替了密钥,而口令由用户自己掌管,采用随机数杂凑多重加密等方法保证数据的安全性。PBE算法在加密过程中并不是直接使用口令来加密,而是加密的密钥由口令生成,这个功能由PBE算法中的KDF函数完成。KDF函数的实现过程为:将用户输入的口令首先通过“盐”(salt)的扰乱产生准密钥,再将准密钥经过散列函数多次迭代后生成最终加密密钥,密钥生成后,PBE算法再选用对称加密算法对数据进行加密,可以选择DES、3DES、RC5等对称加密算法

以上这张图是PBE算法的实现方式

代码实例:

package com.demo;

import com.sun.xml.internal.messaging.saaj.util.Base64;
import sun.misc.BASE64Encoder; import javax.crypto.*;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import java.security.*;
import java.security.spec.InvalidKeySpecException; public class pbedemo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, BadPaddingException, IllegalBlockSizeException { //1.初始化盐
SecureRandom secureRandom = new SecureRandom();
byte[] salt = secureRandom.generateSeed(8); //2. 获取密钥 String password = "123456";
PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
Key key = factory.generateSecret(pbeKeySpec);
//3.加密
PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 100);
Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
byte[] bytes = cipher.doFinal(name.getBytes());
System.out.println(new BASE64Encoder().encode(bytes));
//4.解密 cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);
byte[] res = cipher.doFinal(bytes);
System.out.println(new String(res)); }
}

0x04 非对称加密算法

非对称加密算法需要两个密钥:公钥和私钥。公钥]与私钥是一对,如果用公钥对数据进行加密,只有用对应的私钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

DH

1976年非对称加密算法思想被提出,但是当时并没有给出具体算法和方案,因为当时没有研究出单向函数(也就是信息摘要算法还没出现),但是IEEE的期刊中给出了通信时双方如何通过信息交换协商密钥的算法,也就是DH算法,通过该算法双方可以协商对称加密的密钥。

package com.demo;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import javax.crypto.*;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec; public class dhdemo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidAlgorithmParameterException, InvalidKeyException, NoSuchPaddingException, BadPaddingException, IllegalBlockSizeException {
// 1.初始化发送方密钥
KeyPairGenerator sendKeyPairGenerator = KeyPairGenerator.getInstance("DH");
sendKeyPairGenerator.initialize(512);
KeyPair sendKeyPair = sendKeyPairGenerator.generateKeyPair();
byte[] sendPublicKeyEnc = sendKeyPair.getPublic().getEncoded();//生成发送方公钥,发送给接收方(网络、文件...) // 2.初始化接收方密钥:
KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(sendPublicKeyEnc);
PublicKey receivePublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
DHParameterSpec dhParameterSpec = ((DHPublicKey)receivePublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();
byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded(); // 3.构建接收方密钥:
KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receivePublicKey, true); SecretKey receiverDESKey = receiverKeyAgreement.generateSecret("DES");//接收方Key
// 4.构建发送方密钥:
KeyFactory sendKeyFactory = KeyFactory.getInstance("DH");
x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
PublicKey sendPublicKey = sendKeyFactory.generatePublic(x509EncodedKeySpec); KeyAgreement sendKeyAgreement = KeyAgreement.getInstance("DH");
sendKeyAgreement.init(sendKeyPair.getPrivate());
sendKeyAgreement.doPhase(sendPublicKey, true); SecretKey sendDESKey = sendKeyAgreement.generateSecret("DES");//发送方Key
// 5.发送方加密:
Cipher sendCipher = Cipher.getInstance("DES");
sendCipher.init(Cipher.ENCRYPT_MODE, sendDESKey);
byte[] sendResult = sendCipher.doFinal(name.getBytes());
System.out.println("sendResult :"+ HexBin.encode(sendResult)); // 6.接收方解密:
Cipher receiverCipher = Cipher.getInstance("DES");
receiverCipher.init(Cipher.DECRYPT_MODE, receiverDESKey);
byte[] receiverResult = receiverCipher.doFinal(sendResult);
System.out.println("receiverResult : "+new String (receiverResult)); }
}

RSA

RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥,“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。RSA算法实现了公钥加密、私钥解密 和私钥解密、公钥加密的一个机制。

也就是说使用公钥来进行加密,想要解密获取明文内容,就必须使用对应的私钥来进行解密。而在其中私钥中的内容其实是比较长的,而公钥里面的内容会偏短一些。因为私钥一般会储存在本地,而公钥会放到各大互联网上,公钥比私钥内容短也是为了方便传输和存储。

代码示例:

package com.demo;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import sun.misc.BASE64Encoder; import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; public class rsademo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
// 1.初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");//设置获取RSA的密钥
keyPairGenerator.initialize(512);//设置密钥长度
KeyPair keyPair = keyPairGenerator.generateKeyPair();//生成密钥对
RSAPublicKey rsaPublic =(RSAPublicKey) keyPair.getPublic();//获取公钥
RSAPrivateKey rsaPrivate = (RSAPrivateKey)keyPair.getPrivate();//获取私钥
// System.out.println(new BASE64Encoder().encode(rsaPublic.getEncoded()));//输出公钥
System.out.println("");
// System.out.println(new BASE64Encoder().encode(rsaPrivate.getEncoded()));//输出私钥
// 2.私钥加密、公钥解密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivate.getEncoded());//对密钥进行编码处理
KeyFactory rsa = KeyFactory.getInstance("RSA");//设置获取RSA的密钥
PrivateKey privateKey = rsa.generatePrivate(pkcs8EncodedKeySpec);//从提供的密钥规范生成私钥对象。
// 2.1私钥加密
Cipher encodecipher = Cipher.getInstance("RSA");//设置获取RSA的密钥
encodecipher.init(Cipher.ENCRYPT_MODE,privateKey);//设置为加密类型并传入私钥进行加密
byte[] res = encodecipher.doFinal(name.getBytes());//对内容进行加密 System.out.println(new BASE64Encoder().encode(res)); // 2.2公钥解密 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublic.getEncoded());//对公钥进行编码处理
rsa = KeyFactory.getInstance("RSA");//设置获取RSA的密钥
PublicKey publicKey = rsa.generatePublic(x509EncodedKeySpec);//从提供的密钥规范生成公钥对象。
Cipher decodecipher = Cipher.getInstance("RSA");//设置获取RSA的密钥
decodecipher.init(Cipher.DECRYPT_MODE,publicKey);//设置解密类型并传入公钥进行解密
byte[] decoderes = decodecipher.doFinal(res);//对内容进行解密
System.out.println(new String(decoderes)); }
}

下面再来看个公钥加密私钥解密的代码

package com.demo;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import sun.misc.BASE64Encoder; import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; public class rsademo {
private static String name = "xiaoming";
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
// 1.初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");//设置获取RSA的密钥
keyPairGenerator.initialize(512);//设置密钥长度
KeyPair keyPair = keyPairGenerator.generateKeyPair();//生成密钥对
RSAPublicKey rsaPublic =(RSAPublicKey) keyPair.getPublic();//获取公钥
RSAPrivateKey rsaPrivate = (RSAPrivateKey)keyPair.getPrivate();//获取私钥
// System.out.println(new BASE64Encoder().encode(rsaPublic.getEncoded()));//输出公钥
System.out.println(""); // 3.公钥加密、私钥解密
// 3.1公钥加密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublic.getEncoded());
KeyFactory encodersa = KeyFactory.getInstance("RSA");
PublicKey publicKey = encodersa.generatePublic(x509EncodedKeySpec);
Cipher encodecipher = Cipher.getInstance("RSA");
encodecipher.init(Cipher.ENCRYPT_MODE,publicKey);
byte[] encoderes = encodecipher.doFinal(name.getBytes());
System.out.println(new BASE64Encoder().encode(encoderes));
// 3.2私钥解密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivate.getEncoded());
KeyFactory decodersa = KeyFactory.getInstance("RSA");
PrivateKey privateKey = decodersa.generatePrivate(pkcs8EncodedKeySpec);
Cipher decodecipher = Cipher.getInstance("RSA");
decodecipher.init(Cipher.DECRYPT_MODE,privateKey);
byte[] decoderes = decodecipher.doFinal(encoderes);
System.out.println(new String(decoderes)); }
}

在代码中其实可以看到用到了x509EncodedKeySpecpkcs8EncodedKeySpec的类,其实这两个类一个用于对私钥进行编码的,一个是对私钥进行编码。

0x05 结尾

在安全中其实加密算法显得格外的重要,举个例子,比如说冰蝎,为什么就能过一些设备呢?其实分析过冰蝎的,或者是看过冰蝎作者大大的文章的应该会知道,冰蝎在流量传输中也是做了加密的。使用的是AES加密。首先是将客户端发送的命令转换成字节码,然后使用aes进行加密,然后在客户端也就是webshell获取密钥进行解密得到字节码,最后就是使用defineClass来动态加载字节码进行执行。

但是在后面各大厂商的设备随着各大厂商设备的不断升级,冰蝎2还是被杀了。这是因为在冰蝎aes传输密钥的时候被识别出来了。那么我们如果再对该密钥进行更狠一点加密呢?虽然说也能实现,步骤繁琐一些。但是这还是会产生一些流量。在冰蝎3中的做法是去除了握手的过程,直接写死在Webshell中的字符串作为AES密钥解密流量包。

后面打算基于冰蝎进行一个重写,并使用不同的算法来实现加密。

Java安全之安全加密算法的更多相关文章

  1. Java 加密解密 对称加密算法 非对称加密算法 MD5 BASE64 AES RSA

    版权声明:本文为博主原创文章,未经博主允许不得转载. [前言] 本文简单的介绍了加密技术相关概念,最后总结了java中现有的加密技术以及使用方法和例子 [最简单的加密] 1.简单的概念 明文:加密前的 ...

  2. Java 加密 AES 对称加密算法

    版权声明:本文为博主原创文章,未经博主允许不得转载. [AES] 一种对称加密算法,DES的取代者. 加密相关文章见:Java 加密解密 对称加密算法 非对称加密算法 MD5 BASE64 AES R ...

  3. 常用加密算法的Java实现(一) ——单向加密算法MD5和SHA

    1.Java的安全体系架构 1.1           Java的安全体系架构介绍 Java中为安全框架提供类和接口.JDK 安全 API 是 Java 编程语言的核心 API,位于 java.sec ...

  4. Java中的各种加密算法

    Java中为我们提供了丰富的加密技术,可以基本的分为单向加密和非对称加密 1.单向加密算法 单向加密算法主要用来验证数据传输的过程中,是否被篡改过. BASE64 严格地说,属于编码格式,而非加密算法 ...

  5. JAVA加解密 -- 对称加密算法与非对称加密算法

    对称加密算法:双方必须约定好算法 DES 数据加密标准:由于不断地被破解 自98年起就已经逐渐放弃使用 AES 目前使用最多的加密方式,官方并未公布加密方式已被破解,替代DES 实现和DES非常接近 ...

  6. Java常用几种加密算法

    对称加密算法是应用较早的加密算法,技术成熟.在对称加密算法中,数据发信方将明文(原始数据)和加密密钥(mi yue)一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去.收信方收到密文后,若想解 ...

  7. java几种常见加密算法小试

    http://www.cnblogs.com/JCSU/articles/2803598.html http://www.open-open.com/lib/view/open139727425732 ...

  8. Objective-C 与JAVA的SHA1/HmacSHA1加密算法实现

    最近研究IOS手机上登录的功能.由于加密方式使用SHA1算法.网上也没找到直接的例子,最终参照StackoverFlow上的大神,完成了加密实现. 先上代码: //HmacSHA1加密: +(NSSt ...

  9. Java中常用的加密算法MD5,SHA,RSA

    1. MD5加密,常用于加密用户名密码,当用户验证时. protected byte[] encrypt(byte[] obj){  try {  MessageDigest md5 = Messag ...

随机推荐

  1. mysql load_file()

    本地mysql注入读取配置文件 遇到的问题 简单记录一下. 本地测试时,读取文件发现无论怎样都返回为NULL. >> select load_file('c:/xx/xx/xx/x.txt ...

  2. SSRF漏洞(原理、漏洞利用、修复建议)

    介绍SSRF漏洞 SSRF (Server-Side Request Forgery,服务器端请求伪造)是一种由攻击者构造请求,由服务端发起请求的安全漏洞.一般情况下,SSRF攻击的目标是外网无法访问 ...

  3. Spark 模型选择和调参

    Spark - ML Tuning 官方文档:https://spark.apache.org/docs/2.2.0/ml-tuning.html 这一章节主要讲述如何通过使用MLlib的工具来调试模 ...

  4. Spring一些笔记

    @ControllerAdvice ,被注解的class表示这是一个增强的 Controller. 使用这个 Controller ,可以实现三个方面的功能: 全局异常处理 全局数据绑定 全局数据预处 ...

  5. JAVA并发笔记

    重入锁的特性, 避免死锁, 如果有锁的话, 不用重新加锁, 直接增加锁的次数.. Synchronize, ReentrantLock都是重入锁. 读写锁, ReentrantReadWriteLoc ...

  6. Python-全局解释器锁GIL原理和多线程产生原因与原理-多线程通信机制

    GIL 全局解释器锁,这个锁是个粗粒度的锁,解释器层面上的锁,为了保证线程安全,同一时刻只允许一个线程执行,但这个锁并不能保存线程安全,因为GIL会释放掉的并且切换到另外一个线程上,不会完全占用,依据 ...

  7. 「Redis」字符串

    原文链接:https://www.changxuan.top/?p=1109 简介 Redis 中自定义的字符串结构. 字符串是 Redis 中最常用的一种数据类型,在 Redis 中专门封装了一个字 ...

  8. Varnish 不重启使之配置生效的方法

    Varnish 在内存模式下比较高效,不过它有一个缺点就是 缓存是放在内存里的,一旦重启, 缓存文件也就没了. 往往由于需要调整 vcl 配置文件,但是又不想重启varnish服务,就让配置文件生效的 ...

  9. c#之task与thread区别及其使用

    如果需要查看更多文章,请微信搜索公众号 csharp编程大全,需要进C#交流群群请加微信z438679770,备注进群, 我邀请你进群! ! ! --------------------------- ...

  10. .NET Core使用FluentEmail发送邮件

    前言 在实际的项目开发中,我们会遇到许多需要通过程序发送邮件的场景,比如异常报警.消息.进度通知等等.一般情况下我们使用原生的SmtpClient类库居多,它能满足我们绝大多数场景.但是使用起来不够简 ...