Android 加密知识详解

在 Android 开发中，加密技术是确保数据安全的重要手段。本文将详细介绍几种常见的加密文件格式（如 PKCS#12、JKS、BKS）及其用途，以及常用的加密方法（如 X.509 证书和 SHA 哈希函数），并结合实际应用场景进行讲解。

1. keytool 和 OpenSSL 的使用及下载方式

1.1 keytool

keytool 是 Java 开发工具包（JDK）自带的一个命令行工具，用于创建和管理密钥库（keystores）和证书。

下载方式

如果你已经安装了 JDK，那么 keytool 已经包含在内。你可以在命令行中直接使用 keytool 命令。
如果没有安装 JDK，可以从 Oracle 官方网站下载并安装 JDK。

常用命令

生成密钥对和自签名证书：

 keytool -genkeypair -alias myalias -keyalg RSA -keysize 2048 -keystore mykeystore.jks

查看密钥库内容：

 keytool -list -v -keystore mykeystore.jks

导出证书：

 keytool -exportcert -alias myalias -file mycertificate.crt -keystore mykeystore.jks

导入证书：

 keytool -importcert -file mycertificate.crt -alias myalias -keystore mykeystore.jks

1.2 OpenSSL

OpenSSL 是一个强大的安全套接字层密码库，包含各种密码算法、常用的密钥和证书封装管理功能以及 SSL 协议，并提供丰富的应用程序供测试或其他目的使用。

下载方式

Windows：可以从 OpenSSL 官方网站下载预编译的二进制文件，或者使用 Chocolatey 包管理器安装。
```
 choco install openssl
```
Linux：大多数 Linux 发行版都预装了 OpenSSL，如果没有，可以使用包管理器安装。
```
 sudo apt-get install openssl  # Debian/Ubuntu
sudo yum install openssl      # CentOS/RHEL
```
macOS：可以使用 Homebrew 安装 OpenSSL。
```
 brew install openssl
```

常用命令

生成私钥：

 openssl genpkey -algorithm RSA -out private.key

生成自签名证书：

 openssl req -new -x509 -key private.key -out certificate.crt -days 365

生成 CSR（证书签名请求）：

 openssl req -new -key private.key -out request.csr

查看证书内容：

 openssl x509 -in certificate.crt -text -noout

生成 PKCS#12 文件：

 openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

2. 密钥库格式

2.1 JKS (Java KeyStore)

JSK 是 Java 平台上的密钥库格式，使用 keytool 工具管理。它主要用于存储密钥对（私钥和公钥）和证书。

示例

生成密钥对和自签名证书：

 keytool -genkeypair -alias myalias -keyalg RSA -keysize 2048 -keystore mykeystore.jks

查看密钥库内容：

 keytool -list -v -keystore mykeystore.jks

导出证书：

 keytool -exportcert -alias myalias -file mycertificate.crt -keystore mykeystore.jks

导入证书：

 keytool -importcert -file mycertificate.crt -alias myalias -keystore mykeystore.jks

2.2 PKCS#12 (P12)

PKCS#12 是国际标准的密钥库格式，支持多个证书和密钥对，使用 openssl 工具管理。它通常用于跨平台的密钥库管理和传输。

示例

生成 PKCS#12 文件：

 openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

查看 PKCS#12 文件内容：
```
 openssl pkcs12 -info -in keystore.p12
```

从 PKCS#12 文件中提取证书和私钥：

 openssl pkcs12 -in keystore.p12 -out extracted.pem -nodes

2.3 BKS (Bouncy Castle KeyStore)

BKS 是由 Bouncy Castle 提供的密钥库格式，支持更多算法，适用于 Android。它提供了比 JKS 更多的安全特性和灵活性。

示例

生成 BKS 密钥库：

 keytool -importcert -file certificate.crt -keystore keystore.bks -storetype BKS -provider org.bouncycastle.jce.provider.BouncyCastleProvider

查看 BKS 密钥库内容：

 keytool -list -v -keystore keystore.bks -storetype BKS -provider org.bouncycastle.jce.provider.BouncyCastleProvider

3. 签名（Signature）

签名是一种确保数据完整性和来源真实性的机制。签名过程通常涉及以下步骤：

