Date: Mon, 6 Dec 1999 19:00:21 -0500 (EST)
From: support@redtenbacher.de
Subject: Automat. Ver-/Entschluesselung von E-Mail, Teil IIId

Sehr geehrte "signatur"-Abonnenten,

im 4. (und letzten) Schritt des Implementierungsleitfadens für
Programmierer einer automatischen Ver-/Entschlüsselung/Signatur
von E-Mail geht es nun um die Ausgangsmails: Welche Vorgänge
sollten im Fall einer verschlüsselten/signierten Ausgangsmail
ablaufen, um maximale Interoperabilität mit den existierenden
OpenPGP-kompatiblen Programmen und -Plugins sicherzustellen?


Schritt 4: Abwicklung von Signatur/Verschlüsselung bei
           Ausgangsmails: Formate, Optionen, Algorithmen

Ähnlich wie bei Eingangspost wollen wir auch bei Ausgangspost
sicherstellen, daß ein- und mehrteilige Mails (d.h. insbesondere
auch Mails mit Dateianlagen) wahlweise verschlüsselt,
verschlüsselt+signiert oder auch nur signiert werden können. Als
Zielformate sollen dabei sowohl "OpenPGP" (RFC 2440) als auch die
Erweiterung "PGP-MIME" (RFC 2015) unterstützt werden.

