首页 > 其他分享 >Android 加密知识详解

Android 加密知识详解

时间：2024-11-04 11:47:26浏览次数：4  
标签：加密 String java 详解 密钥 Provider import Android security

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

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

1.1 keytool

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

下载方式

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

常用命令

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

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

  2. 查看密钥库内容：

    keytool -list -v -keystore mykeystore.jks

  3. 导出证书：

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

  4. 导入证书：

    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

常用命令

  1. 生成私钥：

    openssl genpkey -algorithm RSA -out private.key

  2. 生成自签名证书：

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

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

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

  4. 查看证书内容：

    openssl x509 -in certificate.crt -text -noout

  5. 生成 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 工具管理。它主要用于存储密钥对（私钥和公钥）和证书。

示例

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

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

  2. 查看密钥库内容：

    keytool -list -v -keystore mykeystore.jks

  3. 导出证书：

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

  4. 导入证书：

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

2.2 PKCS#12 (P12)

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

示例

  1. 生成 PKCS#12 文件：

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

  2. 查看 PKCS#12 文件内容：

    openssl pkcs12 -info -in keystore.p12

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

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

2.3 BKS (Bouncy Castle KeyStore)

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

示例

  1. 生成 BKS 密钥库：

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

  2. 查看 BKS 密钥库内容：

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

3. 签名（Signature）

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

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

示例

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) 密钥库

  1. 生成私钥：

    openssl genpkey -algorithm RSA -out private.key

  2. 生成自签名证书：

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

  3. 生成 PKCS#12 文件：

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

6.1.2 生成 JKS 密钥库

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

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

  2. 导出证书：

    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 密钥库

  1. 生成 PKCS#12 文件：
    openssl pkcs12 -export -out keystore.p12 -inkey private.key -in certificate.crt -name "alias"

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

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

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

  2. 导出证书：

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

  3. 导入外部 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 证书和私钥，你需要生成一个签名：

  1. 生成 X.509 证书：

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

  2. 生成签名：

    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 进行数据完整性校验：

  1. 生成 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 生成私钥和自签名证书

  1. 生成私钥：

    openssl genpkey -algorithm RSA -out private.key

  2. 生成自签名证书：

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

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

  1. 生成 PKCS#12 文件：

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

  2. 将 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 的作用

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

常见的 Provider

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

如何使用 Provider

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

  1. 获取所有已注册的 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());
        }
    }
}

  2. 添加新的 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());
    }
}

  3. 指定 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 开发中的加密需求有所帮助！

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

标签：加密,String,java,详解,密钥,Provider,import,Android,security
From： https://www.cnblogs.com/ruiruizhou/p/18524894

相关文章

  • Android的自定义View和自定义ViewGroup
    Android自定义视图（View）和视图组（ViewGroup）详解在Android开发中，有时候我们需要创建一些标准控件无法满足需求的自定义视图（View）和视图组（ViewGroup）。本文将详细介绍如何创建自定义视图和视图组，包括构造方法、自定义属性、绘制逻辑、测量逻辑、布局逻辑和设置布局参数等内容。1.......
  • Less语法详解：从零开始，轻松掌握Less
    Less是一种动态样式表语言，它扩展了CSS语言，增加了变量、混合（mixins）、函数等特性。Less可以运行在Node或浏览器上，并且可以与各种构建工具无缝集成。本文将对less基础语法进行讲解。一.安装与编译安装Less在开始使用Less之前，需要先安装它。如果使用Node.js，可以通过n......
  • 【链路层】空口数据包详解(1)：LE未编码物理层的数据包格式
    目录一、概述1.1.数据包结构1.2.传输特性二、前导码(Preamble)2.1.功能2.2.长度2.3.位同步2.4.重要性三、接入地址（AccessAddress）3.1.周期性广播序列中的接入地址3.2.其他广播信道数据包的接入地址3.3.链路层状态与接入地址生成3.4.接入地址要求3.5.......
  • 非对称加密：猫咪的双钥匙保护 (＾• ω •＾)
    非对称加密：猫咪的双钥匙保护(＾•ω•＾)在之前的博客中，我们讨论了对称加密算法。这种算法使用单一密钥对数据进行加密和解密，但这也带来了一些问题，例如密钥分发和共享的安全风险。为了解决这些问题，非对称加密（AsymmetricEncryption）应运而生。非对称加密采用了一对密钥：公开密钥（Pub......
  • 【Google Cloud】专用 Google 访问通道的组成和利用方法详解
    专用Google访问通道（PrivateGoogleAccess）允许从没有外部IP的虚拟机访问GoogleCloud服务的API。本文将详细介绍此功能。什么是专用Google访问通道专用Google访问通道（PrivateGoogleAccess）是指在GoogleCloud（原称GCP）中，允许没有外部IP（公网IP）的虚拟机或本地......
  • Oracle OCP认证考试考点详解082系列09
    题记：本系列主要讲解OracleOCP认证考试考点（题目），适用于19C/21C,跟着学OCP考试必过。41.第41题：题目41.ExaminethedescriptionoftheEMPLOYEEStableNLS_DATE_FORMATissettoDD-MON-YYWhichqueryrequiresexplicit_datatypeconversion?A.SELECTjoin_date......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99