------------------
-----rsa.h--------
------------------

#include <iostream>
#include <time.h>
#include <math.h>
using namespace std;

  #ifndef _rsa_h_
  #define _rsa_h_

int random();
int pn();
double N(int p, int q);
double phi(int p, int q);
double e(double ephi);
double d(double ee, double ephi);
double a = 0;
double b = 0;
int p = 0;
int q = 0;
double NN = 0;
double ee = 0;
double ephi = 0;
double dek = 0;
double dd = 0;

int prim[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
//int prim[] = {101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997};
//int prim[] = sehr lange primzahlenliste die im finalen programm genutzt werden soll!

double mod(double a, double b);
double ggT(double x,double y);
double x = 0;
double y = 0;
double temp = 0;

  #endif

--------------------
----rsa.cpp---------
--------------------

#include <iostream>
#include <time.h>
#include <math.h>
#include "rsa.h"
using namespace std;

// anzahl primzahlen in der finalversion Einhundertneunzehntausendsiebenhundertsechsunddreißig primzahlen der groesse 17000000 - 19000000
// e groesser 65537

int random()
{
    int z1 = rand();
    int z2 = rand();
    int seed = mod(z1*z2, 10); // hier sollen eigentlich nacher zahlen bis zu 110000 gezogen werden
    return seed; // übergabe der Zufallszahl
}

int pn() // sucht eine zufällige Primzahl aus der Primzahlenliste (siehe headerdatei)
{
    int primzahl = prim[random()];
    return primzahl;
}

double N(int p, int q) // Berechnet den RSA-Modul bzw. die Kreisgröße in der nacher zum ver- und entschlüsseln potenziert wird.
{
    double N1 = p*q;
    return N1;
}

double phi(int p, int q) // Berechnet die Eulersche phi-Funktion von N
{
    double phi_N = (p-1)*(q-1);
    return phi_N;
}

double e(double ephi) // eine zu phi teilerfremde Zahl e, für die gilt 1 < e < phi.
{
    int e1 = 1;
    {
        while(ggT (e1, ephi) != 1)
            {
            e1++;
            if (e1 > ephi)
            {
                break; // ich hab später diese break abfrage gemacht um zu testen ob er überhaupt einmal durchzählt...
            }
        }
    }
    return e1;
}

double d(double ee, double ephi) // Berechnet den Entschlüsselungsexponenten d als Multiplikativ Inverses von e bezüglich des Moduls phi.

{
    int k = -1;
    dek = 1;
    while(mod(ee*dek, ephi) != 1)
    {
        dek = (1-k*ephi)/ee;
        k--;
        if (k < -2*ephi)
        {
        break;
        }
    }
    return dek;
}

/*
int pot(int b, int e)
{
    int keep = b;
    while (i < e)
    {
        b = b * keep;
        i++;
    }
    return b;
}
*/

double mod(double a, double b) // berechnet den Modulo von double Werten
{
	while(a>b)
	{
		a = a-b;
	}
	return a;
}

double ggT(double x,double y) // berechnet größten gemeinsamen Teiler
{
    while(y != 0)
    {
        temp = mod(x, y);
        x = y;
        y = temp;
    }
    return x;
} 

int main ()
{
    //srand (4453);
    srand (time(NULL)); // Intialisierung der srand Funktion
    int p = pn(); // ab hier werden alle wichtigen variablen berechnet und dann ausgegeben
    int q = pn();
    while (p == q)
    {
        p = pn();
        q = pn();
    }
    cout << p << "\n" << q << "\n";
    NN = N(p, q);
    cout << NN << "\n";
    ephi = phi(p, q);
    cout << ephi << "\n";
    ee = e(ephi);
    cout << ee << "\n";
    dd = d(ee, ephi);
    cout << dd << "\n";

    system("PAUSE");
    return 0;
}

----------------------------------------------------
------------ende------------------------------------
----------------------------------------------------

bei mir berechnet das Programm die Variablen p und q richtig.
NN und ephi werden auch richtig berechnet.

jedoch scheitert die Berechnung von ee und dd.
ich hatte auch schon eine Version dieses programms erstellt wo e1 und k
zufällig ausgewählt werden bis sie passen. Dabei kam aber keine Lösung heraus
und das Programm rechnete sich Tod. Ich dachte das dies daran liegen könnte,
dass es immer eine sekunde dauert bis die nächste Zufallzahl gewürfelt wird.
Wenn mir jemand sagen könnte ob dies überhaupt der fall ist, das pro sekunde nur eine Zahl gezogen wird und ob man dies beschleunigen kann, wäre ich ihm sehr dankbar.

wenn jemand andere Verbesserungsvorschläge hat oder gar den Fehler in meinem Programm findet dann bitte hier posten...

Kennt jemand schon ein gut programmiertes RSA Schlüsselerzeugungsprogramm, dann schickt bitte ein Link oder ne Mail oder so. oder postet es hier rein.

RSA ist in vielen Krypto-Bibliotheken implementiert. Und wenn Du RSA nicht gerade zu Übungszwecken implementieren willst, rate ich Dir auch dazu, solche Bibliotheken zu nutzen. Fehlerfreie Implementierungen von Kryptoverfahren ohne Sicherheitslücken sind nicht trivial. Am besten nimmt man da schon fertige und gut getestete Open Source Bibliotheken.

appropos Sicherheitslücken. Genau da liegt ja der Hund begraben.
Ich muss jetzt nicht unbedingt ein eigenes Verschlüsselungsprogramm schreiben,
aber ich will zumindest auf das einen blick werfen, welches ich nacher verwende.
Damit ich selber gucken kann ob es Sicherheitslücken gibt. Das mag zwar paranoid klingen, da ich wahrscheinlich selber nicht in der Lage bin ein Kryptoverfahren ohne Sicherheitslücken zu schreiben, aber ich bin quasie von meiner Firma dazu verpflichet Kryptoverfahren nicht einfach so ohne weiteres zu verwenden.

Aber das ist schonmal ein gute idee auf Krypto-Bibliotheken zurückzugreifen.

Damit ich selber gucken kann ob es Sicherheitslücken gibt.

Nichts gegen dich, aber das ist für Normalsterbliche quasi aussichtslos Schau dir lieber an, was andere, die sich ein Leben lang mit Verschlüsselung beschäftigen, zu den Algorithmen sagen.

- math.h und time.h sind keine C++-Header. Nur weil dein Compiler auch die C-Header kennt, bekommst du keine Fehlermeldung. Nimm besser <cmath> und <ctime>
- in rsa.h bindest du völlig unnötigerweise 3 Header ein, die du dort garnicht benutzt.
- in rsa.h hast du ein using namespace std; . Das ist erstens völlig unnötig (du benutzt in dem header nichts aus std), zweitens hebelt es den Nutzen von namespaces in allen Sourcen aus, in die du rsa.h einbindest. Schlimmstenfalls bedeutet das, dass du durch ein simples #include den Sinn der ganzen Source ändern kannst, weil das lookup plötzlich std:: Funktionen findet und benutzt. Kurz: kein using in Headern. Lass es einfach.
- Deine Variablen und Funktionen habe so unheimlich sprechende Namen. a, b, d, e, p, q, N... völlig irritierend, dass du eine Funktion random() genannt hast. 6 Zeichen ist ja elend lang. r hätte auch gereicht. </ironie> Im ernst: veruch mal das Program zu verstehen, ohne den Algorithmus von Wikipedia nebenbei liegen zu haben. Gib den Variablen sprechendere Namen. Das spart dir später viele Kopfschmerzen, vor allem weil du ja rausfinden willst, ob es Sicherheitslücken gibt.

st00x schrieb:

Ich muss jetzt nicht unbedingt ein eigenes Verschlüsselungsprogramm schreiben,
aber ich will zumindest auf das einen blick werfen, welches ich nacher verwende.

Dafür gibts open source-Bibliotheken

da ich wahrscheinlich selber nicht in der Lage bin ein Kryptoverfahren ohne Sicherheitslücken zu schreiben, aber ich bin quasie von meiner Firma dazu verpflichet Kryptoverfahren nicht einfach so ohne weiteres zu verwenden.

Wenn du nicht in der Lage bist, selber eins ohne Sicherheitslücken zu schreiben, heißt das, dass du in deiner eigenen Implementierung eines bekannten Kryptoverfahrens (wie RSA) die Sicherheitslücken zu finden. Wie willst du dann erst beurteilen, ob es in einer fremden Implementierung Sicherheitslücken gibt? Wenn deine Firma dir verbietet, "einfach so" ein Kryptoverfahren zu benutzen (was durchaus nachvollziehbar ist), wende dich an denjenigen, der bei euch dafür zuständig ist, dass er dir eins nennt (und dir die Bibliothek zukommen lässt). Wenn ihr keinen Zuständigen habt und ihr das Kryptoverfahren braucht, dann geht an einer geeigneten Fortbildung nichts vorbei. Ob über eine Schulung oder Internetrecherche, müssen deine Chefs entscheiden. Aber du als Laie (ich geh mal davon aus dass du das bist, sonst würdest du nicht anfangen, es selbst zu implementieren) kannst da so oder so keine Entscheidungen treffen, wenigstens nicht, indem du dir Code anguckst

p, q: zwei Primzahlen,
n = pq, ("Modulus")
ed = 1 mod phi(n) wobei e und d der Ver- bzw Entschlüsselungsexponent ist

(wenn ich das noch richtig im Kopf habe)

Andere Bezeichnungen dafür würde ich also nicht nehmen.

...wobei p, q, N, e, d Standardbezeichnungen für die RSA-Zahlen sind.

p, q: zwei Primzahlen,
n = pq, ("Modulus")
ed = 1 mod phi(n) wobei e und d der Ver- bzw Entschlüsselungsexponent ist

(wenn ich das noch richtig im Kopf habe)

Andere Bezeichnungen dafür würde ich also nicht nehmen.

Okay, das hab ich schon fast befürchtet, allerdings könnte man da einen entsprechenden Text bzw. Link auf eien Doku zufügen.

Was mir allerdings jetzt erst aufgefallen ist: Den Header darf man nicht mehr als einmal im Projekt einbinden. Die ganzen globalen Variablen darin (sowieso schon nicht gut) haben externe linkage, bei mehr als einer TU mit dem Header gibts also ein problem mit der ODR...