Die dafür erforderlichen Formatbeschreibungen und Hilfsprogramme
haben wir bereits in Schritt 3 bei den Eingangsmails behandelt.
Jetzt geht es um die Umkehrrichtung und darum, die Optionen der
Datei KRYPTO.TAB zu unterstützen (vgl. Teil II, "Die Sicht des
Mailserver-Administrators").

Die von "KT-MAIL/Krypto" gewählte Vorgehensweise werde ich
wieder, wie in den Teilen IIIb und IIIc, nachfolgend in
Pseudo-Code näher beschreiben.


Verschlüsselungs-/Signaturroutine von KT-MAIL/Krypto:

(Im Fall von KT-MAIL wird die Verschlüsselungs-/Signaturroutine
aufgerufen, sobald eine Ausgangsmail unmittelbar für die
Versendung ins Internet bereit ist. Die Dateien haben zu diesem
Zeitpunkt daher bereits die Internet-Transportkodierung MIME oder
UUENCODE, sofern es sich nicht einfach um unkodierte Textdateien
handelt.

Falls dies bei Ihrem Mail-System anders ist, sind die
nachstehenden Schritte ggf. geringfügig anzupassen.)


  [Zuerst werden die Kerndaten der E-Mail in Variablen geholt:]

From := (Absender im Haus);
To := (Empfänger im Internet);
Subj := (Inhalt der "Subject:"-Zeile der Ausgangsmail);

  [Als nächstes werden die Default-Werte für den
  Empfängerschlüssel, das Verschlüsselungsverfahren (PGP oder
  PGP-MIME), die gewünschten Optionen (Verschlüsseln, Signieren
  oder beides) und ggf. die KeyID für den zu verwendenden
  Signaturschlüssel des Absenders sowie das zugehörige Mantra
  (Paßwort) gesetzt.]

EmpfängerID := To;
Zielformat := "PGP";
IF (Subj enthält "!V!" oder "!VS!" oder "!SV!" (groß/klein egal))
THEN
  Optionen := "V"
ELSE
  Optionen := ""
END;
IF (Subj enthält "!S!" oder "!VS!" oder "!SV!" (groß/klein egal))
THEN
  Optionen := Optionen + "S"
END;
SigID := "";
SigMantra := "";

  [Bis hier haben wir die explizit geäußerten Wünsche für die
  akt. Ausgangsmail gesammelt. Als nächstes holen wir uns die
  Datei KRYPTO.TAB und prüfen, welche Standardvorgaben dort ggf.
  für unseren Empfänger bzw. Absender festgelegt wurden:]

Datei KRYPTO.TAB laden [Aufbau siehe Teil II, "Die Sicht des
  Mailserver-Administrators"];

Oberste Zeile suchen, deren erste Angabe (Empfängeradresse) im
  akt. 'To' (ohne Berücksichtigung von Groß-/Kleinschreibung)
  enthalten ist:
IF (keine solche Zeile gefunden)
THEN
  GOTO DoneTab1
END;

EmpfängerID := (4. Angabe in der Zeile);
Zielformat := (2. Angabe in der Zeile);
Optionen := Optionen + (eventuelle zusätzliche Optionen [V, S]
            in der 3. Angabe der Zeile);
IF ('Optionen' enthält "S")
THEN
   5. Angabe in Zeile prüfen [opt. Signaturschlüssel];
   IF (Signaturschlüssel dort als KeyID "xxxxxxxx" angegeben) AND
      (wir haben ein passendes Paßwort [vgl. Variablen
      "PGPPWxxxxxxxx" aus Schritt 2 (Initialisierung des
      Krypto-Moduls)])
   THEN
     SigID := "xxxxxxxx"; [= 5. Angabe der Zeile]
     SigMantra := (Inhalt der zugehörigen Variablen
                  "PGPPWxxxxxxxx");
   END;
END;

Sprungmarke "DoneTab1":

IF ('Optionen' enthält weder "V" noch "S")
THEN
  GOTO DoneOutMail
END;

IF ('Optionen' enthält kein "S") OR (SigMantra<>"")
THEN
  GOTO DoneTab2
END;

Oberste Zeile suchen, deren erste Angabe im akt. 'From' (ohne
  Berücksichtigung von Groß-/Kleinschreibung) enthalten ist
  (Absendereintrag):
IF (keine solche Zeile gefunden)
THEN
  GOTO DoneTab2
END;

4. Angabe in Zeile prüfen (KeyID des Signaturschlüssels):
IF (Signaturschlüssel dort als KeyID "xxxxxxxx" angegeben) AND
   (wir haben ein passendes Paßwort [vgl. Variablen
   "PGPPWxxxxxxxx" aus Schritt 2 (Initialisierung des
   Krypto-Moduls)])
THEN
  SigID := "xxxxxxxx"; [= 4. Angabe der Zeile]
  SigMantra := (Inhalt der zugehörigen Variablen
               "PGPPWxxxxxxxx");
END;

Sprungmarke "DoneTab2":

IF ('Optionen' enhält "S") AND (SigID="")
THEN
  Msg := "Kein passender Signaturschlüssel in KRYPTO.TAB!";
  GOTO ErrorOutMail
END;

  [Als nächstes bestimmen wir den Aufbau und Typ der zu
  verschlüsselnden bzw. signierenden Datei:]

Lade die Ausgangsmail, die verschlüsselt bzw. signiert werden
  soll:
IF (Datei enthält Zeile mit "-----BEGIN*PGP*MESSAGE-----",
    wobei "*" als Jokerzeichen steht)
THEN
  GOTO DoneOutMail
  [Hinweis: In diesem Fall ist die Datei bereits verschlüsselt
  oder signiert worden (ggf. vom Endbenutzer mit einem lokalen
  PGP-Schlüsselbund, der auf dem Mailserver nicht verfügbar ist)
  - wir haben daher nichts mehr zu tun]
END;

"Subject:"-Headerzeile der Ausgangsmail suchen und daraus alle
  Markierungen "!V!", "!S!", "!VS!" und "!SV!" (in beliebiger
  Groß-/Kleinschreibung) löschen;
  [Hinweis: Diese Markierungen dienen ja nur der internen
  Signalisierung zwischen Endbenutzer und Mailserver und sollen
  daher in der Mail, die das Haus verläßt, nicht mehr enthalten
  sein.]

Oberste Textzeile des Mailinhalts (nach den Header-Zeilen)
  prüfen:
IF (Zeile fängt mit "begin" an und enthält 3 Angaben) AND
   (letzte Zeile der Datei lautet "end")
THEN
  TransferTyp := "UU-kodiert"
ELSE
  TransferTyp := "unkodiert"
  [Hinweis: Der letzte Fall ist natürlich nur eine Vorbelegung,
  denn die Datei kann noch MIME-kodiert sein.]
END;

IF (Header-Zeilen der Mail enthalten sowohl Eintrag
   "MIME-Version: ..." als auch Eintrag "Content-Type: ...")
THEN
  IF ("Content-Type:"-Eintrag enthält Parameter "multipart")
  THEN
    TransferTyp := "MIME-mehrteilig";
    IF ("Content-Type:"-Eintrag enthält _keinen_ Parameter
       "Boundary=...")
    THEN
       Msg := "Fehlerhafte MIME-Kodierung!";
       GOTO ErrorOutMail
    END;
    Boundary := "--" + (Trenner aus dem Parameter "Boundary=...")
  ELSE
    TransferTyp := "MIME-einteilig"
  END;
END;

IF (Zielformat="PGP-MIME") AND
   ('Optionen' enthält "S", aber kein "V")
THEN
  IF (TransferTyp="MIME-mehrteilig")
  THEN
    Optionen := Optionen + "V"
  ELSE
    Zielformat := "PGP"
  END;
END;
  [Hinweis: PGP hat einen Implementierungsfehler, der dazu führt,
  daß das Programm im PGP-MIME-Modus bei Eingangsmails, die
  lediglich signiert, aber nicht verschlüsselt sind, die Signatur
  nicht findet.

  Der obige Code-Abschnitt umgeht diesen Fehler: Falls die
  Ausgangsmail einteilig ist, wird bei einer nur signierten Mail
  das Zielformat von "PGP-MIME" auf "PGP" geändert (PGP-MIME
  bringt bei einteiligen Mails keinen Vorteil, und jeder
  PGP-MIME-Empfänger kann auch PGP entschlüsseln). Bei
  mehrteiligen Mails (die auch mehrfach gestaffelte
  MIME-Multiparts enthalten könnten und dann für eine korrekte
  automatische Entschlüsselung den PGP-MIME-Modus benötigen) wird
  die reine Signatur hingegen um eine Verschlüsselung
  erweitert.

  Diese Umgehung hat einen kleinen Nachteil: Signierte
  mehrteilige Mails brauchen auch dann, wenn vom Absender keine
  Verschlüsselung gewünscht wird, dennoch einen
  Empfängerschlüssel auf dem Mailserver-Schlüsselbund. In der
  Praxis dürfte diese kleine Einschränkung aber durch den Vorteil
  der zuverlässigen Interoperabilität mit allen bestehenden
  PGP-Implementierungen aufgewogen werden.]

IF (Zielformat="PGP-MIME")
THEN
  IF (TransferTyp="MIME-einteilig") OR
     (TransferTyp="MIME-mehrteilig")
  THEN
    TransferTyp := "MIME-einteilig"
    [Hinweis: Eine MIME-kodierte Mail wird im PGP-MIME-Modus
    immer als Ganzes (= als einteilig) behandelt, weil die Mail
    ohnehin inklusive Transferkodierung verschlüsselt wird.]
  ELSE
    Zielformat := "PGP"
    [Hinweis: Hier ist der TransferTyp entweder "UU-kodiert" oder
    "unkodiert". Da die zugrunde liegende Mail somit keine
    MIME-Struktur aufweist, macht der "PGP-MIME"-Modus keinen
    Sinn und wird zum normalen PGP-Format abgeändert.]
  END;
END;

  [Nun wird der (nächste) zu verschlüsselnde Block bestimmt:]

IF (TransferTyp="unkodiert") OR (TransferTyp="UU-kodiert")
THEN
  AnfZeile := (Nr. der ersten Inhaltszeile der Mail [nach den
              Header-Zeilen und darauf folgende(n) Leerzeile(n)]);
  EndZeile := (Nr. der letzten Zeile der Mail);
  GOTO RangeOK
ELSIF (TransferTyp="MIME-einteilig")
THEN
  AnfZeile := (Nr. der Zeile mit dem "MIME-Version:"-Header);
  EndZeile := (Nr. der letzten Zeile der Mail);
  GOTO RangeOK
END;

[An dieser Stelle gilt jetzt: TransferTyp="MIME-mehrteilig"]

EndZeile := (Nr. der letzten Header-Zeile der Datei);

Sprungmarke "NextOutBlock":

Suche niedrigste Zeilennr. größer als 'EndZeile', deren Inhalt
  mit dem Trenner in der Variablen 'Boundary' beginnt:
IF (keine solche Zeile gefunden) OR
   (diese Zeile ist identisch mit "Boundary"+"--")
  [Hinweis: Die Zeichenfolge "--" hinter dem Trenner ist die
  explizite Ende-Markierung einer mehrteiligen MIME-Mail.]
THEN
  GOTO DoneOutMail
END;
AnfZeile := (akt. Zeilennr. + 1);
Suche niedrigste Zeilennr. größer als 'AnfZeile', deren Inhalt
  mit dem Trenner in der Variablen 'Boundary' beginnt:
IF (es gibt keine solche Zeile mehr)
THEN
  Msg := "Fehlerhafte MIME-Kodierung!"
  GOTO ErrorOutMail
END;
EndZeile := (akt. Zeilennr. - 1);

Sprungmarke "RangeOK":

Schiebe den Block zwischen den Zeilen "AnfZeile" und "EndZeile"
  (inklusive dieser beiden Zeilen) in ein eigenes Fenster;
IF (TranferTyp="MIME-mehrteilig")
THEN
  Fülle vor den Blockanfang die Zeile "MIME-Version: 1.0" ein
END;

  [Nun holen wir uns für den Fall einer Binärdatei den Dateinamen
  des akt. Blocks:]

BlockName := "binmail.000";
  [Hinweis: Diese Vorbelegung garantiert uns einen gültigen
  Blocknamen, falls wir ihn (für Binärdateien) brauchen und
  nichts Besseres in der Datei finden. Der gewählte Name für die
  Vorbelegung ist willkürlich und kann beliebig geändert werden.]

IF (TransferTyp="unkodiert")
THEN
  GOTO OutFileNameOK
  [Hinweis: In diesem Fall finden wir in der Mail keinen
  expliziten Dateinamen.]
END;

IF (TransferTyp="UU-kodiert")
THEN
  BlockName := (3. Angabe in oberster Zeile
               [= "begin 777 <Dateiname>" o.ä.]);
  GOTO OutFileNameOK
END;

  [Hier haben wir auf jeden Fall einen MIME-Block:]

IF (Block enthält in seinen Header-Zeilen einen
   "Content-Type:"-Eintrag)
THEN
  IF ("Content-Type:"-Zeile enthält einen "multipart"-Parameter)
     AND (Zielformat<>"PGP-MIME")
  THEN
    Msg := "Gestaffelte MIME-Kodierung nur mit PGP-MIME erlaubt!"
    GOTO ErrorOutMail
  END;
  IF ("Content-Type:"-Zeile enthält einen "name=..."-Parameter)
  THEN
    BlockName := (Dateiname aus dem "name=..."-Parameter)
  END;
END;

IF (Block enthält in seinen Header-Zeilen einen
   "Content-Disposition:"-Eintrag)
THEN
  IF ("Content-Disposition:"-Zeile enthält einen
     "filename=..."-Parameter)
  THEN
    BlockName := (Dateiname aus dem "filename=..."-Parameter)
  END;
END;

Sprungmarke "OutFileNameOK":

IF (Zielformat="PGP-MIME")
THEN
  Fensterinhalt als Datei M.SRC [Message Source] speichern;
  KryptoTyp := "PGP-MIME";
  GOTO Encrypt
END;

IF (TransferTyp="unkodiert")
THEN
  Fensterinhalt als Datei M.SRC [Message Source] speichern;
  KryptoTyp := "Text";
  GOTO Encrypt
END;

  [Hier ist unser Block entweder MIME- oder UU-kodiert, und das
  Zielformat hat die Einstellung "PGP". Da beim Zielformat "PGP"
  im Unterschied zu "PGP-MIME" die Originaldatei _vor_ der
  Transferkodierung verschlüsselt/signiert wird, müssen
  wir den Block vor dem Verschlüsseln/Signieren wieder aus
  dem MIME- oder UU-Format dekodieren:]

Fensterinhalt als Datei M.SRC speichern;
Programmaufruf der Art: "mailin m.src"
  [Das Programm MAILIN ist der Dekodierer, den wir schon aus dem
  Schritt 3, "Abwicklung von Signatur/Entschlüsselung bei
  Eingangsmails", kennen.]
Ergebnisdatei MAIL.MSG laden, die ersten 4 Zeilen löschen [sie
  enthalten "Date:", "From:", "Subj:" und eine Leerzeile, die wir
  nicht brauchen], und ggf. auch die 5. Zeile löschen, falls sie
  den Text "----- Anfang von:" enthält [im Fall einer
  UU-kodierten Datei];
IF (Datei MAIL.MSG enthält Zeilen, die mit ".HA" beginnen)
  [Hinweis: Diese Zeilen verweisen auf Binärdateien, die ins
  Quarantäne-Verzeichnis gelegt wurden]
THEN
  IF (es gibt mehrere solche Zeilen)
  THEN
    Msg := "Mehrteilige Kodierungen nur mit PGP-MIME erlaubt!"
    GOTO ErrorOutMail
  END;
  Schiebe die Original-Binärdatei [der Dateiname steht in der
    2. Angabe der .HA-Zeile] aus dem Quarantäneverzeichnis in das
    PGP-Verzeichnis und gib ihr dort den Namen M.SRC;
  KryptoTyp := "Binär"
ELSE
  Speichere die (geladene und um 4 bzw. 5 Zeilen gekürzte) Datei
    MAIL.MSG in das PGP-Verzeichnis unter dem Namen M.SRC;
  KryptoTyp := "Text"
END;

Sprungmarke "Encrypt":

  [Hier erfolgt der zentrale PGP-Aufruf zum Verschlüsseln bzw.
  Signieren der Ausgangsmail:]

BlockName := BlockName + ".asc";
Lösche eine ggf. vorhandene Datei M.DST (Message Destination);

IF (KryptoTyp="Text")
THEN
  IF ('Optionen' enhält "V" und "S")
  THEN
    Programmaufruf der folgenden Art (in 1 Zeile!):
    'pgp -e -at m.src -o m.dst +batchmode -r <EmpfängerID>
         -s -u <SigID> -z"<SigMantra>"'
  ELSIF ('Optionen' enthält "V")
  THEN
    Programmaufruf der folgenden Art:
    'pgp -e -at m.src -o m.dst +batchmode -r <EmpfängerID>'
  ELSE [nur signieren:]
    Programmaufruf der folgenden Art:
    'pgp -s -at m.src -o m.dst +batchmode -u <SigID> -z"<SigMantra>"'
  END;
ELSIF (KryptoTyp="Binär")
THEN
  IF ('Optionen' enhält "V" und "S")
  THEN
    Programmaufruf der folgenden Art (in 1 Zeile!):
    'pgp -e -a m.src -o m.dst +batchmode -r <EmpfängerID>
         -s -u <SigID> -z"<SigMantra>"'
  ELSIF ('Optionen' enthält "V")
  THEN
    Programmaufruf der folgenden Art:
    'pgp -e -a m.src -o m.dst +batchmode -r <EmpfängerID>'
  ELSE [nur signieren:]
    Programmaufruf der folgenden Art:
    'pgp -s -a m.src -o m.dst +batchmode -u <SigID> -z"<SigMantra>"'
  END;
ELSE [hier gilt: KryptoTyp="PGP-MIME"]
  IF ('Optionen' enhält "V" und "S")
  THEN
    Programmaufruf der folgenden Art (in 1 Zeile!):
    'pgp -e -at m.src -o m.dst +batchmode +pgp_mime
         -r <EmpfängerID> -s -u <SigID> -z"<SigMantra>"'
  ELSIF ('Optionen' enthält "V")
  THEN
    Programmaufruf der folgenden Art:
    'pgp -e -at m.src -o m.dst +batchmode +pgp_mime -r <EmpfängerID>'
  ELSE [nur signieren:]
    Programmaufruf der folgenden Art (in 1 Zeile!):
    'pgp -s -at m.src -o m.dst +batchmode +pgp_mime
         -u <SigID> -z"<SigMantra>"'
  END;
END;

  [Hinweis: Die obigen Programmaufrufe sind für PGP 5.0 (DOS)
  angegeben und sind bei Verwendung anderer PGP-Versionen oder
  des "Gnu Privacy Guard" entsprechend anzupassen.]

IF (Datei M.DST existiert nicht oder hat 0 Bytes Größe)
THEN
  IF ('Optionen' enthält "V")
  THEN
    Msg := "Kein gültiger Empfängerschlüssel gefunden!"
  ELSE
    Msg := "Fehler beim Signieren!"
  END;
  GOTO ErrorOutMail
END;

  [Typ der Ergebnisdatei bestimmen - bei reiner Signatur kann er
  von 7-Bit abweichen:]

Programmaufruf: "filetype m.dst"
  [Hinweis: Das Programm FILETYPE ist das Dateityp-Prüfprogramm,
  das wir schon aus dem Schritt 3, "Abwicklung von
  Signatur/Entschlüsselung bei Eingangsmails", kennen. Es
  unterscheidet 5 Typen und schreibt das Ergebnis als Datei
  FILETYPE.LST (mit 1 Byte Größe):
    A = Textdatei mit 7-Bit-ASCII-Zeichen
    L = Textdatei mit 8-Bit-Zeichen innerhalb von Latin1
    T = Textdatei mit 8-Bit-Zeichen außerhalb von Latin1
    M = Komforttext-Makro o.ä. (enthält CHR$(0)-Zeichen)
    B = Binärdatei]

Datei FILETYPE.LST laden; erstes Zeichen prüfen:
IF (Zeichen="A")
THEN
  DateiTyp := "7-Bit"
ELSIF (Zeichen="L")
THEN
  DateiTyp := "Latin1"
ELSE [Zeichen="T" oder "M" oder "B"]
  DateiTyp := "8-Bit"
END;

IF ('Optionen' enthält kein "V) AND
   (KryptoTyp="Text") AND
   (DateiTyp<>"7-Bit") AND
   ((TransferTyp="MIME-einteilig") OR (TransferTyp="MIME-mehrteilig"))
THEN
  [Hier handelt es sich um eine signierte Klartext-Mail, die im
  MIME-Format gesandt wird, aber zum jetzigen Zeitpunkt noch
  Zeichen außerhalb des 7-Bit-Zeichensatzes enthält:]

  IF (DateiTyp="Latin1")
  THEN
    Programmaufruf der Art: "mailout m.dst/Q"
  ELSE
    Programmaufruf der Art: "mailout m.dst/B<BlockName>"
  END;

  [Hinweis: Das Programm MAILOUT ist der Kodierer, den wir schon
  aus dem Schritt 3, "Abwicklung von Signatur/Entschlüsselung bei
  Eingangsmails", kennen. Er wandelt hier die Datei M.DST ins
  MIME-Format um, und zwar in "MIME Quoted-Printable", falls die
  Datei nur Latin1-Zeichen enthielt, sonst in "MIME Base64".
  ("MIME Base64" ist hier ggf. erforderlich, obwohl die Datei
  eine Textdatei ist, denn "MIME Quoted-Printable" kann nur den
  Latin1-Zeichensatz unverfälscht kodieren, und eine Verfälschung
  irgendwelcher Zeichen können wir uns bei einer signierten Mail
  natürlich nicht erlauben.)]
END;

Datei M.DST laden;

IF (1. Zeile enthält keinen "MIME-Version: ..."-Eintrag)
THEN
  IF (TransferTyp="MIME-einteilig") OR
     (TransferTyp="MIME-mehrteilig") OR
     ((TransferTyp="UU-kodiert") AND (KryptoTyp="Binär"))
  THEN
     [Hinweis: Bei Mails im MIME-Format ist es naheliegend, daß
     auch das Ergebnis der Verschlüsselung/Signatur wieder mit
     korrekten MIME-Headerzeilen versehen werden muß. Jedoch ist
     auch bei UU-kodierten Mails im Fall von Binärdateien ein
     "Verpacken" des Ergebnisses in einem MIME-Rahmen
     erforderlich, weil sonst Programme wie z.B. "Eudora" die
     Datei fälschlich als Text interpretieren (obwohl die
     OpenPGP-Paketstruktur den Inhalt eigentlich klar als "binär"
     deklariert - aber wir sind ja großzügig und kommen allen
     Programmen entgegen).]

     IF (1. Zeile der Datei ist nicht leer)
     THEN
       Fülle eine Leerzeile vorweg ein
     END;
     Fülle eine neue 1. Zeile ein: "MIME-Version: 1.0";
     IF (KryptoTyp="Binär")
     THEN
       Fülle eine neue 2. Zeile mit folgendem Inhalt ein:
         'Content-Type: application/octet-stream; name="<BlockName>"'
       Fülle eine neue 3. Zeile mit folgendem Inhalt ein:
         'Content-Transfer-Encoding: 7bit'
       Fülle eine neue 4. Zeile mit folgendem Inhalt ein:
         'Content-Disposition: attachment; filename="<BlockName>"'
     ELSE
       Fülle eine neue 2. Zeile mit folgendem Inhalt ein:
         'Content-Type: text/plain; charset="ISO-8859-1"'
       Fülle eine neue 3. Zeile mit folgendem Inhalt ein:
         'Content-Transfer-Encoding: 7bit'
     END;
  END;
END;

IF (TransferTyp="MIME-mehrteilig") AND
   (1. Zeile enthält einen "MIME-Version: ..."-Eintrag)
THEN
  Lösche die 1. Zeile
  [Hinweis: Bei einer mehrteiligen MIME-Datei darf die Zeile
  "MIME-Version: ..." nur im MIME-Rahmen und nicht mehr in den
  einzelnen Teilen erscheinen.]
END;

Speichere die Datei M.DST (falls sie durch die obigen Schritte
  geändert wurde), schließe das Fenster und kehre zum
  Fenster mit der Original-Ausgangsmail zurück;

IF (TransferTyp="UU-kodiert) AND (KryptoTyp="Binär")
THEN
  Lösche die Leerzeile(n) nach der letzten Header-Zeile, und
    reduziere den Wert der Variablen 'AnfZeile' entsprechend
  [Hinweis: In diesem Fall wurde das verschlüsselte bzw.
  signierte Ergebnis in einen MIME-Rahmen gebettet. Dieser muß
  ohne Leerzeile direkt an die letzte Header-Zeile der Mail
  angefügt werden.]
END;

Füge den Inhalt der Datei M.DST vor die Zeile Nr. 'AnfZeile' in
  das Fenster mit der Original-Ausgangsmail ein;
EndZeile := (Nr. der letzten Zeile, die eingefügt wurde);

IF (TransferTyp="MIME-mehrteilig")
THEN
  GOTO NextOutBlock
ELSE
  GOTO DoneOutMail
END;

Sprungmarke "ErrorOutMail":

  [Hinweis: Dies ist die zentrale Fehlerbehandlungsroutine des
  Verschlüsselungmoduls. Das Anzeigen einer Fehlermeldung an
  dieser Stelle hilft allerdings nichts, da zu diesem Zeitpunkt
  wahrscheinlich gar kein Benutzer in der Nähe des
  Mailservers sein wird, der diese Fehlermeldung zur Kenntnis
  nehmen könnte. Daher erzeugen wir im Fall eines Fehlers eine
  "Antwortmail" an den Absender im Haus, die die Fehlermeldung
  und danach die fehlerhafte Ausgangsmail enthält. Die
  folgende Vorgehensweise ist ein Beispiel dafür, wie ein
  solcher "Fehlerbericht" aussehen könnte.]

Erzeuge eine Datei folgender Art:
  To: <From>     [<- Absender im Haus]
  Date: ...
  Subject: KT-MAIL/Krypto-Fehlermeldung
  From: ktmail@localhost
  <Leerzeile>
  <hier steht der Inhalt der Variablen 'Msg'>
  <Leerzeile>
  <ab hier kommt die fehlerhafte Datei>

Schleuse diese Datei ins normale Mail-System zur Zustellung an
  den Absender im Haus ein [siehe Teil IIIa, "Einfügen einer
  Dateischnittstelle in ein bestehendes Mail-System"].
Schließe alle Fenster.
Lösche die Original-Ausgangsmail aus der Ausgangs-Warteschlange.
GOTO ENDE

Sprungmarke "DoneOutMail":

Ausgangsmail speichern, falls der obige Vorgang zu Änderungen
  geführt hat.

ENDE der Verschlüsselungsroutine von KT-MAIL/Krypto.

  [Hinweis: Im Fall von KT-MAIL wird die Verschlüsselungsroutine
  automatisch für jede Ausgangsmail einzeln aufgerufen. Bei
  anderen Mail-Systemen ist daher der obige Ablauf ggf. um eine
  Schleife über alle wartenden Ausgangsmails zu ergänzen.]


Damit sind die Schritte des Leitfadens für Programmierer einer
automatischen Ver-/Entschlüsselung/Signatur abgeschlossen.

- Wolfgang Redtenbacher
  "signatur"-Moderator

[Zurück zur Hauptseite des Verschlüsselungsprojekts]