[skelle]

Hallo,
ich muss ja zur Zeit ein Programm zum verschlüsseln von Dateien schreiben und habe mir mal Verfahren wie das PublicKey Verfahren etc angesehen.

Ich wollte einmal fragen ob es vllt möglich ist ein solches Verfahren selbst zu implementieren.

Die Priorität ist dabei nicht die Sicherheit des ganzen sondern nur das es funktioniert

Ich habe mir schon einige Dokumente angesehen welche jedoch voll mit Math. Zeug waren welches ich nich so ganz raffe. Ich war zwar 11 - 13 Klasse Mathe LK aber dafür reichts bei mir denn doch noch nich ^^

Deswegen wollte ich mal in Erfahrung bringen obs für sowas vllt leichtere Anleitungen gibt oder vllt hat ja hier jemand sowas schonmal gemacht.

greetz skelle

[Witi]

Vielleicht kannst du damit ja anfangen:
http://www.example-c...om/vcpp/rsa.asp
http://www.codeproje...cpp/rsa_bb.aspx

Weitere Quellen zu unterschiedlichen Verschlüsselungsverfahren sollten sich ebenfalls leicht finden lassen.

[skelle]

Aus folgendem Grund:
Wir sollen ein Programm schreiben welches mind. 4 Verschlüsselungsverfahren kann.

Ich habe bereits XOR und OneTimePad implementiert und die anderen 2 sollen "Eigenentwicklungen" sein.
Eine habe ich bereits und die andere sollte eine asymetrische werden. Wieso? Naja mit höherer Schwierigkeit bekommt man auch eine bessere Note

Deswegen gehts auch nicht primär um Sicherheit sondern darum das es funktioniert. Ansonsten könnte ich wie von dir gesagt öffentliche Implementierungen nutzen, das stimmt.

Hoffe meine Situation ist damit geklärt

greetz skelle

Edit: @Witi: Wie gesagt, geht es mir ja nicht darum RSA o.Ä. zu implementieren sondern um eine vereinfachte Eigenentwicklung.

Dieser Beitrag wurde von skelle bearbeitet: 24. April 2008 - 12:06

[Seven]

Mit welcher Programmiersprache schreibst du es

[skelle]

C++

[skelle]

Ich habe noch ein wenig weiter recherchiert und bin gerade dabei etwas QT z tippen. Ich muss für die Verschlüsselung ein multiplikatives Inverse berechen ( oder so ähnlich )

Hab dazu auch einen Pseudoquelltext gefunden:

a,b: zwei Zahlen für die der erweiterte euklidische Algorithmus durchgeführt wird

