cifrado asimétrico

El algoritmo de cifrado asimétrico también se llama algoritmo de cifrado moderno. El cifrado asimétrico es la piedra angular de la seguridad de las comunicaciones informáticas y garantiza que los datos cifrados no se descifren.
A diferencia de los algoritmos de cifrado simétrico, los algoritmos de cifrado asimétrico requieren dos claves: clave pública (publickey) y clave privada (privatekey)
Una clave pública y una clave privada son un par. Si los datos se cifran con una clave pública, solo se pueden descifrar con la clave privada correspondiente. Si los datos se cifran con una clave privada, solo se pueden descifrar con la clave pública correspondiente.
Debido a que el cifrado y el descifrado utilizan dos claves diferentes, este algoritmo se denomina algoritmo de cifrado asimétrico.

características
- El cifrado y el descifrado utilizan claves diferentes
- Si se cifra con la clave privada, solo se puede descifrar con la clave pública
- Si se cifra con la clave pública, solo se puede descifrar con la clave privada
- El procesamiento de datos es más lento debido al alto nivel de seguridad

ejemplo
1. Primero genere un par de claves, la clave pública es (5,14), la clave privada es (11,14), A quiere enviar el texto original 2 a B
2. A utiliza la clave pública para cifrar los datos. 2 a la quinta potencia mod 14 = 4, envía el texto cifrado 4 a B
3. B usa la clave privada para descifrar los datos 4 a la 11 potencia mod14 = 2, obtener el texto original 2

1 Algoritmos Comunes

RSA
- RSA fue propuesto en 1977 por Ronald Rivest (Ron Rivest), Adi Shamir (Adi Shamir) y Leonard Adleman (Leonard Adleman).
- El criptosistema de clave pública RSA es un tipo de uso de clave de cifrado y clave de descifrado diferentes.
- RSA puede resistir la gran mayoría de los ataques criptográficos conocidos hasta ahora y ha sido recomendado por ISO como un estándar de cifrado de datos de clave pública. Solo las claves RSA cortas pueden descifrarse por fuerza bruta. Todavía no existe una forma confiable de atacar el algoritmo RSA en el mundo. Siempre que la longitud de la clave sea lo suficientemente larga, la información cifrada con RSA no se puede descifrar.
- El algoritmo RSA se basa en un hecho de teoría de números muy simple: es muy fácil multiplicar dos números primos grandes, pero es extremadamente difícil factorizar el producto, por lo que el producto puede hacerse público como una clave de cifrado.
- Herramientas en línea de RSA
- Amigos que deseen obtener más información sobre RSA, pasen al algoritmo RSA de cifrado de clave pública
ECC (criptografía de curva elíptica)
- Criptografía de curva elíptica (ECC), un algoritmo para construir criptografía de clave pública, basado en las matemáticas de las curvas elípticas. El uso de curvas elípticas en criptografía fue propuesto de forma independiente por Neal Koblitz y Victor Miller en 1985.
- Amigos que deseen obtener más información sobre ECC, pasen a la explicación detallada del principio de cifrado y descifrado de curva elíptica ECC (con imágenes)

2 Generar claves públicas y privadas

    public static void main(String[] args) throws NoSuchAlgorithmException {
    
    
        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 获取公钥字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        // 对公私钥进行base64编码
        String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
        String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
        // 打印私钥
        System.out.println("私钥:"+privateKeyString);
        // 打印公钥
        System.out.println("共钥:"+publicKeyString);
    }

