Einfache RSA-Verschlüsselung (Java)

Question

Dies ist einfach zum Spaß. Dies wird nicht für eine tatsächliche Verschlüsselung verwendet. Ich bin erst im ersten Jahr comp sci Student und liebe Kryptographie.

Dies dauerte lange, bis es funktionierte. Bei ungefähr N = 18 beginnt es zu brechen. Nach diesem Punkt werden die Nachrichten nicht richtig verschlüsselt. Ich bin mir nicht sicher warum. Irgendwelche Einsichten? Ich würde auch alle Links schätzen, die Sie mir zu Tutorials oder interessanten Lektüren über Kryptographie zur Verfügung stellen könnten.

import java.math.BigInteger; 
import java.security.SecureRandom; 

/** 
* Cryptography. 
* 
* Generates public and private keys used in encryption and 
* decryption 
* 
*/ 
public class RSA 
{ 
    private final static BigInteger one = new BigInteger("1"); 
    private final static SecureRandom random = new SecureRandom(); 

    // prime numbers 
    private BigInteger p; 
    private BigInteger q; 

    // modulus 
    private BigInteger n; 

    // totient 
    private BigInteger t; 

    // public key 
    private BigInteger e; 

    // private key 
    private BigInteger d; 

    private String cipherText; 

    /** 
    * Constructor for objects of class RSA 
    */ 
    public RSA(int N) 
    { 
     p = BigInteger.probablePrime(N/2, random); 
     q = BigInteger.probablePrime(N/2, random); 

     // initialising modulus 
     n = p.multiply(q); 

     // initialising t by euclid's totient function (p-1)(q-1) 
     t = (p.subtract(one)).multiply(q.subtract(one)); 

     // initialising public key ~ 65537 is common public key 
     e = new BigInteger("65537"); 
    } 

    public int generatePrivateKey() 
    { 
     d = e.modInverse(t); 
     return d.intValue(); 
    } 

    public String encrypt(String plainText) 
    { 
     String encrypted = ""; 
     int j = 0; 
     for(int i = 0; i < plainText.length(); i++){ 
      char m = plainText.charAt(i); 
      BigInteger bi1 = BigInteger.valueOf(m); 
      BigInteger bi2 = bi1.modPow(e, n); 
      j = bi2.intValue(); 
      m = (char) j; 
      encrypted += m; 
     } 
     cipherText = encrypted; 
     return encrypted; 
    } 

    public String decrypt() 
    { 
     String decrypted = ""; 
     int j = 0; 
     for(int i = 0; i < cipherText.length(); i++){ 
      char c = cipherText.charAt(i); 
      BigInteger bi1 = BigInteger.valueOf(c); 
      BigInteger bi2 = bi1.modPow(d, n); 
      j = bi2.intValue(); 
      c = (char) j; 
      decrypted += c; 
     } 
     return decrypted; 
    } 
} 

Answer 1

Ihre Verschlüsselung kann trivial gebrochen werden, da Sie nur 2^16 verschiedene Nachrichten haben. RSA ist nur sicher, wenn korrektes Padding (OEP) verwendet wird. Und natürlich benötigt der Chiffretext 100x so viel Platz wie der Klartext, da Sie ein Zeichen einem RSA-Block zuordnen.

j = bi2.intValue(); 
m = (char) j; 

Beide dieser Operationen übermäßig schrecklich. Bi2 ist aus gutem Grund ein BigInteger. Es passt einfach nicht zu einem 32-Bit-Integer/16-Bit-Zeichen. Da beim Abschneiden der Ganzzahl die meisten Bits verloren gehen, funktioniert die Entschlüsselung nicht mehr, da Sie den Chiffretext beschädigt haben.