
                  «««««««««««««« Gcode »»»»»»»»»»»»»»»»»

                               Version 1.0

            © 1992 by Ralph-Thomas Aussem All rights reserved


                           Achtung!!! Es handelt
   sich bei diesem Programm nicht um einen vollständiges Codierprogramm !!!

Verbreitung ?
---------------
Jeder  darf das Programm benutzen, kopieren und weitergeben sofern er nicht
mehr  als  DM  5.-  dafür  verlangt.   Ich  übernehme keine Haftung für das
Programm  und  seine  Ausgaben.   Eine Verbreitung über Datennetze wird vom
Autor begrüßt.

Was braucht das Programm ?
--------------------------
Einen Amiga und die ixemul.library.

Was kann das Programm ?
-----------------------
Dieses  Programm  realisiert  den Diffie-Hellmann Schlüsseltausch.  Es löst
teilweise  das  klasische  Problem, wenn zwei Leute sich über einen öffent-
lichen  Kanal  schreiben wollen und deshalb die Nachrichten codieren wollen
oder  müssen.   Eine  Lösung  wäre es einen Public-key (oder asymetrischen)
Codieralgorithmus  zu  benutzen.   Diese sind aber meist sehr langsam.  Ein
andere  ist, man benutzt einen "normalen" (symetrischen) Codieralgorithmus.
Dazu  muß  aber  ein  gemeinsamer und geheimer Schlüssel vereinbart werden.
Dort  setzt  dieses  Programm  an.  Es gibt die Möglichkeit einen Schlüssel
über  einen  öffentlichen  Kanal auszutauschen und daraus dann den geheimen
Schlüssel  für  das "normale" Codierverfahren zu berechnen.  Die Sicherheit
ist ähnlich hoch wie beim RSA-Algoritmus.

                                Wichtig !!!
Mit  diesem  Programm  ist  es  NICHT  möglich,  einen BESTIMMTEN Schlüssel
auszutauschen.   Es kommen zwar beide Seiten zu dem selben Schlüssel (sonst
wäre  das  ganze  Programm  ja  witzlos),  doch  der  ist  mehr oder minder
zufällig.   Es  ist  also  nicht  möglich  einen Schlüssel wie "Karin" oder
"07.05.1968"  für  ein  symetrisches Codierverahren zu übertragen.  Das was
GCode  nacher liefert ist eine Zahl < als die gewählte Primzahl.  Wobei ich
aber  zu Verteidigung von GCode sagen muss, daß man solche Schlüssel besser
garnicht benutzen sollte, sondern lieber zufällig gewählte Schlüssel.

Wie benutzt man das Programm ?
------------------------------
Angenommen  Herr  G.Heim  möchte Frau Blick schreiben.  Dazu benutzt er ein
symetrisches  Codierverfahren  (z.B  den DES Algoritmus).  Er muß aber Frau
Blick  den geheimen Schlüssel zum Dekodieren mit dem symetrischen Verfahren
mitteilen.  Dazu benutzt er Gcode.

1. Man verabredet zwei nicht(!) geheime Zahlen mit folgenden Eigenschaften:
   a) p ist einen Primzahl
   b) s ist eine Systemzahl < p (ansonsten beliebig)

2. Herr G.Heim überlegt sich eine Geheimzahl a < p
   Frau Blick überlegt sich auch eine Geheimzahl b < p

3. Jeder Partner berechnet seinen öffentlichen Schlüssel mit
   folgenden Aufruf von gcode:

   gcode -p[Primzahl] -s[Systemzahl] -c[Geheimzahl]

   Lässt  man  die  Systemzahl weg, generiert Gcode eine Systemzahl.  Lässt
   man  die  Primzahl  weg  und  gibt -n[N] eine Zahl vor, sucht Gcode eine
   Primzahl > N.  Lässt man -p und -n weg oder setzt sie auf 0, dann wird
   eine Primzahl aus dem internen Puffer benutzt.  (Sehr zu empfehlen für
   Benutzter  von  <68030).   Da  die  Primzahl nicht geheim ist.  Entsteht
   dadurch auch kein Sicherheitsrisiko.

   Es kommt dabei folgende Ausgabe heraus mit
   Primzahl=17
   Systemzahl=5
   Geheimzahl=8
   als Parameter...
   -------------------- snip -----------------------------------
   Code generator for the Diffie-Hellmann key exchange
   GCode Version X.X © 1992 by Ralph-Thomas Aussem All rights reserved
   compiled by GNU C++ version 2.1 on XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   X prims in the internal buffer
   prim number=17
   system number=5
   Your secret code number:8

   Your public key=16
   -------------------- snip -----------------------------------

   Wichtig ist die letzte Zeile.  Dort steht der öffentliche Schlüssel
   von Herrn G.Heim.  Frau Blick macht das selbe mit ihrer Geheimzahl
   und erhält auch einen öffentlichen Schlüssel.