私钥:MIIG/QIBADANBgkqhkiG9w0BAQEFAASCBucwggbjAgEAAoIBgQC6hpkMQs+D0XefTNESooz3Cauz8Tpl7NaHKm3X8ZrqLO/QfCqW2ZoozlkXFi7nzNwPQ
BfEv1VgXhiT5VOy+r24Lcc3oakNtSWXYuBoXraJXdpE7EqVKdPSZbxzT3OhSQ0QqX3F2Y19euz5RB8jD9GBEJ+VHTnBKIpugX4irCWj1TYKbB8XGbH85wcWG
4uH2kn41DqM8IPw9TTDpMoyW7BEHShulOS+7G1Nd7rrtaf0tCyk9bVdms9Ou+JzKWRfCQFxuEH1sWvijW4R83OQYfpGa2kvJgiUQP0O9TQCmp0+ImWiThWfY
biqrFyJVynIDko8mFXXWolmdfq1myuNg126sUe1wPmZhtIC595hp965K8bwTiSg8weuSXOkAXJ7Cr4OLCOimSrB4qdLueqjAhMcQWuHXbGZCqnrbtOFmzxxR
NH8TWjhyPvtXldf7bK0CQaSuE2kfAi7YKwBwzI8iAbVomYh7EdVvMHq/YlwEPg8DqcuAJODaqcnZsy7omKuZWcCAwEAAQKCAYAIQ96URIGdfbKnRGgfQ0Srz
anmF1JXId9/rcmgP/x1U/hsbJQWix3hoQMhmsIJU3KM2nIzLadC1eiQ5SCIVcQCXUTumiM7kENSKfd3qHq+K4J4e1/yrB/OuuNW2LZu9yW1D02bbsBuRvwpL
3ORwimuZmYr3Vepz3oS23oTXz1rvQ7f91qJU4InirUtrZrJMksE06KkjCPMkZD8+lhbUuTEn+YiwEZCj4doX13RBAOlPDaeOKUIuMtm2bx3DeZ8r5Flbhas9
n3/OELgIgJ6omKaipgHdWTVkaowbCZcJsUUoKyjQNHRZ4ae/0ie1I4IvhS9hml+8gcuPOu+kVpNyYvmUZZQoPFv9QaVyL16OSgGR80/7k4/JB3a7SldbEKqY
Gasij3B8Agq0oXOY2oV5srs/wsum+HxzdKEFhAd+7YIYtxx82LzNes8NUg32NxaNMvoO2OqmSDqZo1Mu5lQBYWo/pPKJPxoT2oq2+9hAVgimvaUm1PoUEu2W
/H6lOOKdQECgcEA0QtPgKtJc0LCxLInXBl286tspYPSbToGuBJe7/IVQjWlCEs0quX8xUcFeRAUSIDPGtKHfgVQoLd6XuizXvPYwHaJdgc/mqPyoyMhYwPQy
Kr3njwDNLbI0jZTZVnz1iGEujYFbOCAsZraJLqgSeofxQHJNwy1v+DJj+6pn1k4rLjNrrRPgn8JdpCV9RttZ0xIZWpxYUO6z+wYvWLd8MXaGBT0UQcMK0Wh2
hCT5XVOJ0RjucQ0dsq+xnQz6eSnpmDRAoHBAORsaKrfFfE1U9Foj39Qg5gcJUKh1UYwl6dt3utrETSKnP5g7t0XlqYcB4nTs7V+MA8ooAlUroXpWIm62v2PX
ugda4qLtEZAF4uNcUX9a8kGfj4Cxqw0DCrLhN2KkoLKGdyyNoZQGqZCGqXU70G+UBkDrGTZwBt55GurhISZHBb7BJWL+Q4cPnEdwxSwDJxT1E0aCN6na+8HS
laiFp8UL7Ewox5nHzHizsOEYx9ZRZb8Owd2J7hUzEm0ga0rNRgwtwKBwQDFgco755oeLJWZAjnt6qFY2D5uo33NdWWjxLeuPSuYwtaKX4QDdAi+27twBqEjX
5BN51vc1Wi4cKJNyc6vh/Ti4xw9R9vwX7aALFD/HDvHXMFX35un0osrEej5eWPIjSK6TRATLoppQ8WXrjyDmZEqseVK/dc600edlgDtbX7+shyjU/lLcnuea
j1EuAVF8+zy5P76xuNaT9eQGDlZo5XL6wBrDh2RRNkHD2KtCYgt0Y/nlFl9Y1Gcb24dLsy3hgECgcBUX/cJpv3j617aq1TWIld5iGv7AOxW0PwzzFHbg+EHF
2yGSifxYxUypofiUWDAWaxG7SqwR6dvr5IUzgC2SI82Dif7NT+R83q/AbAlukZmKw/WuA/K7C7SX/rkGpuj1CNZcjrRwiUV5LUTLGR0VGgh1UmItyZO/+dwH
hsFH8lQc8httRZ6L9Sg0+2LZrxBwnVZRZShKhakZH0BIz5X5Iz5Vo3qXQ0Y0D6v2ecDXWZnLyRezTY+0JPlZdfAr4UdOmECgcAYsuA5t2keukkeAR7qDZYsy
stVIEsXujmevjPTlMHJxRySa5jpWzTeCqQS4zKpnu0ayogTCyUSYgGTYsYPYigAhr67dcQHzy95d9wF0bv0B9BYZmTYoHC4ThrElX1DPkYFU1JJjPS+BhNID
GTK+vH4wZFFWHm8Fyhmgvexo4A6/yxAZWykDwBKG9NUDN/AoqUfJFcmRCD616Bt4FoNlzk7mfLg92W61pywvHQ+uxCuFWqwFVfUUInLJ6pfPvdm7u0=

