RSS

Schlagwort-Archive: RSA

RSA – Verschlüsselung in JAVA – Basiscode

Hier gibt es den RSA – Algorythmus in JAVA als Basiscode. Es gibt zwei Versionen:

  1. Bei der ersten Version werden zwei Primzahlen p1 und p2 nacheinander berechnet.
  2. Diese Version berechnet die Primzahlen p1 und p2 parallel. Dies ist dann von Vorteil, wenn Primzahlen mit BIT Größen > 2000 (diese Größe ist hardwareabhängig. Mein Rechner ist bei 2000 BIT noch schnell. Je weniger BIT umso schneller der Algorhytmus) errechnet werden sollen. Solche großen Primzahlen ergeben eine Schlüssellänge von mehr als 4000 BIT. Das macht praktisch vielleicht keinen Sinn, aber es ist ein Spaß, solche Zahlen am Computer zu sehen.

Nr 1:


import java.math.BigInteger;
import java.util.Random;

public class Multi {

public static void main(String[] args) {

final long START=System.currentTimeMillis();

Random rnd = new Random();

rnd.setSeed(2000);
BigInteger p1 = BigInteger.probablePrime( 2500 , rnd );
rnd.setSeed(2000);
BigInteger p2 = BigInteger.probablePrime( 2500 , rnd );

BigInteger e = new BigInteger( „65537“ );

//———————————————————————————————–

BigInteger phi = new BigInteger(p1.subtract(BigInteger.ONE)
.multiply(p2.subtract(BigInteger.ONE))
.toString(10));
BigInteger modul = new BigInteger(p1.multiply(p2)
.toString(10));
BigInteger key = new BigInteger(e.modInverse(phi)
.toString(10));

//———————————————————————————————–

BigInteger nachricht= new BigInteger(„9999999999″);

BigInteger chiffre = new BigInteger(nachricht.modPow(e, modul)
.toString(10));
BigInteger dechiffre= new BigInteger(chiffre.modPow(key, modul)
.toString(10));

//———————————————————————————————–

System.out.println(p1);
System.out.println(p2+“\n“);

System.out.println(„Modul „+modul+“ „+modul.bitLength()+“ BIT“);
System.out.println(„Privater Key „+key);
System.out.println(„\nNachricht „+nachricht+“ Chiffre „+chiffre+“ Dechiffre „+dechiffre);

final long ENDE=System.currentTimeMillis();
System.out.println(„Dauer „+(ENDE – START)+“ ms“);
}
}

import java.math.BigInteger;
import java.util.Random;

public class Mutli {

public static void main(String[] args) {

final long START=System.currentTimeMillis();

Random rnd = new Random();

rnd.setSeed(2000);
BigInteger p1 = BigInteger.probablePrime( 2500 , rnd );
rnd.setSeed(2000);
BigInteger p2 = BigInteger.probablePrime( 2500 , rnd );

BigInteger e = new BigInteger( „65537“ );

//———————————————————————————————–

BigInteger phi = new BigInteger(p1.subtract(BigInteger.ONE)
.multiply(p2.subtract(BigInteger.ONE))
.toString(10));
BigInteger modul = new BigInteger(p1.multiply(p2)
.toString(10));
BigInteger key = new BigInteger(e.modInverse(phi)
.toString(10));

//———————————————————————————————–

BigInteger nachricht= new BigInteger(„9999999999″);

BigInteger chiffre = new BigInteger(nachricht.modPow(e, modul)
.toString(10));
BigInteger dechiffre= new BigInteger(chiffre.modPow(key, modul)
.toString(10));

//———————————————————————————————–

System.out.println(p1);
System.out.println(p2+“\n“);

System.out.println(„Modul „+modul+“ „+modul.bitLength()+“ BIT“);
System.out.println(„Privater Key „+key);
System.out.println(„\nNachricht „+nachricht+“ Chiffre „+chiffre+“ Dechiffre „+dechiffre);

final long ENDE=System.currentTimeMillis();
System.out.println(„Dauer „+(ENDE – START)+“ ms“);
}
}


Nr 2:


import java.math.BigInteger;
import java.util.Random;

public class Multithread {

static BigInteger p1 = new BigInteger(„0“);
static BigInteger p2 = new BigInteger(„0“);

public static void main(String[] args) throws InterruptedException {

final long START=System.currentTimeMillis();

Thread t1 = new Thread ( new Number1() );
t1.start();

Thread t2 = new Thread ( new Number2() );
t2.start();

t1.join();
t2.join();

p1 = new BigInteger(Number1.zahl.toString(10));
p2 = new BigInteger(Number2.zahl.toString(10));

BigInteger e = new BigInteger( „65537“ );

BigInteger phi = new BigInteger(p1.subtract(BigInteger.ONE) .multiply(p2.subtract(BigInteger.ONE)) .toString(10));

BigInteger modul = new BigInteger(p1.multiply(p2)
.toString(10));

BigInteger key = new BigInteger(e.modInverse(phi)
.toString(10));

BigInteger nachricht = new BigInteger(„9999999999″);
BigInteger chiffre = new BigInteger(nachricht.modPow(e, modul) .toString(10));
BigInteger dechiffre= new BigInteger(chiffre.modPow(key, modul) .toString(10));

System.out.println(p1);
System.out.println(p2+“\n“);

System.out.println(„Modul „+modul+“ „+modul.bitLength()+“ BIT“);
System.out.println(„Privater Key „+key);
System.out.println(„\nNachricht „+nachricht+“ Chiffre „+chiffre+“ Dechiffre „+dechiffre);

final long ENDE=System.currentTimeMillis();
System.out.println(„Dauer „+(ENDE – START)+“ ms“);
}
}

class Number1 implements Runnable
{
static Random rnd = new Random();
static BigInteger zahl = new BigInteger(„0“);

@Override public void run()
{
rnd.setSeed(2000);
zahl = BigInteger.probablePrime(2500, rnd);
}
}

class Number2 implements Runnable
{

static Random rnd = new Random();
static BigInteger zahl = new BigInteger(„0“);

@Override public void run()
{
rnd.setSeed(2000);
zahl = BigInteger.probablePrime(2500, rnd);
}
}


Anmerkungen:

  • Die zweite Version ist bei großen Primzahlen nicht ganz doppelt so schnell, wie die erste.
  • Im Code sind rnd.seeds gesetzt, mit dem immer gleichen Wert von 2000. Dies dient dazu, dass immer wieder die gleiche Zufalls(Prim)zahl berechnet wird. Dadurch werden beide Versionen miteinander vergleichbar.
  • In diesen Beispielen werden Primazahlen mit 2.500 BIT Länge erzeugt. Das braucht auf meinem Recher bei Nr. 1 ca. 3,5 sec. Nr. 2 braucht 1,9 sec. (Vorsicht bei zu großer Bit Länge 😉 )

Wenn jemandem was hier zu einfällt, bitte mitteilen und viel Spaß ….

PS: Bitte niemals mit RSA-only eine reine Textverschlüssung durchführen. RSA ist ein asymetrisches Verschlüsselungsverfahren und vermeidet den Schlüsselaustausch bei symetrischen Verfahren. Deswegen werden Texte in der Praxis mit RSA in Kombination mit sysmetrischen Verfahren eingesetzt (z.B. AES).

Ich hafte nicht für die Anwendung dieses Codes. Es ist nur ein Muster.

 

Schlagwörter: , ,

 
%d Bloggern gefällt das: