文章目录
- 一.Java安全体系结构
- 二.JCA和JCE
- 三.CSP(加密服务提供程序)与Engine类
- 四.查看当前JDK支持的算法服务提供商(Provider)
- 五.BouncyCastle是什么
- 六.如何使用BouncyCastle?
- 七.bouncycastle实现ED25519工具类
一.Java安全体系结构
总共分为4个部分:
- JCA( Java Cryptography Architecture, Java加密体系结构):提供了基本的加密框架,包括证书、数字签名、消息摘要和密钥对产生器等。它允许开发者通过Java API来访问和操作加密相关的功能。
- JCE( Java Cryptography Extension, Java加密扩展包) :JCE在JCA的基础上作了扩展, 提供了各种加密算法、 消息摘要算法(散列算法、哈希算法)和密钥管理等功能。JCE的实现主要在
javax.crypto包( 及其子包)
中 - JSSE( Java Secure Sockets Extension, Java安全套接字扩展包):JSSE提供了基于SSL( Secure Sockets Layer,安全套接字层) 的加密功能。。这有助于确保在网络传输过程中的信息安全,防止数据被窃取或篡改。
- JAAS( Java Authentication and Authentication Service, Java认证和授权服务):用于Java应用程序的
认证和授权
。它允许程序根据用户的身份和权限来限制对某些资源的访问,从而增强了应用程序的安全性。
二.JCA和JCE
JCA: Java密码体系结构 Java Cryptography Architecture
-
JCE(Java Cryptography Extension),在早期JDK版本中,由于受美国的密码出口条例约束,Java中涉及加解密功能的API被限制出口,所以Java中安全组件被分成了
2部分
: 不含加密功能的JCA
(Java Cryptography Architecture )和含加密功能的JCE
(Java Cryptography Extension)。- 现在JCE已经捆绑在JDK中,所以,这里
JCE是JCA的一部分
- 现在JCE已经捆绑在JDK中,所以,这里
-
JCA包含一个提供者
【Provider】体系结构
和一组用于数字签名
,消息摘要(哈希)
,证书和证书验证
,加
密(对称/非对称块/流密码),密钥生成管理
和安全随机数
生成等等的API。
JCA包含两个组件:
-
定义和支持Provider为其提供实现的加密服务的框架 。 这个框架包含了诸如java.security,javax.crypto,javax.crypto.spec和javax.crypto.interfaces等软件包。
-
JCA相关代码位于JDK的
rt.jar
中的java.security包及其子包中。 -
JCE相关代码位于JDK的
jce.jar
中的javax.crypto包及其子包中。java.security.Provider
类是所有加密与安全算法的父类。
-
-
Sun,SunRsaSign,SunJCE等实际提供者的具体的加密实现。
-
通过JCA统一的、可扩展的一套
用于实现加密服务的基础功能基础API
,,打包成一个Provider服务( 安全提供者),也就是一个实现JCA标准的jar包
, 可以动态地加载到Java运行环境中。- 而开发者在使用只需根据JCA框架提供的
统一接口来调用各种第三方服务商加密算法
、密钥管理等功能,而无需关心底层的实现细节
- 而开发者在使用只需根据JCA框架提供的
三.CSP(加密服务提供程序)与Engine类
1.CSP
在Java中,并没有直接称为"Cryptographic Service Provider (CSP)
"的官方组件或术语。 然而,Java有一个类似的机制,即Java Cryptography Extension (JCE)中的Provider机制,它允许第三方实现并集成加密服务
。
- java.security.Provider是所有安全算法提供实现的父类。 每个CSP都包含这个类的一个实例,它包含了
提供者的名字,并列出了它实现的所有安全服务/算法
。 - 每个Provider可以包含多种类型的Engine类,这些Engine类
是实现特定加密算法或功能的基类
。这些基类定义了算法的通用接口
,而具体的实现则由不同的Provider提供
。
2.Engine类
Engine类为特定类型的密码服务提供的统一接口,不依赖于特定的密码算法或提供者。
- 加密,数字签名,消息摘要等
- 密钥和算法参数
- 密钥库或证书
消息摘要引擎(Message Digest Engine):
- 作用:用于数据完整性校验。它将输入的任意长度消息进行哈希运算,生成一个固定长度的摘要值。
- 常见算法:包括MD5、SHA-1等。
- 使用场景:在保证消息完整的前提下,即使消息长度非常大,也可以通过摘要值的校验实现快速和安全的数据校验。
java.security.MessageDigest
数字签名引擎(Digital Signature Engine):
- 作用:用于验证数据真实性和完整性。
- 使用场景:常用于电子商务、在线金融等领域,用于保证交易的安全性。
java.security.Signature
对称加密引擎:
- 使用相同的密钥进行加密和解密数据。
javax.crypto.Cipher
类来进行对称加密。- 常见算法:包括DES、AES和Blowfish等。
非对称加密引擎:
- 使用一对密钥(公钥和私钥)进行加密和解密。发送方使用接收方的公钥加密数据,接收方使用自己的私钥解密数据。
- 使用
javax.crypto.Cipher
类进行非对称加密操作。
消息认证码(Message Authentication Code,MAC)引擎
- Mac是一个带密钥的hash算法,首先使用密钥初始化后生成散列值,以保护消息的完整性。
java.crypto.Mac
密钥生成器:
- KeyGenerator:用于生成指定算法的对称密钥。
- KeyPairGenerator:用于生成一对适用于指定算法的非对称加密算法的密钥对。
KeyFactory
- 用于从某种类型的密钥规范(key specification)中导出密钥的引擎。
SecretKeyFactory
- 用于从原始密钥序列化数据中导出密钥的引擎。
SecureRandom
- 用于生成随机或伪随机数字。
如何使用引擎类
1.使用KeyPairGenerator引擎类
生成公钥和私钥的密钥对
- 要使用KeyPairGenerator生成密钥对,你需要首先获取
对应算法的实例
,然后通过调用genKeyPair()
方法来生成密钥对。
java
public class KeyPairGeneratorExample {
public static void main(String[] args) {
try {
// 创建一个KeyPairGenerator实例,指定密钥对的算法为RSA
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
// 初始化KeyPairGenerator,指定密钥长度
keyPairGenerator.initialize(2048); // 2048位密钥长度
// 生成密钥对
KeyPair keyPair = keyPairGenerator.genKeyPair();
// 获取公钥和私钥
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
// 打印公钥和私钥信息(在实际应用中,不应该直接打印或输出私钥)
System.out.println("Public Key: " + publicKey);
System.out.println("Private Key: " + privateKey);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
}
2.使用Mac引擎类
,生成消息摘要算法
- 使用Mac算法,先获取一个Mac实例,指定所使用的算法(如HmacSHA256),然后提供密钥和要计算MAC的消息。
java
public class MacExample {
public static void main(String[] args) {
try {
// 创建一个Mac实例,指定算法为HmacSHA256
Mac mac = Mac.getInstance("HmacSHA256");
// 初始化Mac实例,使用指定的密钥
byte[] keyBytes = "mySecretKey".getBytes(StandardCharsets.UTF_8);
SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "HmacSHA256");
mac.init(secretKeySpec);
// 提供要计算MAC的消息
byte[] message = "Hello, World!".getBytes(StandardCharsets.UTF_8);
// 计算MAC值
byte[] macBytes = mac.doFinal(message);
// 打印MAC值(通常以十六进制形式表示)
System.out.println("MAC: " + bytesToHex(macBytes));
} catch (NoSuchAlgorithmException | InvalidKeyException e) {
e.printStackTrace();
}
}
// 辅助方法,将字节数组转换为十六进制字符串
private static String bytesToHex(byte[] hash) {
StringBuilder hexString = new StringBuilder(2 * hash.length);
for (int i = 0; i < hash.length; i++) {
String hex = Integer.toHexString(0xff & hash[i]);
if (hex.length() == 1) hexString.append('0');
hexString.append(hex);
}
return hexString.toString();
}
}
四.查看当前JDK支持的算法服务提供商(Provider)
- 当前版本jdk1.8
java
public class JavaProividerTest {
public static void main(String[] args) throws NoSuchPaddingException, NoSuchAlgorithmException {
System.out.println(printAllSecurityProvidersInMdTable());
}
// 输出MarkDown格式的表格,具体内容见下表
public static String printAllSecurityProvidersInMdTable() {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("Provider Name(供应商名称)|Provider Version(供应商版本)|Algorithm Type(算法类型)|Algorithm Name(算法名称)\r\n");
stringBuilder.append("|:-|:-|:-|:-\r\n");
Map<String, Map<String, String>> providers2Algorithms = Arrays.stream(Security.getProviders())
.collect(Collectors.toMap(provider -> provider.getName() + "@" + provider.getVersion(), provider -> provider.getServices().stream().collect(Collectors.toMap(service -> service.getType(), service -> service.getAlgorithm(), (algorithm1, algorithm2) -> algorithm1 + "@" + algorithm2))));
providers2Algorithms.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey)).forEachOrdered(entryProvider -> {
String[] provider = entryProvider.getKey().split("@");
Map<String, String> algoType2AlgoName = entryProvider.getValue();
int[] rowNumber = {0};
algoType2AlgoName.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey)).forEachOrdered(entryAlgorithm -> {
StringBuilder algorithmCellStr = new StringBuilder();
int[] numberOfAlgorithm = {1};
Arrays.stream(entryAlgorithm.getValue().split("@")).sorted(String::compareTo).forEachOrdered(algorithm -> {
algorithmCellStr.append(algorithm);
if (0 == numberOfAlgorithm[0] % 1) {
algorithmCellStr.append("<br>");
}
numberOfAlgorithm[0]++;
});
stringBuilder.append(String.format("|%s|%s|%s|%s\r\n", 0 == rowNumber[0] ? provider[0] : "", 0 == rowNumber[0] ? provider[1] : "", entryAlgorithm.getKey(), algorithmCellStr.toString()));
rowNumber[0]++;
});
});
return stringBuilder.toString();
}
// 输出纯文本格式
public static void printAllSecurityProviders() {
for (Provider provider : Security.getProviders()) {
System.out.println("Provider: " + provider.getName() + " (ver " + provider.getVersion() + ")");
System.out.print(" Algorithms: ");
ArrayList<String> algos = new ArrayList<String>();
for (Provider.Service service : provider.getServices()) {
algos.add(String.format("%s (%s)", service.getAlgorithm(), service.getType()));
}
java.util.Collections.sort(algos);
String algorsStr = algos.toString();
algorsStr = algorsStr.substring(1, algorsStr.length() - 1);
System.out.println(algorsStr);
System.out.println();
}
}
}
当前JDK版本为1.8,每个JDK安装都默认安装并配置了一个或多个provider包。
java
public static void main(String[] args) {
System.out.println("-------列出加密服务提供者-----");
Provider[] pro = Security.getProviders();
for (Provider p : pro) {
System.out.println("Provider:" + p.getName() + " - version:" + p.getVersion());
System.out.println(p.getInfo());
}
System.out.println("");
System.out.println("-------列出系统支持的消息摘要算法(散列算法、哈希算法):");
for (String s : Security.getAlgorithms("MessageDigest")) {
System.out.println(s);
}
System.out.println("-------列出系统支持的生成公钥和私钥对的算法:");
for (String s : Security.getAlgorithms("KeyPairGenerator")) {
System.out.println(s);
}
}
- 可以看到默认情况下java1.8已经支持市面上绝大多数常见算法
有一些算法JDK中的Provider并没有提供,用户可以静态或动态添加其他provider。
- 除了jdk自带的加解密实现外,另外2个主要的加解密算法的提供者为
bouncy castle
和apache common codec
,它们提供了额外的算法以及在JDK基础上提高了易用性。其中bouncy castle就提供了Provider的扩展,补充了JDK没有实现的一些算法
。
下面我们就以bouncy castle为例,看看如何添加新的Provider扩展:
五.BouncyCastle是什么
- BouncyCastle(轻量级密码术包)是一种用于 Java 平台的开源的轻量级加密包;Bouncycstle 包含了大量哈希算法和加密算法,包括Java标准库没有的一些算法,如非对称加密算法
ECDSA(椭圆曲线数字签名算法)
,并提供JCE 1.2.1
的实现、RipeMD160哈希算法、椭圆曲线数字签名算法分支ED25519
六.如何使用BouncyCastle?
引入bouncycastle依赖
xml
<!-- <dependency>-->
<!-- <groupId>org.bouncycastle</groupId>-->
<!-- <artifactId>bcprov-jdk18on</artifactId>-->
<!-- <version>1.77</version>-->
<!-- </dependency>-->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.70</version>
</dependency>
Java标准库的java.security包提供了一种标准机制,允许第三方提供商无缝接入
。使用BouncyCastle提供的ED25519算法,需要先把BouncyCastle注册一下:
- 加入一行代码:在java应用程序启动注册BouncyCastle提供的所有哈希算法和加密算法
java
static {
//注册只需要在启动时进行一次,后续就可以使用BouncyCastle提供的所有哈希算法和加密算法。
Security.addProvider(new BouncyCastleProvider());
}
执行代码:
-
可以看到bouncycastle作为加密服务提供者已经注册到java程序中
-
系统支持的哈希算法和非对称加密算法也多出了很多
-------列出系统支持的消息摘要算法(散列算法、哈希算法):
SHA-1
SHA-384
HARAKA-256
SKEIN-512-256
SKEIN-1024-384
BLAKE2B-160
SHA
KECCAK-288
WHIRLPOOL
SKEIN-512-384
SHA-224
SM3
BLAKE2B-512
OID.1.0.10118.3.0.55
GOST3411-2012-512
KECCAK-256
SKEIN-512-128
BLAKE2B-384
SHAKE256-512
SKEIN-256-160
DSTU7564-256
SHA-256
BLAKE2S-224
SHA3-256
KECCAK-384
SKEIN-256-128
DSTU7564-384
HARAKA-512
SHAKE128-256
KECCAK-224
SKEIN-512-512
SKEIN-1024-512
SKEIN-512-160
GOST3411
BLAKE2B-256
SKEIN-1024-1024
SHA3-384
BLAKE2S-256
SHA-512/224
TIGER
RIPEMD256
SKEIN-256-256
SHA3-224
SHA3-512
RIPEMD320
RIPEMD160
GOST3411-2012-256
KECCAK-512
SKEIN-512-224
BLAKE2S-160
SHA-512/256
MD2
RIPEMD128
MD4
SHA-512
SKEIN-256-224
MD5
BLAKE2S-128
DSTU7564-512
-------列出系统支持的生成公钥和私钥对的算法(非对称加密算法):
ECDH
DH
DIFFIEHELLMAN
ECGOST3410-2012
X448
ECDHC
ED25519
GOST3410
ELGAMAL
DSA
ED448
DSTU4145
XDH
EC
ECDSA
RSA
X25519
ECGOST3410
ECIES
ECDHWITHSHA1KDF
RSASSA-PSS
EDDSA
ECMQV
七.bouncycastle实现ED25519工具类
Ed25519是椭圆曲线数字签名算法(ECDSA)的一个重要分支
特点:
- 安全性: Ed25519相对于传统的ECDSA有着更好的安全性。
- 效率: 它的运行效率非常高,适合在各种设备上执行,包括移动设备。
- 短签名: 它产生的签名非常短,只有64字节。
- 可用于区块链签名。签名过程不依赖
随机数生成器,
不依赖哈希函数的抗碰撞性
,没有时间通道
攻击的问题。
- 可用于区块链签名。签名过程不依赖
java
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
import org.bouncycastle.crypto.params.Ed25519KeyGenerationParameters;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Base64;
/**
* BouncyCastle是一个提供了很多哈希算法和加密算法的第三方库。它提供了Java标准库没有的一些算法,例如,RipeMD160哈希算法。其它第三方库还有Commons Codec等。
* 你可以使用Bouncy Castle的API来生成密钥对,然后使用私钥对消息进行签名,使用公钥来验证签名。
*/
public class Ed25519Utils {
static {
//注册只需要在启动时进行一次,后续就可以使用BouncyCastle提供的所有哈希算法和加密算法。
Security.addProvider(new BouncyCastleProvider());
}
//1.初始化密钥对
private static AsymmetricCipherKeyPair KEY_PAIR = generateKeyPair();
//2.创建一个私钥和私钥
private static Ed25519PrivateKeyParameters PRIVATE_KEY = getPrivateKey(KEY_PAIR);
private static Ed25519PublicKeyParameters PUBLIC_KEY = getPublicKey(KEY_PAIR);
/**
* 初始化上下文
*/
public static void initContext() {
KEY_PAIR = generateKeyPair();
PRIVATE_KEY = getPrivateKey(KEY_PAIR);
PUBLIC_KEY = getPublicKey(KEY_PAIR);
}
/**
* 获取私钥对消息签名的Base64格式字符串
*
* @param message
* @return
*/
public static String getPrivateKeySignMessageBase64(String message) {
byte[] messageBytes = getBytes(message);
System.out.println("签名消息:" + message + "\n");
//使用私钥对消息进行签名,然后将私钥签名编码为Base64格式,最后将base64私钥签名进行url编码
byte[] privateSignatureByte = privateKeySign(PRIVATE_KEY, messageBytes);
return base64EncodeToString(privateSignatureByte);
}
/**
* 使用公钥来验证签名。
*
* @param message 签名消息
* @param privateBase64Sign 私钥对消息签名的Base64格式字符串
*/
public static boolean publicKeyCheckSign(String message, String privateBase64Sign) {
//初始化签名器
Ed25519Signer verifier = new Ed25519Signer();
verifier.init(false, PUBLIC_KEY);
//执行验签
verifier.update(getBytes(message), 0, getBytes(message).length);
//验签结果
return verifier.verifySignature(Base64.getDecoder().decode(privateBase64Sign));
}
/**
* 使用私钥对消息进行签名
*
* @param privateKey 私钥
* @param messageBytes 消息 "account=zichangaibantest1@163.com&captcha=111111&code=WrPQctXMOu&pub_key=" + publicBase64Str + "&type=2";
* @return 私钥签名后的base编码消息
*/
public static byte[] privateKeySign(Ed25519PrivateKeyParameters privateKey, byte[] messageBytes) {
//初始化签名器
Ed25519Signer signer = new Ed25519Signer();
signer.init(true, privateKey);
// 执行签名
signer.update(messageBytes, 0, messageBytes.length);
//7.将私钥签名编码为Base64格式
return signer.generateSignature();
}
private static AsymmetricCipherKeyPair generateKeyPair() {
//1.创建ed25519密钥生成器
Ed25519KeyPairGenerator keyPairGenerator = new Ed25519KeyPairGenerator();
//密钥生成参数,需要指定随机种子
SecureRandom secureRandom = new SecureRandom();
Ed25519KeyGenerationParameters keyGenerationParameters = new Ed25519KeyGenerationParameters(secureRandom);
keyPairGenerator.init(keyGenerationParameters);
//2.生成公私钥对
return keyPairGenerator.generateKeyPair();
}
/**
* 获取私钥对象
*
* @param keyPair
* @return
*/
private static Ed25519PrivateKeyParameters getPrivateKey(AsymmetricCipherKeyPair keyPair) {
return (Ed25519PrivateKeyParameters) keyPair.getPrivate();
}
/**
* 获取公钥对象
*
* @param keyPair
* @return
*/
private static Ed25519PublicKeyParameters getPublicKey(AsymmetricCipherKeyPair keyPair) {
return (Ed25519PublicKeyParameters) keyPair.getPublic();
}
/**
* 获取私钥字节
*
* @param privateKey
* @return
*/
private static byte[] getPrivateByte(Ed25519PrivateKeyParameters privateKey) {
//序列化私钥
return privateKey.getEncoded();
}
/**
* 获取公钥字节
*
* @param publicKey
* @return
*/
private static byte[] getPublicByte(Ed25519PublicKeyParameters publicKey) {
//序列化公钥
return publicKey.getEncoded();
}
/**
* 获取base64编码后字符串
*
* @param bytes
* @return 如:/85uEv81XgrIbuHqnUMVRSrS8C/tr9jn0NBSv0wb1Dk= 会携带/、=之类特殊符号
*/
public static String base64EncodeToString(byte[] bytes) {
return Base64.getEncoder().encodeToString(bytes);
}
/**
* 获取私钥base64编码后字符串
*
* @param privateBase64Str 如:/85uEv81XgrIbuHqnUMVRSrS8C/tr9jn0NBSv0wb1Dk= 会携带/、=之类特殊符号
* @return
*/
public static String urlEncodeStr(String privateBase64Str) {
try {
return URLEncoder.encode(privateBase64Str, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return null;
}
public static byte[] getBytes(String str) {
return str.getBytes(StandardCharsets.UTF_8);
}
/**
* 获取base64编码公钥字符串
*
* @return
*/
public static String getBase64Public() {
byte[] publicBytes = getPublicByte(PUBLIC_KEY);
return base64EncodeToString(publicBytes);
}
/**
* 获取url编码后的 获取base64编码公钥字符串
*
* @return
* @throws
*/
public static String getBase64UrlEncodePublic() {
return urlEncodeStr(getBase64Public());
}
/**
* 获取base64编码私钥字符串
*
* @return
*/
public static String getBase64Private() {
byte[] priavteBytes = getPrivateByte(PRIVATE_KEY);
return base64EncodeToString(priavteBytes);
}
/**
* 获取url编码后的 获取base64编码私钥字符串
*
* @return
* @throws
*/
public static String getBase64UrlEncodePrivate() {
return urlEncodeStr(getBase64Private());
}
}
测试代码
java
public static void main(String[] args) {
for (int i = 0; i < 1; i++) {
Ed25519Utils.initContext();
//1.将publicBytes编码为Base64格式,然后对Base64公钥进行url编码
String publicBase64 = Ed25519Utils.getBase64Public();
String urlEncodedBase64Public = Ed25519Utils.urlEncodeStr(publicBase64);
System.out.println("base64公钥:" + publicBase64);
System.out.println("URL编码后的base64公钥为:" + urlEncodedBase64Public + "\n");
//2.将privateBytes编码为Base64格式,然后对Base64私钥进行url编码
String privateBase64 = Ed25519Utils.getBase64Private();
String urlEncodedBase64Private = Ed25519Utils.urlEncodeStr(privateBase64);
System.out.println("base64私钥:" + privateBase64);
System.out.println("URL编码后的base64私钥为:" + urlEncodedBase64Private + "\n");
//3.拼接公钥到请求消息中,同时序列化消息
String message = "account=zichangaibantest1@163.com&captcha=111111&code=WrPQctXMOu&pub_key=publicKey&type=2";
// 需要签名的数据,根据key进行排序,然后序列化签名
message = message.replaceAll("publicKey", publicBase64);
//4.使用私钥对消息进行签名,然后将私钥签名编码为Base64格式,最后将base64私钥签名进行url编码
String privateBase64Sign = Ed25519Utils.getPrivateKeySignMessageBase64(message);
String urlEncodePrivateBase64Sign = Ed25519Utils.urlEncodeStr(privateBase64Sign);
System.out.println("bas4私钥签名消息为:" + privateBase64Sign);
System.out.println("私钥签名消息:" + urlEncodePrivateBase64Sign + "\n");
//5.使用公钥验证签名
boolean isValid = Ed25519Utils.publicKeyCheckSign(message, privateBase64Sign);
System.out.println("验证私钥签名是否正确 i: " + isValid);
System.out.println("----------------------------------------------------");
System.out.println("----------------------------------------------------");
}
}
}
执行结果
Provider Name | Provider Version | Algorithm Type | Algorithm Name |
---|---|---|---|
SUN | 1.8 | AlgorithmParameterGenerator | DSA |
AlgorithmParameters | DSA | ||
CertPathBuilder | PKIX | ||
CertPathValidator | PKIX | ||
CertStore | Collection LDAP com.sun.security.IndexedCollection | ||
CertificateFactory | X.509 | ||
Configuration | JavaLoginConfig | ||
KeyFactory | DSA | ||
KeyPairGenerator | DSA | ||
KeyStore | CaseExactJKS DKS JKS | ||
MessageDigest | MD2 MD5 SHA SHA-224 SHA-256 SHA-384 SHA-512 | ||
Policy | JavaPolicy | ||
SecureRandom | SHA1PRNG | ||
Signature | NONEwithDSA SHA1withDSA SHA224withDSA SHA256withDSA | ||
SunEC | 1.8 | AlgorithmParameters | EC |
KeyAgreement | ECDH | ||
KeyFactory | EC | ||
KeyPairGenerator | EC | ||
Signature | NONEwithECDSA SHA1withECDSA SHA224withECDSA SHA256withECDSA SHA384withECDSA SHA512withECDSA | ||
SunJCE | 1.8 | AlgorithmParameterGenerator | DiffieHellman |
AlgorithmParameters | AES Blowfish DES DESede DiffieHellman GCM OAEP PBE PBES2 PBEWithHmacSHA1AndAES_128 PBEWithHmacSHA1AndAES_256 PBEWithHmacSHA224AndAES_128 PBEWithHmacSHA224AndAES_256 PBEWithHmacSHA256AndAES_128 PBEWithHmacSHA256AndAES_256 PBEWithHmacSHA384AndAES_128 PBEWithHmacSHA384AndAES_256 PBEWithHmacSHA512AndAES_128 PBEWithHmacSHA512AndAES_256 PBEWithMD5AndDES PBEWithMD5AndTripleDES PBEWithSHA1AndDESede PBEWithSHA1AndRC2_128 PBEWithSHA1AndRC2_40 PBEWithSHA1AndRC4_128 PBEWithSHA1AndRC4_40 RC2 | ||
Cipher | AES AESWrap AESWrap_128 AESWrap_192 AESWrap_256 AES_128/CBC/NoPadding AES_128/CFB/NoPadding AES_128/ECB/NoPadding AES_128/GCM/NoPadding AES_128/OFB/NoPadding AES_192/CBC/NoPadding AES_192/CFB/NoPadding AES_192/ECB/NoPadding AES_192/GCM/NoPadding AES_192/OFB/NoPadding AES_256/CBC/NoPadding AES_256/CFB/NoPadding AES_256/ECB/NoPadding AES_256/GCM/NoPadding AES_256/OFB/NoPadding ARCFOUR Blowfish DES DESede DESedeWrap PBEWithHmacSHA1AndAES_128 PBEWithHmacSHA1AndAES_256 PBEWithHmacSHA224AndAES_128 PBEWithHmacSHA224AndAES_256 PBEWithHmacSHA256AndAES_128 PBEWithHmacSHA256AndAES_256 PBEWithHmacSHA384AndAES_128 PBEWithHmacSHA384AndAES_256 PBEWithHmacSHA512AndAES_128 PBEWithHmacSHA512AndAES_256 PBEWithMD5AndDES PBEWithMD5AndTripleDES PBEWithSHA1AndDESede PBEWithSHA1AndRC2_128 PBEWithSHA1AndRC2_40 PBEWithSHA1AndRC4_128 PBEWithSHA1AndRC4_40 RC2 RSA | ||
KeyAgreement | DiffieHellman | ||
KeyFactory | DiffieHellman | ||
KeyGenerator | AES ARCFOUR Blowfish DES DESede HmacMD5 HmacSHA1 HmacSHA224 HmacSHA256 HmacSHA384 HmacSHA512 RC2 SunTls12Prf SunTlsKeyMaterial SunTlsMasterSecret SunTlsPrf SunTlsRsaPremasterSecret | ||
KeyPairGenerator | DiffieHellman | ||
KeyStore | JCEKS | ||
Mac | HmacMD5 HmacPBESHA1 HmacSHA1 HmacSHA224 HmacSHA256 HmacSHA384 HmacSHA512 PBEWithHmacSHA1 PBEWithHmacSHA224 PBEWithHmacSHA256 PBEWithHmacSHA384 PBEWithHmacSHA512 SslMacMD5 SslMacSHA1 | ||
SecretKeyFactory | DES DESede PBEWithHmacSHA1AndAES_128 PBEWithHmacSHA1AndAES_256 PBEWithHmacSHA224AndAES_128 PBEWithHmacSHA224AndAES_256 PBEWithHmacSHA256AndAES_128 PBEWithHmacSHA256AndAES_256 PBEWithHmacSHA384AndAES_128 PBEWithHmacSHA384AndAES_256 PBEWithHmacSHA512AndAES_128 PBEWithHmacSHA512AndAES_256 PBEWithMD5AndDES PBEWithMD5AndTripleDES PBEWithSHA1AndDESede PBEWithSHA1AndRC2_128 PBEWithSHA1AndRC2_40 PBEWithSHA1AndRC4_128 PBEWithSHA1AndRC4_40 PBKDF2WithHmacSHA1 PBKDF2WithHmacSHA224 PBKDF2WithHmacSHA256 PBKDF2WithHmacSHA384 PBKDF2WithHmacSHA512 | ||
SunJGSS | 1.8 | GssApiMechanism | 1.2.840.113554.1.2.2 1.3.6.1.5.5.2 |
SunJSSE | 1.8 | KeyFactory | RSA |
KeyManagerFactory | NewSunX509 SunX509 | ||
KeyPairGenerator | RSA | ||
KeyStore | PKCS12 | ||
SSLContext | Default TLS TLSv1 TLSv1.1 TLSv1.2 | ||
Signature | MD2withRSA MD5andSHA1withRSA MD5withRSA SHA1withRSA | ||
TrustManagerFactory | PKIX SunX509 | ||
SunMSCAPI | 1.8 | Cipher | RSA RSA/ECB/PKCS1Padding |
KeyPairGenerator | RSA | ||
KeyStore | Windows-MY Windows-ROOT | ||
SecureRandom | Windows-PRNG | ||
Signature | MD2withRSA MD5withRSA NONEwithRSA SHA1withRSA SHA256withRSA SHA384withRSA SHA512withRSA | ||
SunPCSC | 1.8 | TerminalFactory | PC/SC |
SunRsaSign | 1.8 | KeyFactory | RSA |
KeyPairGenerator | RSA | ||
Signature | MD2withRSA MD5withRSA SHA1withRSA SHA224withRSA SHA256withRSA SHA384withRSA SHA512withRSA | ||
SunSASL | 1.8 | SaslClientFactory | CRAM-MD5 DIGEST-MD5 EXTERNAL GSSAPI NTLM PLAIN |
SaslServerFactory | CRAM-MD5 DIGEST-MD5 GSSAPI NTLM | ||
XMLDSig | 1.8 | KeyInfoFactory | DOM |
TransformService | http://www.w3.org/2000/09/xmldsig#base64 http://www.w3.org/2000/09/xmldsig#enveloped-signature http://www.w3.org/2001/10/xml-exc-c14n# http://www.w3.org/2001/10/xml-exc-c14n#WithComments http://www.w3.org/2002/06/xmldsig-filter2 http://www.w3.org/2006/12/xml-c14n11 http://www.w3.org/2006/12/xml-c14n11#WithComments http://www.w3.org/TR/1999/REC-xpath-19991116 http://www.w3.org/TR/1999/REC-xslt-19991116 http://www.w3.org/TR/2001/REC-xml-c14n-20010315 http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments | ||
XMLSignatureFactory | DOM |