RSA - Verfahren

[aknayirp]

Moin,

habe gerade das RSA-Verfahren soweit fertig implementiert, aber beim Enkodieren kommt leider nicht das richtig raus.

Hier der Quellcode:

public class RSA {
	
	private double p, q, n, c, e, d;
	
        //2 Primzahlen werden dem Konstruktor übergeben und n und c werden gesetzt
	public RSA(double p, double q){
		this.p = p;
		this.q = q;
		this.n = p * q;
		this.c = (p-1)*(q-1);
	}
	
        //e soll gefunden werden mit der Bedingung ggt(e,c) = 1
        //da e irgendein zahl sein kann beginnt ich bei 2 und addiere immer 1 hinzu  
	public void findE(){
		GGT test = new GGT();
		double e_lokal = 0;
		double h = 1;
		while(e_lokal != 1){
			h = h+1;
			e_lokal = test.teiler(h, c);
		}
		e = h;
	}
	
        //d soll über den erweiterten euklidischen algorithmus gefunden werden und die Implementation habe ich mir
        //aus dem Internet geholt. Daher bin ich mir nicht zu 100% sicher, ob das so richtig ist.
        public void findd(){
		double x = e;
		double b = c;
		int s,s2,t1,s1,t,t2,temp=1,g,r,y; 
	    s=s2=t1=0; 
	    s1=t=t2=1; 
	    y=(int) b; 
	    while(temp!=0) 
	    { 
	        g=(int)x/y; 
	        r=(int)x%y; 
	        s=s1-g*s2; 
	        t=t1-g*t2; 
	        s1=s2; 
	        s2=s; 
	        t1=t2; 
	        t2=t; 
	        x=y; 
	        y=r; 
	        temp=(int)x%y; 
	    } 
	    if (s<0) s+=b; 
	    d = s; 	    
	}

        //Ich denke mir das hier eventuell ein Fehler liegt. Da math.pow(w,e) eine sehr große Zahl ist und dadurch 
        //was falsches rauskommt!?
	public double V(char ver){
		double w = (double) ver;
		return (Math.pow(w, e)%n);
	}
	
        //so wie verschlüsselung wird auch entschlüsselung durchgeführt
	public char E(double ent){
		double w = Math.pow(ent, d)%n;
		return ((char) w);
	}
	
	public static void main(String args[]){
		RSA test = new RSA(7,11);
		test.findE();
		double ver = test.V('a');
		test.findd();
		char ent = test.E(ver);
		
		System.out.println("Verschlüsselung = " + ver);
		System.out.println("Entschlüsselung = " + ent);
		
		double e = test.gete();
		double d = test.getd();
		
		System.out.println("e = " + e);
		System.out.println("d = " + d);			
	}	
}

Ich hoffe die obigen Kommentare reichen aus als Beschreibungen. Auf jeden Fall kommt beim Zeichen a ein + raus...

MFG
Aknayirp

 

[aknayirp]

Moin,

also ich nehme einmal an, dass ich in der Memberfunktion V und E mit BigInteger hantieren muss, um die große Zahl zu handeln.
Leider funktioniert es trotzdem nicht und ich habe mir mal ein Beispie überlegt um einfach mal zu schauen, wie das funktionieren sollte.
Beispiel: Primzahlen p=7 und q=11 ; n = 77 ; c = 60 ; e = 47 ; d = 23
Jetzt möchte ich ein char Verschlüsseln und Entschlüsseln. Ich nehme jetzt ein 'a', was eine 97 ist. Dementsprechend wende ich nun die Verschlüsselungsfunktion an: 97^47 mod 77 und es kommt 48 heraus.
Wenn ich nun wieder entschlüsseln möchte, dann muss ich ja die 48 nehmen und an die Funktion anwenden: 48^23 mod 77. Ich hätte jetzt eigentlich erwartet, dass wieder 97 herauskommt aber es kommt 20 heraus. Ich habe es in WolframAlpha eingetippt. Woran liegt das jetzt bzw. habe ich hier was völlig falsch verstanden?!

 

[aknayirp]

Leider konnte ich den zweiten Beitrag nicht editieren, deshalb muss ich nochmal neu antworten, aber das ist wahrscheinlich so gedacht
Ich denke ich habe herausgefunden, wieso ich eine 20 beim Entschlüsseln herausbekomme, wenn ich ein 'a' also eine 97 verschlüssele. Das liegt am n also am Produkt der beiden Primzahlen, da beim Entschlüsseln Modulo n angewandt wird. Wenn nun das n kleiner ist als die Verschlüsselte Zahl, dann läuft das natürlich schief. Nun ist meine Frage, ob man da irgendwas machen kann? Also eigentlich benutzt man ja größere Primzahlen und wenn das Produkt dann größer als 256 ist, dann passt ja alles. Ich bin der Meinung, dass da nichts gemacht werden kann und abhängig vom n können dementsprechend Zahlen Verschlüsselt und Entschlüsselt werden.
Wobei ich nur beim Entschlüsseln dieses Problem entdeckt habe. Gilt dies auch beim Verschlüsseln? Da hier ja auch mit Modul n gearbeitet wird.