DHM-Programm

Nach dem Webstart erscheint ein Extra-Fenster mit dem
DHM-Schluesseltausch-Programm für die Erzeugung eines
gemeinsamen geheimen Schlüssels nach Diffie, Hellman und Merkle:

Zahlen eingeben und prüfen, was bei beiden Parteien als
gemeinsame Geheimzahl heraus kommt.

Wenn die Java-JRE installiert ist, können Sie das Programm jetzt sofort ausführen:

Hier klicken zum Webstart des DHM-Programms

Danach Öffnen von DHM_Schluesseltausch.jnlp [mit Java(TM) Webstart Launcher (Standard)] wählen/bestätigen
und bei evtl. Sicherheitswarnung vor der Ausführung von DHM_Schluesseltausch_ Start das Risiko akzeptieren und OK drücken.

Wenn Sie außerdem gefragt werden, ob Sie eine Desktop- und eine Startmenüverknüpfung anlegen wollen,
sollten Sie zustimmen, wenn Sie das Programm auch nach Verlassen dieser Webseite nochmal ausprobieren wollen.

Wird nach dem Klick DHM_Schluesseltausch.jnlp herunter geladen oder werden Sie gefragt, womit Sie DHM_Schluesseltausch.jnlp öffnen wollen
oder ob/wohin Sie die Datei speichern wollen, haben Sie entweder kein Java installiert oder ihr Browser (z.B. Opera) unterstützt keinen Webstart.
Im letzten Fall empfiehlt sich nachfolgend der Download der .jar-Datei:

Sie können das Testprogramm für die Schlüsselvereinbarung nach Diffie, Hellman (und Merkle) auch als ausführbare Java-Datei Diffie-Hellman-Schluesseltausch(r-krell.de).jar (8 kB) herunter laden und später lokal auf Ihrem Rechner starten (Java-Umgebung JRE vorausgesetzt). Die Ausführung als Applet im Browser wird von mir hingegen nicht mehr angeboten: Gründe, Abhilfe und alle Downloads (in neuem Tab)

Nachfolgend der Quelltext des Applets, soweit nicht bereits auf der "Informatik-mit-Java"-Seite k) dargestellt:

DHM_Schluesseltausch_Start
DHM_Schluesseltausch_GUI

Anmerkung: Dieses Programm bildet nicht die Realität nach, etwa indem zwei Partner, die beide dieses Programm benutzen, damit trotz einer unsicheren Kommunikationsverbindung auf sichere Weise eine gemeinsame Schlüsselzahl erstellen. Sondern das Programm veranschaulicht unter Anzeige der Eingaben beider Partner in einem Fenster das Verfahren für einen imaginären, allwissenden Beobachter.
Und: Der aus der Literatur übernommene Name 'Schlüsseltausch' ist irreführend. Der Schlüssel selbst wird nie ausgetauscht, sondern nur einige 'unverfängliche' Hilfszahlen, womit beide Partner dann jeweils die gleiche (vorher nicht voraussehbare) Schlüsselzahl erzeugen können. Insofern sollte man besser von DHM-Schlüsselvereinbarung sprechen!

zum Inhaltsverzeichnis (oben) / zum Seitenende

Startdatei für den Start der DHM-Demo als Applet oder als Application

// Startdatei für DHM-Programm als Application oder als Applet -- www.r-krell.de -- 8.2.2011

public class DHM_Schluesseltausch_Start extends javax.swing.JApplet
{

  public static void main(String[] s)
  {
    new DHM_Schluesseltausch_GUI("DHM-Schlüsselvereinbarung (www.r-krell.de) -- als Application");
  }

  public void init()    // Start als Applet
  {
    new DHM_Schluesseltausch_GUI("DHM-Schlüsselvereinbarung (www.r-krell.de) -- als Applet");
  }
}

zum Seitenanfang / zum Seitenende

Programmtext der Oberfläche

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

/**
  *
  * Oberfläche für Diffie/Hellman/Merkle-Schlüsseltausch bzw. -vereinbarung
  *
  * @version 1.2 (ohne JNumberField) from 8.11.2011
  * @author  R. Krell
  * für www.r-krell.de/if-java-k.htm
  */