共钥:MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAuoaZDELPg9F3n0zREqKM9wmrs/E6ZezWhypt1/Ga6izv0HwqltmaKM5ZFxYu58zcD0AXxL9VY
F4Yk+VTsvq9uC3HN6GpDbUll2LgaF62iV3aROxKlSnT0mW8c09zoUkNEKl9xdmNfXrs+UQfIw/RgRCflR05wSiKboF+Iqwlo9U2CmwfFxmx/OcHFhuLh9pJ+
NQ6jPCD8PU0w6TKMluwRB0obpTkvuxtTXe667Wn9LQspPW1XZrPTrvicylkXwkBcbhB9bFr4o1uEfNzkGH6RmtpLyYIlED9DvU0ApqdPiJlok4Vn2G4qqxci
VcpyA5KPJhV11qJZnX6tZsrjYNdurFHtcD5mYbSAufeYafeuSvG8E4koPMHrklzpAFyewq+DiwjopkqweKnS7nqowITHEFrh12xmQqp627ThZs8cUTR/E1o4
cj77V5XX+2ytAkGkrhNpHwIu2CsAcMyPIgG1aJmIexHVbzB6v2JcBD4PA6nLgCTg2qnJ2bMu6JirmVnAgMBAAE=

3 cifrado de clave privada

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
    
    
        String input = "国泰民安";
        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();

        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        System.out.println(Base64.encodeBase64String(bytes));
    }

gjfiD1F+DOFk2IHqrTWSKe+8qGLCihNuu+RrZY6CKji0H56RUhSL3P5fW2X3FXpCrY+CMsGg16HfmR3boeX1qY4e0NJU0JtE1Ch4uERigH1eM/MUCUaFaVI4
9roDAcqbz0v+lnsX41mOCQ4YSd742XoIg7cJX1GcsHhkXDF3JCM/fDxdHYR63ApmSpzr+qfoelntnc+Xah90i3UR/PPiEZ6/6JWz7mU5DK/X5IVnqgGObNCl
syH7tWcwl34IcrszFvK4ovtxeYVQken7IHgW8LMCxWGXWyDThC+9A/d9AV9vlLLuzZcYEvRYMS5BzZqr9gzdrgYE1hsRouFQ0yyuOUoVAbaqAjqhPRTTIj0E
QUl2PpB7hi561x/j/58w9dsoI3gKp/G6SBl40yyuxbm5z/RGYxjeZhyIC4Lm/ddpCQpJ5qzZ/WX6N9fSqjwQLaHSQpgmsy5zdZRkZchxknw8LgONSzObwA5/
F561oXgtHWD44+SzZHoOGY3hDSU3oKMT

4 cifrado de clave privada descifrado de clave pública

Cifrado de clave privada, solo descifrado de clave pública

public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
    
    
        String input = "国泰民安";
        System.out.println(input);
        // 加密算法
        String algorithm = "RSA";
        //  创建密钥对生成器对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 生成公钥
        PublicKey publicKey = keyPair.getPublic();

        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        System.out.println(Base64.encodeBase64String(bytes));

        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println(new String(bytes1));
    }

国泰民安
VfUXV9TiXxeRx5/gq13GtsNm76BSw/63e1SaOI1szLnb9DjE4hfCmim0qqqOQYSp5fyE45694Dlj37p7/+eu7gMAuJN5PYZfN7bYQZ+ZIJeXCiEO/IWXFzQW
yIgoyqUjZ1i6ja0yfHhY0FXkBBJCr2SNwBiMW1lEQav0UE/i05Dj3+OOKDTKNbIgMLcsZfM3WPSNJWJq7bthnjO0KTPSdG5Dl+/eJictaSGTk0it5+D1l4G6
N8CfTfshG9c3vWbfmqgmU8GaA5Iqo1eHINPpS9SZOoAAokGEzmDkx2VJQiQO3GELIdcCGvyWvZIm7PlAV8EYzxTQiHRSuwiCJyGGABC+I9iEFwDaZwYCTAh7
roSwtpt1ax/KgQfbhv8vNE+/3ADnnvFgzDX6LfWuSl0vhclh9kl0ECnIICJd6dxKwCAZkctiwdOoPrbGnK4lWXbeTbdkxBpdw9LcnWMkCuCVy53k47OjB3S+
t+Uktr2snJAjJDYG4ZZmrQpEIj17zLKZ
国泰民安