生成哈希值：使用哈希函数（如 SHA-256）对数据生成固定长度的哈希值。
生成签名：使用私钥对哈希值进行加密，生成签名。
验证签名：接收方使用公钥解密签名，得到哈希值，并与重新计算的数据哈希值进行比较，如果一致则签名有效。

示例

 import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
 
public class SignatureExample {
    public static void main(String[] args) throws Exception {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
 
        // 生成哈希值
        String data = "Hello, World!";
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));
 
        // 生成签名
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);
        signature.update(hash);
        byte[] signedData = signature.sign();
 
        // 验证签名
        signature.initVerify(publicKey);
        signature.update(hash);
        boolean isVerified = signature.verify(signedData);
 
        System.out.println("Signature verified: " + isVerified);
    }
}

4. 对称加密（Symmetric Encryption）

对称加密 使用相同的密钥进行加密和解密。常见的对称加密算法有 AES（Advanced Encryption Standard）、DES（Data Encryption Standard）等。

示例

 import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
 
public class SymmetricEncryptionExample {
    public static void main(String[] args) throws Exception {
        String key = "1234567890123456"; // 16 字节的密钥
        String data = "Hello, World!";
 
        // 加密
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "AES");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        String encodedEncryptedData = Base64.getEncoder().encodeToString(encryptedData);
        System.out.println("Encrypted Data: " + encodedEncryptedData);
 
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        byte[] decodedEncryptedData = Base64.getDecoder().decode(encodedEncryptedData);
        byte[] decryptedData = cipher.doFinal(decodedEncryptedData);
        String originalData = new String(decryptedData);
        System.out.println("Decrypted Data: " + originalData);
    }
}

5. 非对称加密（Asymmetric Encryption）

非对称加密 使用一对密钥（公钥和私钥）进行加密和解密。公钥用于加密，私钥用于解密。常见的非对称加密算法有 RSA、ECC（Elliptic Curve Cryptography）等。

示例

 import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import java.util.Base64;
 
public class AsymmetricEncryptionExample {
    public static void main(String[] args) throws Exception {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
 
        String data = "Hello, World!";
 
        // 加密
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        String encodedEncryptedData = Base64.getEncoder().encodeToString(encryptedData);
        System.out.println("Encrypted Data: " + encodedEncryptedData);
 
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodedEncryptedData = Base64.getDecoder().decode(encodedEncryptedData);
        byte[] decryptedData = cipher.doFinal(decodedEncryptedData);
        String originalData = new String(decryptedData);
        System.out.println("Decrypted Data: " + originalData);
    }
}

6. 使用 PKCS#12 和 JKS 及 X.509 进行 SSL/TLS 通信

假设你需要在 Android 应用中使用 PKCS#12 和 JKS 密钥库以及 X.509 证书进行 SSL/TLS 通信。

6.1 生成密钥库和证书

6.1.1 生成 PKCS#12 (P12) 密钥库

生成私钥：

 openssl genpkey -algorithm RSA -out private.key

生成自签名证书：

 openssl req -new -x509 -key private.key -out certificate.crt -days 365

生成 PKCS#12 文件：

 openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

6.1.2 生成 JKS 密钥库

生成密钥对和自签名证书：

 keytool -genkeypair -alias myalias -keyalg RSA -keysize 2048 -keystore mykeystore.jks

导出证书：

 keytool -exportcert -alias myalias -file mycertificate.crt -keystore mykeystore.jks

6.2 加载密钥库并配置 SSLContext

6.2.1 使用 PKCS#12 (P12) 密钥库

 import java.io.FileInputStream;
import java.security.KeyStore;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
 
public class PKCS12SSLConfigurator {
    public static SSLSocketFactory createSSLSocketFactory() throws Exception {
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream("keystore.p12")) {
            keyStore.load(fis, "password".toCharArray());
        }
 
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(keyStore, "password".toCharArray());
 
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), null, null);
 
        return sslContext.getSocketFactory();
    }
}

6.2.2 使用 JKS 密钥库

 import java.io.FileInputStream;
import java.security.KeyStore;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
 