public class DHM_Schluesseltausch_GUI extends JFrame {
  // Anfang Attribute
  private JLabel jLabel1 = new JLabel();
  private JLabel jLabel2 = new JLabel();
  private JLabel jLabel3 = new JLabel();
  private JTextField jTfP = new JTextField();
  private JLabel jLabel4 = new JLabel();
  private JTextField jTfG = new JTextField();
  private JLabel jLabel5 = new JLabel();
  private JTextField jTfA = new JTextField();
  private JTextField jTfAlpha = new JTextField();
  private JLabel jLabel7 = new JLabel();
  private JTextField jTfB = new JTextField();
  private JLabel jLabel8 = new JLabel();
  private JTextField jTfBeta = new JTextField();
  private JLabel jLabel9 = new JLabel();
  private JLabel jLabel10 = new JLabel();
  private JTextField jTfSchluesselA = new JTextField();
  private JLabel jLabel11 = new JLabel();
  private JTextField jTfHinweis = new JTextField();
  private JLabel jLabel12 = new JLabel();
  private JLabel jLabel13 = new JLabel();
  private JButton jBtBerechnen = new JButton();
  private JTextField jTfSchluesselB = new JTextField();
  private JLabel jLabel6 = new JLabel();
  private JLabel jLabel14 = new JLabel();
  // Ende Attribute

