Algorithme RSA (chiffrement et déchiffrement)

Introduction à l'algorithme RSA:

        L'algorithme RSA est l'algorithme de chiffrement RSA, qui est un algorithme de chiffrement asymétrique . RSA est largement utilisé dans le chiffrement à clé publique et le commerce électronique . RSA 1977 par le Ronald Rivest (Ron Rivest), Adi Shamir (Adi Shamir) et Leonard Adleman (Leonard Adleman) présenté ensemble. RSA est composé des lettres des trois. En 1973, Clifford Cocks, un mathématicien travaillant au siège des communications du gouvernement britannique , a proposé un algorithme identique dans un document interne, mais ses conclusions ont été classées confidentielles jusqu'en 1997. Publiez. RSA est maintenant un algorithme de cryptage à clé publique très influent. Il peut résister à la plupart des attaques cryptographiques connues. Il a été recommandé par l'ISO comme norme de cryptage des données à clé publique. Depuis 2008, il n'existe aucun moyen fiable d'attaquer l'algorithme RSA dans le monde. Tant que la longueur de la clé est suffisamment longue, les informations chiffrées avec RSA ne peuvent pas réellement être brisées. 

Vitesse:

Parce que tous les calculs sont de grands nombres, la situation RSA la plus rapide est plusieurs fois plus lente que DES, qu'elle soit implémentée en logiciel ou en matériel. La vitesse a toujours été un inconvénient de RSA. Généralement utilisé uniquement pour une petite quantité de chiffrement de données. La vitesse de RSA est environ 1000 fois plus lente que l'algorithme cryptographique symétrique correspondant au même niveau de sécurité.

Sécurité:

La sécurité de RSA dépend de la décomposition de grands nombres, mais si elle est équivalente à la décomposition de grands nombres n'a pas été théoriquement prouvée, car il n'y a aucune preuve que la décomposition de RSA nécessite une décomposition de grands nombres. Supposons qu'il existe un algorithme qui n'a pas besoin de décomposer de grands nombres, alors il peut certainement être modifié en un algorithme de décomposition de grands nombres. Certaines variantes de RSA se sont avérées équivalentes à une décomposition en grand nombre. Dans tous les cas, la factorisation n est la méthode d'attaque la plus évidente. Les gens ont pu résoudre de grands nombres premiers avec plusieurs décimales . Par conséquent, le module n doit être choisi plus grand, en fonction de l'application spécifique.

                                                                                                                                                               ------ Le contenu ci-dessus est tiré de l'Encyclopédie Sogou

Implémentation du code:

package com.huadian.encrytionanddecrytion; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.util.Scanner; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.KeyGenerator; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec;

classe publique RSA { / ** * 加密 * * @param content * 需要 加密 的 内容 * @param password * 加密 密码 * @return * / public static byte [] encrypt (String content, String password) { try { KeyGenerator kgen = KeyGenerator.getInstance ("AES"); kgen.init (128, nouveau SecureRandom (password.getBytes ())); SecretKey secretKey = kgen.generateKey (); byte [] enCodeFormat = secretKey.getEncoded (); SecretKeySpec key = nouveau SecretKeySpec (enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance ("AES"); // 创建 密码 器 octet [] byteContent = content.getBytes ("utf-8"); cipher.init (Cipher.ENCRYPT_MODE, clé); // 初始化 octet [] résultat = cipher.doFinal (byteContent); résultat de retour; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace (); } catch (NoSuchPaddingException e) { e.printStackTrace (); } catch (InvalidKeyException e) { e.printStackTrace (); } catch (UnsupportedEncodingException e) { e.printStackTrace (); } catch (IllegalBlockSizeException e) { e.printStackTrace (); } catch (BadPaddingException e) { e.printStackTrace (); } return null; }

/** * 解密 * * @param content * 待解密内容 * @param password * 解密密钥 * @return */ public static byte[] decrypt(byte[] content, String password) { try { KeyGenerator kgen = KeyGenerator.getInstance("AES"); kgen.init(128, new SecureRandom(password.getBytes())); SecretKey secretKey = kgen.generateKey(); byte[] enCodeFormat = secretKey.getEncoded(); SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES"); Cipher cipher = Cipher.getInstance("AES");// 创建密码器 cipher.init(Cipher.DECRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(content); return result; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return null; }

/** * 将二进制转换成16进制 * * @param buf * @return */ public static String parseByte2HexStr(byte buf[]) { StringBuffer sb = new StringBuffer(); for (int i = 0; i < buf.length; i++) { String hex = Integer.toHexString(buf[i] & 0xFF); if (hex.length() == 1) { hex = '0' + hex; } sb.append(hex.toUpperCase()); } return sb.toString(); }

/** * 将16进制转换为二进制 * * @param hexStr * @return */ public static byte[] parseHexStr2Byte(String hexStr) { if (hexStr.length() < 1) return null; byte[] result = new byte[hexStr.length() / 2]; for (int i = 0; i < hexStr.length() / 2; i++) { int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16); int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16); result[i] = (byte) (high * 16 + low); } return result; }

/** * 加密 * * @param content * 需要加密的内容 * @param password * 加密密码 * @return */ public static byte[] encrypt2(String content, String password) { try { SecretKeySpec key = new SecretKeySpec(password.getBytes(), "AES"); Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding"); byte[] byteContent = content.getBytes("utf-8"); cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化 byte[] result = cipher.doFinal(byteContent); return result; // 加密 } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (InvalidKeyException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (IllegalBlockSizeException e) { e.printStackTrace(); } catch (BadPaddingException e) { e.printStackTrace(); } return null; }

public static void main(String[] args) throws UnsupportedEncodingException { System.out.println("请输入要加密的内容和密码"); System.out.println("请输入要加密的密码"); Scanner scanner = new Scanner(System.in); String content = scanner.next(); String password = scanner.next(); // String content = "我是shoneworn"; // String password = "12345678"; // 加密 System.out.println("加密前：" + content); byte[] encode = encrypt(content, password); //传输过程,不转成16进制的字符串，就等着程序崩溃掉吧 String code = parseByte2HexStr(encode); System.out.println("密文字符串：" + code); byte[] decode = parseHexStr2Byte(code); // 解密 byte[] decryptResult = decrypt(decode, password); System.out.println("解密后：" + new String(decryptResult, "UTF-8")); //不转码会乱码 } }