extended_euclid(a,b)
1  wenn b = 0
2	  dann return (a,1,0)
3  (d',s',t') <-- extended_euclid(b, a mod b)
4  (d,s,t) <-- (d',t',s' - floor(a/b)t')
5  return (d,s,t)

und hab versucht diesen in c++ umzusetzen

Zahl eukel(int a, int b)
{
	Zahl result;
	Zahl result2;
	if(b==0)
	{
		result.d = a;
		result.s = 1;
		result.t = 0;
		return result;
	}
	
	result = eukel(b, a % b);

	result2.d =result.d - floor((float)a/b)*result.t;
	result2.s =result.t - floor((float)a/b)*result.t;
	result2.t =result.s - floor((float)a/b)*result.t;

	return result2;
}

Es kommen aber nicht die richtigen Ergebnisse raus =/

Ich finde aber leider nicht den Fehler im Quelltext und wollt deshalb ma hier fragen ob ihn jemand sieht

greetz skelle

[h3llfire]

Zufällig hab ich aus Spaß auch mal versucht das ganze zu Implementieren, hier mal mein Versuch, vllt hilft es ja jemanden, das ganze ist aber ziemlich unsauber geschrieben und irgendwo ist ein Fehler durch den es nicht immer funktioniert, orientiert habe ich mich am Wikipedia Artikel:

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string>

using namespace std;

typedef unsigned long long ull;

bool isprim(int n)
{
   int i, di;
   if (n<=1) return false;
   if (n%2 && n%3) {
	 for ( i=5, di=4; i*i<=n; i+=di^=6 )
	   if (n%i==0) return false;
	 return true;
   } else return n<4;
}

ull ggT( ull n1 , ull n2 )
{		  
   if( n1 == n2 ) return n1;
   if( n1 < n2 )
	   {
	   ull tmp = n2;
	   n2 = n1;
	   n1 = tmp;
	   }
   while( 1 )
	  {
	   ull rest = n2 % n1;
	  if( rest==0 ) return n1;
	  n2 = n1;
	  n1 = rest;
	  }
}

void extended_euclid(ull a, ull b, ull & d, ull & s, ull & t){
	if(b == 0){
		d=a;
		s=1;
		t=0;
		return; 
	}
	ull d2,s2,t2;
	extended_euclid(b, a%b, d2,s2,t2);
	d = d2;
	s = t2;
	t = s2-(a/b)*t2;
	return;
}

ull mod_exp(ull b, ull x, ull m)
{
	ull erg = 1;
		while ( x > 0 ) 
		{
				if ( x & 1 ) { erg = ( erg * b ) % m; }
				b = ( b * b ) % m;
				x = x >> 1;
		}
		return erg;
}

int rand(int min, int max){
	return min + ( rand() % ( max - min + 1 ) );
}

/*
 *Generiert ein Schlüsselpaar
 *public key: e und N
 *private key: d und N
 */
void generateKeys(ull & e, ull & d, ull & N){

	//Seed für rand
	srand( (unsigned) time(NULL) ); 
	
	//Also wollen wir mal 2 Zufallsprimzahlen generieren:
	int p = 0;
	int q = 0;
	
	do{
		p =  rand(100, 1000);
	}while(!isprim(p));
	
	do{
		q =  rand(100, 1000);
	}while(!isprim(q));
	
	//cout << "p: " << p << endl;
	//cout << "q: " << q << endl;
	
	N = p*q;
	ull eul = (p-1)*(q-1);
	
	//cout << "eul(" << N << ")=" <<  eul << endl;	
	
	//Teilerfremde Zahl zu eul:
	do{
		e = rand(2, eul-1); // Zahl zwischen 1 < e < eul
	}while(ggT(e,eul) != 1); //solange nicht Teilerfremd
	
	//cout <<  1 << " < e: " << e << " < eul: " << eul << endl;
	
	//e*d sollen konkuent zu 1 mod eul sein
	ull temp, k;
	extended_euclid(e, eul, temp, d, k);

	
	//cout << "public key: e: "<< e << " N: " << N << endl;
	//cout << "private key: d: "<< d << " N: " << N << endl;
	
}

/*
 * Verschlüsselt msg mit dem public key
 */
ull crypt(const ull & msg, const ull & e, const ull & N){
	return mod_exp(msg, e, N);
}
/*
 * Entchlüsselt crypt mit dem private key
 */
ull decrypt(const ull & crypt, const ull & d, const ull & N){
	return mod_exp(crypt, d, N);
}
/*
 * Testet die gernerierten Schlüssel
 */
bool testKeys(const ull & e, const ull & d, const ull & N){
	ull msg = 123;
	return msg == decrypt(crypt(msg,e,N),d,N);
}

int main() {

	ull e,d,N;
	do{
		generateKeys(e,d,N);
	}while(!testKeys(e,d,N));

	cout << "public key: e: "<< e << " N: " << N << endl;
	cout << "private key: d: "<< d << " N: " << N << endl;
		
	return 0;
}

Dieser Beitrag wurde von h3llfire bearbeitet: 21. Mai 2008 - 23:38

[skelle]

ich habs nach langem hin und her auch noch geschafft die Sache hinzubiegen

[Witi]

Na dann her mit der Lösung, die wird sicherlich auch andere interessieren.