  public DHM_Schluesseltausch_GUI (String title) {
    super (title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    int frameWidth = 567;
    int frameHeight = 417;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    Container cp = getContentPane();
    cp.setLayout(null);
    // Anfang Komponenten
    jLabel1.setBounds(24, 24, 490, 24);
    jLabel1.setText("Diffie/Hellman/Merkle-Schlüssel-'Tausch' bzw. -Erzeugung");
    jLabel1.setFont(new Font("MS Sans Serif", Font.PLAIN, 17));
    cp.add(jLabel1);
    jLabel2.setBounds(24, 72, 236, 16);
    jLabel2.setText("Gemeinsame Funktion f(x)=(g^x)%p mit");
    jLabel2.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel2);
    jLabel3.setBounds(280, 72, 15, 16);
    jLabel3.setText("p=");
    jLabel3.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    jLabel3.setToolTipText("möglichst Primzahl");
    cp.add(jLabel3);
    jTfP.setBounds(304, 64, 81, 24);
    jTfP.setText("23");
    jTfP.setToolTipText("möglichst Primzahl !");
    cp.add(jTfP);
    jLabel4.setBounds(392, 72, 40, 16);
    jLabel4.setText("und g=");
    jLabel4.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    jLabel4.setToolTipText("g < p: möglichst Primitivwurzel von p");
    cp.add(jLabel4);
    jTfG.setBounds(440, 64, 97, 24);
    jTfG.setText("17");
    jTfG.setToolTipText("g < p;  g möglichst Primitivwurzel von p");
    cp.add(jTfG);
    jLabel5.setBounds(24, 120, 106, 16);
    jLabel5.setText("Geheime Zahl A =");
    jLabel5.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel5);
    jTfA.setBounds(136, 112, 97, 24);
    jTfA.setText("5");
    cp.add(jTfA);
    jTfAlpha.setBounds(136, 216, 97, 24);
    jTfAlpha.setText("");
    jTfAlpha.setEditable(false);
    cp.add(jTfAlpha);
    jLabel7.setBounds(328, 120, 106, 16);
    jLabel7.setText("Geheime Zahl B =");
    jLabel7.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel7);
    jTfB.setBounds(440, 112, 97, 24);
    jTfB.setText("18");
    cp.add(jTfB);
    jLabel8.setBounds(328, 192, 182, 16);
    jLabel8.setText("veröffentlichbares  beta = f(B) =");
    jLabel8.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel8);
    jTfBeta.setBounds(440, 216, 97, 24);
    jTfBeta.setText("");
    jTfBeta.setEditable(false);
    cp.add(jTfBeta);
    jLabel9.setBounds(24, 256, 459, 16);
    jLabel9.setText("Nach Austausch von alpha und beta kann mit der eigenen Geheimzahl jeweils");
    jLabel9.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel9);
    jLabel10.setBounds(24, 288, 84, 16);
    jLabel10.setText("(beta^A)%p = ");
    jLabel10.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel10);
    jTfSchluesselA.setBounds(104, 280, 81, 24);
    jTfSchluesselA.setText("");
    jTfSchluesselA.setEditable(false);
    cp.add(jTfSchluesselA);
    jLabel11.setBounds(208, 288, 88, 16);
    jLabel11.setText("(alpha^B)%p =");
    jLabel11.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel11);
    jTfHinweis.setBounds(392, 280, 145, 24);
    jTfHinweis.setText("");
    jTfHinweis.setEditable(false);
    cp.add(jTfHinweis);
    jLabel12.setBounds(24, 336, 521, 16);
    jLabel12.setText("die nur die beiden Besitzer von A und B berechnen können -- und kein Dritter, solange es");
    jLabel12.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel12);
    jLabel13.setBounds(24, 352, 495, 16);
    jLabel13.setText("kein Verfahren gibt, um aus bekanntem f(x) in annehmbarer Zeit das x zu berechnen.");
    jLabel13.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel13);
    jBtBerechnen.setBounds(64, 152, 435, 25);
    jBtBerechnen.setText("Berechnen");
    jBtBerechnen.setMargin(new Insets(2, 2, 2, 2));
    jBtBerechnen.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        jBtBerechnen_ActionPerformed(evt);
      }
    });
    cp.add(jBtBerechnen);
    jTfSchluesselB.setBounds(296, 280, 81, 24);
    jTfSchluesselB.setText("");
    jTfSchluesselB.setEditable(false);
    cp.add(jTfSchluesselB);
    jLabel6.setBounds(24, 192, 189, 16);
    jLabel6.setText("veröffentlichbares  alpha = f(A) =");
    jLabel6.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    cp.add(jLabel6);
    jLabel14.setBounds(24, 320, 475, 16);
    jLabel14.setText("als neues Geheimnis bzw. als neue, gemeinsame Schlüsselzahl erzeugt werden,");
    jLabel14.setFont(new Font("MS Sans Serif", Font.PLAIN, 13));
    jLabel14.setEnabled(true);
    cp.add(jLabel14);
    // Ende Komponenten
    setResizable(false);
    setVisible(true);
  }

  // Anfang Methoden
  public void jBtBerechnen_ActionPerformed(ActionEvent evt)
  {
    int p = -1;
    int g = -1;
    int a = -1;
    int b = -1;
    boolean okay = false;
    try {
      p = Integer.parseInt(jTfP.getText());
      g = Integer.parseInt(jTfG.getText());
      a = Integer.parseInt(jTfA.getText());
      b = Integer.parseInt(jTfB.getText());
      okay = true;
    }
    catch (NumberFormatException nfe)
    {  }

    if (!okay)
    {
      jTfHinweis.setText("Fehleingabe");
    }
    else
    {
      jTfHinweis.setText("");

      // Erzeugen eines Objekts der Klasse RestVonPotenz_Rechner und Aufruf von Methoden
      // zur Berechnung von alpha, beta, schlüsselA und schlüsselB

      RestVonPotenz_Rechner dhm = new RestVonPotenz_Rechner();
      int alpha = dhm.potMod(g,a,p);
      jTfAlpha.setText(""+alpha);
      int beta  = dhm.potMod(g,b,p);
      jTfBeta.setText(""+beta);

      int schlüsselA = dhm.potMod(beta,a,p);
      jTfSchluesselA.setText(""+schlüsselA);
      int schlüsselB = dhm.potMod(alpha,b,p);
      jTfSchluesselB.setText(""+schlüsselB);

      if (schlüsselA == schlüsselB)
      {
        jTfHinweis.setText ("gleich!");
      }
      else
      {
        jTfHinweis.setText ("* ungleich *");
      }
    }
  }
}

Hinweis: Damit das Programm auch als (J-)Applet läuft, wurden die Eingabefelder vom Typ JNumberField durch Eingabefelder vom Typ JTextField ersetzt. Im Programmtext auf der Extraseite zum RSA-Applet kann man hingegen noch den Gebrauch von JNumberField-Typen sehen!

zum Seitenanfang / zum Seitenende

Die Klasse RestVonPotenz_Rechner ist auf der Seite k) dargestellt!

zurück zur Seite „Informatik mit Java, Teil k)"

zum Anfang dieser Seite