Download:
Stellen.java

10^k ≤ 2¹⁰²⁴ ≤ 10^k+1

dann hat die Zahl zwischen k+1 und k+2 Stellen (führende Ziffer ≥ 1). Wir lösen:

k log₂10 ≤ 1024 und damit

k ≤ 1024 (lg2 / lg10) = 1024 lg2 ≈ 308,3

Die Zahl hat also 309 Stellen mit mindestens einer führenden 1.

Die exakte Zahl 2¹⁰²⁴ ist

1797693134862315907729305190789024733617976978942306572734
3008115773267580550096313270847732240753602112011387987139
3357658789768814416622492847430639474124377767893424865485
2763022196012460941194530829520850057688381506823424628814
7391311054082723716335051068458629823994724593847971630483
5356329624224137216.

Sie wurde mit einem kleinen Java-Programm berechnet. Das Programm gibt auch die Anzahl der Stellen aus, nämlich 309. Die Ergebnisse machen zweierlei deutlich:

• Da eine sichere RSA-Verschlüsselung große Blöcke verlangt, muss auch n sehr groß sein. Damit steigt der Rechenaufwand.
• Es werden viele große Primzahlen benötigt, denn jeder der RSA-verschlüsselte  Nachrichten empfangen will, benötigt sein eigenes Primzahlpärchen. Woher also die Primzahlen nehmen?

m = c^d mod n = 25⁵ mod 391 = 9

hat sie die Botschaft entschlüsselt.
 

Download:
PrimzahlErzeuger.
java

628171751
798446651
501561630838755901

Die Zerlegung des Produktes mit dem Primzerleger-Programm (s. o.) bestätigt, dass es sich bei den Zufallszahlen tatsächlich um Primzahlen gehandelt hatte. Die Zerlegung benötigt geraume Zeit und das bei einem Produkt aus zwei nur 9-stelligen Primzahlen. Wie mit der Größe der Primzahlen die Chance in vernünftigen Zeiten eine Zerlegung und damit eine RSA-Entschlüsselung zu schaffen, schwinden, ist dadurch eindringlich demonstriert. Diese Aussage bleibt richtig, auch wenn man effektivere Algorithmen zum Zerlegen in Primfaktoren benutzt.

[zurück]
 

public class Schluessel {



  private long n = 0, e = 0, d = 0, z = 0, p = 0, q = 0;

  

  public Schluessel(){

    erzeugeN();

    erzeugeE();

    erzeugeD();

  }



  private void erzeugeN(){

    String zahl;

    do{

      p = Mathematik.erzeugePrim(0,15000);

      q = Mathematik.erzeugePrim(0,15000);

      n = p*q;

      zahl = ""+n;

    } while (zahl.length()!= 9);

    z = (p-1)*(q-1);

  }

  private void erzeugeE(){

    e = (long)(500*Math.random()+600);  

    while(Mathematik.ggT(e,z) != 1){

      e++;

    }

  }

  private void erzeugeD(){

    int k = 1;

    do{

      k++;

    } while ((k*z+1)%e != 0);

    d = (k*z+1)/e;

  }



  public long getP(){return p;}

  public long getQ(){return q;}

  public long getZ(){return z;}

    

  public long getN(){return n;}

  public long getE(){return e;}

  public long getD(){return d;}

}

  public static int erzeugePrim(int u, int o){

    int a;

    do{

      a = (int) ((o-u)*Math.random()+u);

    } while (!prim(a));

    return a;

  }



  public static boolean prim(int a){

    boolean ergebnis = true;

    for (int i = 2; i < Math.sqrt(a); i++){

      if (a%i == 0){

        ergebnis = false;

      }

    }

     return ergebnis;

  }

Kommen wir zur Klasse RSA32bitEnCrypt; sie besitzt nur eine Methode, nämlich das Verschlüsseln eines übergebenen Originaltextes nach der Methode RSA mit Hilfe der ebenfalls übergebenen öffentlichen Schlüssels.
 

import java.math.*; 



public class RSA32bitEnCrypt {

 

  public static String rsaEnCrypt(String originalText, 

                                  int n, int e){

    originalText = originalText.toUpperCase();

    String geheimText = "";  

    BigInteger nBig = new BigInteger(""+n);

    BigInteger eBig = new BigInteger(""+e);  

    long m;  

    BigInteger mBig;  

    if (originalText.length()%4==1){

      originalText = originalText + "   ";

    }

    if (originalText.length()%4==2){

      originalText = originalText + "  ";

    }

    if (originalText.length()%4==3){

      originalText = originalText + " ";

    } 

    for (int i = 0; i < originalText.length();){

      m = (int)originalText.charAt(i++)*1000000;

      m += (int)originalText.charAt(i++)*10000;

      m += (int)+originalText.charAt(i++)*100;

      m += (int)+originalText.charAt(i++);

      mBig = new java.math.BigInteger(""+m);

      String cText = ""+mBig.modPow(eBig,nBig);

      int differenz = 9 - cText.length();

      for (int j = 0; j < differenz; j++){

        cText = "0"+cText;

      }

      geheimText += cText;

    }

    return geheimText;

  }

}

import java.math.*; 





public class RSA32bitDeCrypt {

  public static String rsaDeCrypt(String geheimText, 

                                  int n, int d){



    int c;         

    int m;  

    String originalText = "";  

    BigInteger nBig = new BigInteger(""+n); 

    BigInteger dBig = new BigInteger(""+d);              

    BigInteger cBig;                          



    for (int i = 0; i < geheimText.length(); i += 9) {

      c = Integer.parseInt(geheimText.substring(i,i+9)); 

      cBig = new java.math.BigInteger(""+c); 

      m = cBig.modPow(dBig,nBig).intValue(); 

      int ascii1 =  m/1000000;                            

      m = m%1000000;                                      

      int ascii2 = m/10000;                               

      m = m%10000;

      int ascii3 = m/100;                                 

      m = m%100;                                          

      originalText = originalText + 

            (char)ascii1 + (char)ascii2 + (char)ascii3 + (char)m;

    }

    return originalText;

  }

}