public class JKS_SSLConfigurator {
    public static SSLSocketFactory createSSLSocketFactory() throws Exception {
        KeyStore keyStore = KeyStore.getInstance("JKS");
        try (FileInputStream fis = new FileInputStream("mykeystore.jks")) {
            keyStore.load(fis, "password".toCharArray());
        }
 
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(keyStore, "password".toCharArray());
 
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), null, null);
 
        return sslContext.getSocketFactory();
    }
}

6.3 使用 SSLSocketFactory 进行 HTTPS 请求

 import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
 
public class Main {
    public static void main(String[] args) {
        try {
            // 使用 PKCS#12 密钥库
            SSLSocketFactory sslSocketFactory = PKCS12SSLConfigurator.createSSLSocketFactory();
 
            // 或者使用 JKS 密钥库
            // SSLSocketFactory sslSocketFactory = JKS_SSLConfigurator.createSSLSocketFactory();
 
            URL url = new URL("https://example.com");
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            connection.setSSLSocketFactory(sslSocketFactory);
            connection.connect();
 
            // 处理响应
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.4 使用 X.509 证书进行身份验证

假设你已经有一个 X.509 证书和私钥，并且需要将其导入到 PKCS#12 或 JKS 密钥库中。

6.4.1 导入 X.509 证书到 PKCS#12 密钥库

生成 PKCS#12 文件：

 openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

6.4.2 导入 X.509 证书到 JKS 密钥库

生成密钥对和自签名证书：

 keytool -genkeypair -alias myalias -keyalg RSA -keysize 2048 -keystore mykeystore.jks

导出证书：

 keytool -exportcert -alias myalias -file mycertificate.crt -keystore mykeystore.jks

导入外部 X.509 证书：

 keytool -importcert -file external_certificate.crt -alias externalalias -keystore mykeystore.jks

7. X.509 和 SHA 的关系及同类算法

7.1 X.509 证书

X.509 证书 是一种数字证书标准，用于验证公钥的所有权，常用于 SSL/TLS 通信中的身份验证。

7.2 SHA (Secure Hash Algorithm)

SHA 是一种哈希函数，用于生成固定长度的哈希值，常用于数据完整性校验和密码存储。常见的 SHA 类型有 SHA-1、SHA-256 和 SHA-512。

7.3 关系

X.509 证书 和 SHA 在功能上没有直接关系，但它们经常一起使用：
- 证书签名：X.509 证书中的签名通常使用哈希函数（如 SHA-256）和非对称加密算法（如 RSA）生成。
- 数据完整性校验：在传输过程中，可以使用 SHA 哈希值来校验数据的完整性。

7.4 同类算法

X.509 证书的同类算法：
- PEM (Privacy Enhanced Mail)：一种文本格式，用于编码 X.509 证书。
- DER (Distinguished Encoding Rules)：一种二进制格式，用于编码 X.509 证书。
SHA 的同类算法：
- MD5 (Message-Digest Algorithm 5)：生成 128 位哈希值，现已不推荐使用。
- SHA-1：生成 160 位哈希值，已不再被认为是安全的。
- SHA-256：生成 256 位哈希值，广泛使用。
- SHA-512：生成 512 位哈希值，提供更高的安全性。

7.5 示例

7.5.1 X.509 证书签名

假设你有一个 X.509 证书和私钥，你需要生成一个签名：

生成 X.509 证书：

 openssl req -new -x509 -key private.key -out certificate.crt -days 365

生成签名：

 import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.cert.X509Certificate;
import java.security.cert.CertificateFactory;
import java.io.FileInputStream;
 
public class SignatureExample {
    public static void main(String[] args) throws Exception {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
 
        // 加载 X.509 证书
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        try (FileInputStream fis = new FileInputStream("certificate.crt")) {
            X509Certificate certificate = (X509Certificate) cf.generateCertificate(fis);
 
            // 生成签名
            Signature signature = Signature.getInstance("SHA256withRSA");
            signature.initSign(privateKey);
            byte[] data = "Hello, World!".getBytes();
            signature.update(data);
            byte[] signedData = signature.sign();
 
            // 验证签名
            signature.initVerify(publicKey);
            signature.update(data);
            boolean isVerified = signature.verify(signedData);
 
            System.out.println("Signature verified: " + isVerified);
        }
    }
}

7.5.2 数据完整性校验

假设你需要使用 SHA-256 进行数据完整性校验：

生成 SHA-256 哈希值：

 import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
 
public class SHAExample {
    public static void main(String[] args) throws Exception {
        String data = "Hello, World!";
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));
        String hexString = bytesToHex(hash);
        System.out.println("SHA-256 Hash: " + hexString);
    }
 
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

8 BKS实现HTTPS通讯示例

当然可以！下面是关于如何使用 BKS（Bouncy Castle KeyStore）对接 HTTPS 实现的详细步骤和示例代码。

8.1 准备工作

首先，确保你已经安装了 Bouncy Castle 提供的 JAR 文件。你可以从 Bouncy Castle 官方网站下载最新版本的 JAR 文件，或者通过 Maven 依赖添加到你的项目中。

Maven 依赖

在你的 pom.xml 文件中添加以下依赖：

 <dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.68</version>
</dependency>

8.2 生成 BKS 密钥库

8.2.1 使用 OpenSSL 生成私钥和自签名证书

生成私钥：

 openssl genpkey -algorithm RSA -out private.key

生成自签名证书：

 openssl req -new -x509 -key private.key -out certificate.crt -days 365

8.2.2 将证书和私钥导入 BKS 密钥库

生成 PKCS#12 文件：

 openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

将 PKCS#12 文件转换为 BKS 文件：

 keytool -importkeystore -deststorepass password -destkeypass password -destkeystore keystore.bks -srckeystore keystore.p12 -srcstoretype PKCS12 -srcstorepass password -alias alias

8.3 加载 BKS 密钥库并配置 SSLContext

8.3.1 创建 BKS 密钥库加载器

 import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.Security;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
public class BKSSSLConfigurator {
    static {
        // 添加 Bouncy Castle 提供商
        Security.addProvider(new BouncyCastleProvider());
    }
 
    public static SSLSocketFactory createSSLSocketFactory() throws Exception {
        KeyStore keyStore = KeyStore.getInstance("BKS", "BC");
        try (FileInputStream fis = new FileInputStream("keystore.bks")) {
            keyStore.load(fis, "password".toCharArray());
        }
 
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(keyStore, "password".toCharArray());
 
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), null, null);
 
        return sslContext.getSocketFactory();
    }
}