5 Guardar y leer la clave pública y la clave privada

5.1 Guardar la clave pública y la clave privada

public static void main(String[] args) throws Exception {
    
    
        String input = "硅谷";
        // 加密算法
        String algorithm = "RSA";

        //生成密钥对并保存在本地文件中
        generateKeyToFile(algorithm, "a.pub", "a.pri");


    }

    /**
     * 生成密钥对并保存在本地文件中
     *
     * @param algorithm : 算法
     * @param pubPath   : 公钥保存路径
     * @param priPath   : 私钥保存路径
     * @throws Exception
     */
    private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
    
    
        // 获取密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 获取密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 获取byte数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 进行Base64编码
        String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
        String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
        // 保存文件
        FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
        FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));

    }

5.2 Leer claves públicas y privadas

public static void main(String[] args) throws Exception {
    
    
        String input = "明德新民，止于至善";
        // 加密算法
        String algorithm = "RSA";

        //生成密钥对并保存在本地文件中
        generateKeyToFile(algorithm, "a.pub", "a.pri");
        //读取私钥
        PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
        //读取公钥
        PublicKey publicKey = getPublicKey("a.pub", algorithm);

        String s = encryptRSA(algorithm, privateKey, input);
        String res = decryptRSA(algorithm, publicKey, s);
        System.out.println(res);
    }

    /**
     * 解密数据
     *
     * @param algorithm      : 算法
     * @param encrypted      : 密文
     * @param key            : 密钥
     * @return : 原文
     */
    public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
    
    
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 私钥进行解密
        cipher.init(Cipher.DECRYPT_MODE,key);
        // 由于密文进行了Base64编码, 在这里需要进行解码
        byte[] decode = Base64.decodeBase64(encrypted);
        // 对密文进行解密，不需要使用base64，因为原文不会乱码
        byte[] bytes1 = cipher.doFinal(decode);
        return new String(bytes1);

    }
    /**
     * 使用密钥加密数据
     *
     * @param algorithm      : 算法
     * @param input          : 原文
     * @param key            : 密钥
     * @return : 密文
     */
    public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
    
    
        // 创建加密对象
        // 参数表示加密算法
        Cipher cipher = Cipher.getInstance(algorithm);
        // 初始化加密
        // 第一个参数:加密的模式
        // 第二个参数：使用私钥进行加密
        cipher.init(Cipher.ENCRYPT_MODE,key);
        // 私钥加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        // 对密文进行Base64编码
        return Base64.encodeBase64String(bytes);
    }

    public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
    
    
        // 将文件内容转为字符串
        String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyString));
        // 生成公钥
        return keyFactory.generatePublic(spec);
    }

    /**
     * 生成密钥对并保存在本地文件中
     *
     * @param algorithm : 算法
     * @param pubPath   : 公钥保存路径
     * @param priPath   : 私钥保存路径
     * @throws Exception
     */
    private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
    
    
        // 获取密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        // 获取密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥
        PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        PrivateKey privateKey = keyPair.getPrivate();
        // 获取byte数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        byte[] privateKeyEncoded = privateKey.getEncoded();
        // 进行Base64编码
        String publicKeyString = Base64.encodeBase64String(publicKeyEncoded);
        String privateKeyString = Base64.encodeBase64String(privateKeyEncoded);
        // 保存文件
        FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
        FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));

    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
    
    
        // 将文件内容转为字符串
        String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
        // 获取密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        // 构建密钥规范 进行Base64解码
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyString));
        // 生成私钥
        return keyFactory.generatePrivate(spec);
    }

inserte la descripción de la imagen aquí

Criptografía [java] Una exploración inicial del cifrado asimétrico en los métodos de cifrado

Directorio de artículos

cifrado asimétrico

1 Algoritmos Comunes

2 Generar claves públicas y privadas

3 cifrado de clave privada

4 cifrado de clave privada descifrado de clave pública

5 Guardar y leer la clave pública y la clave privada

5.1 Guardar la clave pública y la clave privada

5.2 Leer claves públicas y privadas

Supongo que te gusta