4. Herr G.Heim  und Frau Blick tauschen die öffentlichen Schlüssel
   aus.

5. Herr G.Heim und Frau Blick rufen Gcode mit folgenden
   Parametern auf:

   Gcode -p[Primzahl] -s[Systemzahl] -c[Geheimzahl] -k[öffentlicher Schlüssel]

   Es kommt dabei folgende Ausgabe heraus mit
   Primzahl=17
   Systemzahl=5
   Geheimzahl=8
   öffentlicher Schlüssel=3
   als Parameter ...
   -------------------- snip -----------------------------------
   Code generator for the Diffie-Hellmann key exchange
   GCode Version X.X © 1992 by Ralph-Thomas Aussem All rights reserved
   compiled by GNU C++ version 2.1 on XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   X prims in the internal buffer
   prim number=17
   system number=5
   Your secret code number:8

   Your key:16
   -------------------- snip -----------------------------------
   Wichtig  ist  wieder die letzte Zeile.  Dort steht der geheime Schlüssel
   für das symetrischer Codierverfahren.  Beide erhalten nach diesem Aufruf
   die selbe Zahl als Ausgabe.


Optionen:
---------
	Hier noch einmal die Optionen.

   GCode -n[N] -p[prim] -s[system] -c[secret-code] -k[public-key] -g[N]

	Mit -g[N] erzeugt GCode N zufällige Primzahlen mit mehr als 100 Ziffern
   Die anderen Optionen sind weiteroben erklärt worden.

	Die  Ausgaben  werden auch in das ENV:  Verzeichnis abgespeichert, damit
   andere Programme darauf zu greifen können (siehe Beispiel für MPoint).
   ENV:PRIMNUMBER           - die Primzahl
   ENV:SYSTEMNUMBER         - die Systemzahl
   ENV:PUBLICKEY            - der öffentliche Schlüssel
   ENV:KEY                  - der geheime Schlüssel

Wie sicher ist Gcode ?
----------------------
Was  müsste Mr.  X als potentieller Angreifer schaffen um diese Algorithmus
zu  knacken  ?   Das  Codierschema  von  Gcode  basiert auf dem Problem des
diskreten Logaritmus:

           Bestimmung von a aus s^a MOD p bei bekanntem s und p

Er müsste also aus der Systemzahl,der Primzahl und den öffentlichen
Schlüsseln eine der beiden Geheimzahlen a und b bestimmen.  Das Berechnen
von a ist ebenso komplex wie das Faktorisieren einer Zahl, falls die Zahl
groß genug ist.  Daher sollte die Primzahl >10^100 sein.  Ebenso sollte die
Systemzahl und die Geheimzahlen möglichst nahe bei der Primzahl liegen.

Sonstiges...
------------
Dieses Programm ist meine erster Versuch in C++.  Die Größe (Quelltext 10k)
des  Programm  liegt  daran,  daß ich den Typ Integer vom gcc benutzt habe.
Mit diesem Zahlentyp ist es möglich sehr große ganze Zahlen darzustellen.

Inhalt des Archives ?
---------------------------
Listing of archive 'gcode.lha':
Original  Packed Ratio    Date     Time    Name
-------- ------- ----- --------- --------  -------------
    2063     639 69.0% 17-Aug-92 17:01:52  dkey.mp
   76256   31592 58.5% 17-Aug-92 16:58:44  gcode
    7606    3114 59.0% 17-Aug-92 16:58:12  gcode.dok
   75512   31460 58.3% 17-Aug-92 13:45:02  gcode20
    2038     667 67.2% 17-Aug-92 17:01:52  key.mp
-------- ------- ----- --------- --------
  163475   67472 58.7% 17-Aug-92 17:02:44   5 files

Wobei  gcode die Version für den 68000 und gcode20 dir für 68020 oder höher
ist.   Da  Ganzzahl-Arithmetik  benutzt  wird,  kommt  der Mathecoprozessor
leider nicht zu tragen.
Die  beiden AREXX Scripte für MPoint (Hallo Martin !!!) sind Beispiele, wie
man GCode in sein Pointprogramm einbauen kann.


Erreichbarkeit des Autors ?
---------------------------
 Z-Netz:    R.Aussem@innoTec1.Zer
 UUCP:      maverik@mavhh.wolf.sub.org

History:
---------
1.0 Erste Veröffentlichung