8.4 使用 SSLSocketFactory 进行 HTTPS 请求

8.4.1 创建主类并进行 HTTPS 请求

 import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
 
public class Main {
    public static void main(String[] args) {
        try {
            // 创建 SSLSocketFactory
            SSLSocketFactory sslSocketFactory = BKSSSLConfigurator.createSSLSocketFactory();
 
            // 创建 URL 对象
            URL url = new URL("https://example.com");
 
            // 打开连接
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
 
            // 设置 SSLSocketFactory
            connection.setSSLSocketFactory(sslSocketFactory);
 
            // 连接
            connection.connect();
 
            // 处理响应
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
 
            // 读取响应内容
            try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                String inputLine;
                StringBuffer content = new StringBuffer();
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
                System.out.println("Response Content: " + content.toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在加密和安全领域中，“provider”是指提供特定加密算法和服务的软件模块。在 Java 中，Provider 是一个接口，定义了一组加密服务（如加密算法、密钥生成、签名等）的实现。每个 Provider 通常是一个独立的库或模块，负责实现一组相关的加密功能。

8.5 Provider 的作用

标准化接口：Provider 接口提供了一种标准化的方式来访问不同的加密算法和服务，使得开发者不需要关心底层的具体实现细节。
可插拔性：Java 安全架构允许动态地添加和移除 Provider，这使得系统可以灵活地支持新的加密算法和服务。
模块化：每个 Provider 可以专注于实现一组特定的加密功能，这样可以提高代码的可维护性和扩展性。

常见的 Provider

Sun Provider：这是 Java 标准库自带的默认 Provider，实现了许多常用的加密算法和服务。
Bouncy Castle Provider：这是一个开源的 Provider，提供了大量的加密算法和服务，特别适合于需要更多高级加密功能的应用。
SunJSSE Provider：这个 Provider 提供了 Java Secure Socket Extension (JSSE) 的实现，用于支持 SSL/TLS 协议。
SunJCE Provider：这个 Provider 提供了 Java Cryptography Extension (JCE) 的实现，支持更多的加密算法和服务。

如何使用 Provider

在 Java 中，你可以通过 Security 类来管理和使用 Provider。以下是一些常见的操作：

获取所有已注册的 Provider：

 import java.security.Provider;
import java.security.Security;
 
public class ListProviders {
    public static void main(String[] args) {
        Provider[] providers = Security.getProviders();
        for (Provider provider : providers) {
            System.out.println(provider.getName());
        }
    }
}

添加新的 Provider：

 import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
public class AddProvider {
    public static void main(String[] args) {
        // 添加 Bouncy Castle Provider
        Security.addProvider(new BouncyCastleProvider());
    }
}

指定 Provider：
当你需要使用某个特定的 Provider 来执行加密操作时，可以在相关类的方法调用中指定 Provider。例如：

 import java.security.KeyPairGenerator;
import java.security.Security;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
public class UseProvider {
    public static void main(String[] args) throws Exception {
        // 添加 Bouncy Castle Provider
        Security.addProvider(new BouncyCastleProvider());
 
        // 使用 Bouncy Castle Provider 生成 RSA 密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA", "BC");
        keyGen.initialize(2048);
        keyGen.generateKeyPair();
    }
}

示例：使用 Bouncy Castle Provider 进行加密

以下是一个完整的示例，展示了如何使用 Bouncy Castle Provider 进行 RSA 加密和解密。

1. 添加 Bouncy Castle 依赖

如果你使用 Maven，可以在 pom.xml 中添加以下依赖：

 <dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.68</version>
</dependency>

2. 使用 Bouncy Castle Provider 进行 RSA 加密和解密

 import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import javax.crypto.Cipher;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
public class RSAEncryptionExample {
    static {
        // 添加 Bouncy Castle Provider
        Security.addProvider(new BouncyCastleProvider());
    }
 
    public static void main(String[] args) throws Exception {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA", "BC");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
 
        // 要加密的数据
        String data = "Hello, World!";
        byte[] plainText = data.getBytes();
 
        // 加密
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(plainText);
 
        System.out.println("Encrypted Data: " + bytesToHex(encryptedData));
 
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedData = cipher.doFinal(encryptedData);
        String decryptedText = new String(decryptedData);
 
        System.out.println("Decrypted Text: " + decryptedText);
    }
 
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

总结

通过上述解释和示例代码，我们可以看到：

公钥和私钥：是一对密钥，公钥用于加密和验证签名，私钥用于解密和生成签名。
加密：使用公钥对数据进行加密，确保数据的机密性。
非对称加密：使用一对密钥（公钥和私钥）进行加密和解密，提高了安全性。
签名：使用私钥对数据的哈希值进行加密，生成签名，确保数据的完整性和来源真实性。

Provider 是 Java 加密框架中的一个重要概念，它提供了一种标准化和模块化的方式来访问和使用各种加密算法和服务。通过 Provider，开发者可以灵活地选择和切换不同的加密实现，从而满足不同场景下的安全需求。希望这些解释和示例能够帮助你更好地理解和使用 Provider。如果有任何问题或需要进一步的解释，请随时提问。

通过本文，我们详细介绍了 keytool 和 OpenSSL 的使用及下载方式，以及密钥库（JKS、PKCS#12、BKS）的格式和用途，签名、对称加密和非对称加密的概念和示例代码。这些工具和技术在数据安全和身份验证中起着重要作用，希望对你在 Android 开发中的加密需求有所帮助！

如果有任何问题或需要进一步的解释，请随时留言交流。

__EOF__

本文作者：小书童
本文链接：https://www.cnblogs.com/ruiruizhou/p/18524894.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2024-11-04 11:53 还要再努力一些吧阅读(187) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Spring学习（1）

· Docker学习

· 安卓安全秘籍-全-

· 公钥加密和私钥加密是什么？

· Android 传输数据加密解密的几种算法

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】

历史上的今天：
2021-11-04 Java基础学习（三）
2021-11-04 Java基础学习（二）

公告

Android 加密知识详解

发表于 2024-11-04 11:53阅读：187评论：0推荐：0

关注

跳至底部

昵称：还要再努力一些吧
园龄： 3年4个月
粉丝： 7
关注： 2

+加关注

随笔分类

java(1)

	sudo apt-get install openssl # Debian/Ubuntu
	sudo yum install openssl # CentOS/RHEL

	import java.security.KeyPair;
	import java.security.KeyPairGenerator;
	import java.security.PrivateKey;
	import java.security.PublicKey;
	import java.security.Signature;
	import java.security.MessageDigest;
	import java.nio.charset.StandardCharsets;

	public class SignatureExample {
	public static void main(String[] args) throws Exception {
	// 生成密钥对
	KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
	keyGen.initialize(2048);
	KeyPair keyPair = keyGen.generateKeyPair();
	PrivateKey privateKey = keyPair.getPrivate();
	PublicKey publicKey = keyPair.getPublic();

	// 生成哈希值
	String data = "Hello, World!";
	MessageDigest md = MessageDigest.getInstance("SHA-256");
	byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));

	// 生成签名
	Signature signature = Signature.getInstance("SHA256withRSA");
	signature.initSign(privateKey);
	signature.update(hash);
	byte[] signedData = signature.sign();

	// 验证签名
	signature.initVerify(publicKey);
	signature.update(hash);
	boolean isVerified = signature.verify(signedData);

	System.out.println("Signature verified: " + isVerified);
	}
	}

	import javax.crypto.Cipher;
	import javax.crypto.spec.SecretKeySpec;
	import java.util.Base64;

	public class SymmetricEncryptionExample {
	public static void main(String[] args) throws Exception {
	String key = "1234567890123456"; // 16 字节的密钥
	String data = "Hello, World!";

	// 加密
	Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
	SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "AES");
	cipher.init(Cipher.ENCRYPT_MODE, keySpec);
	byte[] encryptedData = cipher.doFinal(data.getBytes());
	String encodedEncryptedData = Base64.getEncoder().encodeToString(encryptedData);
	System.out.println("Encrypted Data: " + encodedEncryptedData);

	// 解密
	cipher.init(Cipher.DECRYPT_MODE, keySpec);
	byte[] decodedEncryptedData = Base64.getDecoder().decode(encodedEncryptedData);
	byte[] decryptedData = cipher.doFinal(decodedEncryptedData);
	String originalData = new String(decryptedData);
	System.out.println("Decrypted Data: " + originalData);
	}
	}

	import java.io.FileInputStream;
	import java.security.KeyStore;
	import javax.net.ssl.KeyManagerFactory;
	import javax.net.ssl.SSLContext;
	import javax.net.ssl.SSLSocketFactory;

	public class PKCS12SSLConfigurator {
	public static SSLSocketFactory createSSLSocketFactory() throws Exception {
	KeyStore keyStore = KeyStore.getInstance("PKCS12");
	try (FileInputStream fis = new FileInputStream("keystore.p12")) {
	keyStore.load(fis, "password".toCharArray());
	}

	KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
	kmf.init(keyStore, "password".toCharArray());

	SSLContext sslContext = SSLContext.getInstance("TLS");
	sslContext.init(kmf.getKeyManagers(), null, null);

	return sslContext.getSocketFactory();
	}
	}

	import java.net.URL;
	import javax.net.ssl.HttpsURLConnection;

	public class Main {
	public static void main(String[] args) {
	try {
	// 使用 PKCS#12 密钥库
	SSLSocketFactory sslSocketFactory = PKCS12SSLConfigurator.createSSLSocketFactory();

	// 或者使用 JKS 密钥库
	// SSLSocketFactory sslSocketFactory = JKS_SSLConfigurator.createSSLSocketFactory();

	URL url = new URL("https://example.com");
	HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
	connection.setSSLSocketFactory(sslSocketFactory);
	connection.connect();

	// 处理响应
	int responseCode = connection.getResponseCode();
	System.out.println("Response Code: " + responseCode);
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}

	import java.security.MessageDigest;
	import java.nio.charset.StandardCharsets;

	public class SHAExample {
	public static void main(String[] args) throws Exception {
	String data = "Hello, World!";
	MessageDigest md = MessageDigest.getInstance("SHA-256");
	byte[] hash = md.digest(data.getBytes(StandardCharsets.UTF_8));
	String hexString = bytesToHex(hash);
	System.out.println("SHA-256 Hash: " + hexString);
	}

	private static String bytesToHex(byte[] bytes) {
	StringBuilder sb = new StringBuilder();
	for (byte b : bytes) {
	sb.append(String.format("%02x", b));
	}
	return sb.toString();
	}
	}

	<dependency>
	<groupId>org.bouncycastle</groupId>
	<artifactId>bcprov-jdk15on</artifactId>
	<version>1.68</version>
	</dependency>

	import java.io.FileInputStream;
	import java.security.KeyStore;
	import java.security.Security;
	import javax.net.ssl.KeyManagerFactory;
	import javax.net.ssl.SSLContext;
	import javax.net.ssl.SSLSocketFactory;
	import org.bouncycastle.jce.provider.BouncyCastleProvider;

	public class BKSSSLConfigurator {
	static {
	// 添加 Bouncy Castle 提供商
	Security.addProvider(new BouncyCastleProvider());
	}

	public static SSLSocketFactory createSSLSocketFactory() throws Exception {
	KeyStore keyStore = KeyStore.getInstance("BKS", "BC");
	try (FileInputStream fis = new FileInputStream("keystore.bks")) {
	keyStore.load(fis, "password".toCharArray());
	}

	KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
	kmf.init(keyStore, "password".toCharArray());

	SSLContext sslContext = SSLContext.getInstance("TLS");
	sslContext.init(kmf.getKeyManagers(), null, null);

	return sslContext.getSocketFactory();
	}
	}

	import java.security.Provider;
	import java.security.Security;

	public class ListProviders {
	public static void main(String[] args) {
	Provider[] providers = Security.getProviders();
	for (Provider provider : providers) {
	System.out.println(provider.getName());
	}
	}
	}

	import java.security.Security;
	import org.bouncycastle.jce.provider.BouncyCastleProvider;

	public class AddProvider {
	public static void main(String[] args) {
	// 添加 Bouncy Castle Provider
	Security.addProvider(new BouncyCastleProvider());
	}
	}

还要再努力一些吧

尘世中迷路小书童！！！

Android 加密知识详解

1. keytool 和 OpenSSL 的使用及下载方式

1.1 keytool

下载方式

常用命令

1.2 OpenSSL

下载方式

常用命令

2. 密钥库格式

2.1 JKS (Java KeyStore)

示例

2.2 PKCS#12 (P12)

示例

2.3 BKS (Bouncy Castle KeyStore)

示例

3. 签名（Signature）

示例

4. 对称加密（Symmetric Encryption）

示例

5. 非对称加密（Asymmetric Encryption）

示例

6. 使用 PKCS#12 和 JKS 及 X.509 进行 SSL/TLS 通信

6.1 生成密钥库和证书

6.1.1 生成 PKCS#12 (P12) 密钥库

6.1.2 生成 JKS 密钥库

6.2 加载密钥库并配置 SSLContext

6.2.1 使用 PKCS#12 (P12) 密钥库

6.2.2 使用 JKS 密钥库

6.3 使用 SSLSocketFactory 进行 HTTPS 请求

6.4 使用 X.509 证书进行身份验证

6.4.1 导入 X.509 证书到 PKCS#12 密钥库

6.4.2 导入 X.509 证书到 JKS 密钥库

7. X.509 和 SHA 的关系及同类算法

7.1 X.509 证书

7.2 SHA (Secure Hash Algorithm)

7.3 关系

7.4 同类算法

7.5 示例

7.5.1 X.509 证书签名

7.5.2 数据完整性校验

8 BKS实现HTTPS通讯示例

8.1 准备工作

Maven 依赖

8.2 生成 BKS 密钥库

8.2.1 使用 OpenSSL 生成私钥和自签名证书

8.2.2 将证书和私钥导入 BKS 密钥库

8.3 加载 BKS 密钥库并配置 SSLContext

8.3.1 创建 BKS 密钥库加载器

8.4 使用 SSLSocketFactory 进行 HTTPS 请求

8.4.1 创建主类并进行 HTTPS 请求

8.5 Provider 的作用

常见的 Provider

如何使用 Provider

示例：使用 Bouncy Castle Provider 进行加密

1. 添加 Bouncy Castle 依赖

2. 使用 Bouncy Castle Provider 进行 RSA 加密和解密

总结

公告

小书童

Android 加密知识详解

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

推荐排行榜