RSS

Schlagwort-Archive: JAVA

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.

Advertisements
 

Schlagwörter: , ,

JAVA: Einfaches Programm zur grafischen Lösung von Differenzialgleichungen

Die Datei herunterladen: 

Link: Quellcode

Und den Quellcode einfach mit Copy/Paste in eine Java Entwicklungsumgebung (z.B. Eclipse) hineinkopieren. Die Klasse unter “Hauptprogramm” speichern. Es handelt sich nur um ein einfaches Programm. Aber man kann es natürlich zu mehr ausbauen. Verwendung findet das einfache Euler-Verfahren zur numerischen Lösung von Anfangswertproblemen gewöhnlicher Differenzialgleichungen. Der Button <PRINT> zeigt den Graphen der Differenzialgleichung. Der Button <DIFF> zeigt die Stammfunktion angenähert durch das Euler-Verfahren. <RICHT> zeigt eine Schar (n := Integer!) von Stammfunktionen der Differenzialgleichung definiert in dem Intervall y0 bis yn. Die Textfelder dienen zur Eingabe der entsprechenden Grenzen.

Die Verwendung des Codes und der darauf basierenden Programme ist ohne Gewähr und erfolgt auf eigene Verantwortung. Für Schäden aus der Anwendung des Quellkodes und der darauf basierenden Programme übernimmt der Verfasser keine Haftung. So etwas muss heute leider geschrieben werden.

 

Schlagwörter: , , , , , ,

 
%d Bloggern gefällt das: