 /********************************************************************/
/*                                                                   */
/*   PGP for GoldEd 4.x - Arexx Script                               */
/*                                                                   */
/*                                                                   */
/*              ´GoldED4´ - © Ditmar Eilert                       */
/*                                                                   */
/*           ´rexxreqtools.library´ © Nico François                  */
/*                                                                   */
/*                                                                   */
/*  Author: Lunz O. Wolfgang (Luwo)                                  */
/*         <W.LUNZ@link-ba.cl.sub.de>                                */
/*                                                                   */
/*  Adapted to GoldED4 by P!\K/Un0X                                  */
/*         <bstegema@ix.urz.uni-heidelberg.de>                       */
/*                                                                   */
/*  Hinweis: ´MERGE´en des PGP.men an das für Textverarbeitung       */
/*           verwendete GoldEd-Menü!                                 */
/*           & diesen Script in das 'REXX:'-Verzeichnis kopieren     */
/*                                                                   */
/*                                                                   */
/*   $VER: PGP-GoldEd-Script V0.91  ©Luwo (29.04.1994)               */
/*                                                                   */
/*********************************************************************/



ADDRESS COMMAND  'STACK 12000'        /* PGP ist ziemlich hungrig :) */

lib = 'rexxreqtools.library'
if ~show('l',lib) then call addlib(lib,0,-30,0)



OPTIONS RESULTS                            /* enable return codes    */

if (LEFT(ADDRESS(), 6) ~= "GOLDED") then   /* not started by GoldEd ?*/
    ADDRESS 'GOLDED.1'

'LOCK CURRENT RELEASE=4'                   /* lock GUI, gain access  */
 OPTIONS FAILAT 6                          /* ignore warnings        */
SIGNAL ON SYNTAX                           /* ensure clean exit      */
SIGNAL ON ERROR                            /* trap errors            */


USERFILE = 'T:PGP_userIDs.tmp'           /* einige Standard-Variablen*/
UserPath = 'T:Users'
IDstring = '0x'
NL       = '0a'x
CLRSCR   = '0c'x
PGP      = SEARCHPATH()   /* den Pfad aus der PGPPATH-Variablen lesen*/


'QUERY DOC VAR DEFAULTFILENAME'         /* wurde die Blockmarkierung */
'QUERY MARKED VAR BLOCKMARKIERUNG'      /* aktiviert?                */
ORGFILENAME=DEFAULTFILENAME

IF BLOCKMARKIERUNG="TRUE" then  ORGFILENAME=DEFAULTFILENAME'.block'



/* --------- Begin der Verzweigungsroutine ------------------------- */



IF ARG(1)="READ_PGP" then READ_PGP()   /* SubProg, je nach Parameter */
IF ARG(1)="WRITE_PGP" then WRITE_PGP()
IF ARG(1)="ENCODE_normal" then ENCODE_normal()
IF ARG(1)="DECODE_normal" then DECODE_normal()
IF ARG(1)="UNTERSCHREIBEN" then UNTERSCHREIBEN()
IF ARG(1)="KEY_aufnehmen" then KEY_aufnehmen()
IF ARG(1)="KEY_ansehen" then KEY_ansehen()
IF ARG(1)="KEY_editieren" then KEY_editieren()
IF ARG(1)="KEY_entfernen" then KEY_entfernen()
IF ARG(1)="KEY_beglaubigen" then KEY_beglaubigen()
IF ARG(1)="KEY_anhaengen" then KEY_anhaengen()
IF ARG(1)="KEY_generieren" then KEY_generieren()


/* Kein verfügbarer Parameter ! */


ADDRESS "GOLDED.1" 
'REQUEST BODY "PGP-Script-Error!" BUTTON "Shit!"'
 REALLYQUIT()

/*----------- Ende der Verzweigungsroutine --------------------------*/

/*-------------------------------------------------------------------*/
READ_PGP:                     /* PGP analysiert den Text selbständig */

     CALL SAVER()
     ADDRESS COMMAND  PGP '+FORCE 'ORGFILENAME' -o'ORGFILENAME
     CALL LOADER()
REALLYQUIT('k')
end
/*-------------------------------------------------------------------*/



/*-------------------------------------------------------------------*/
WRITE_PGP:                   /* Der Text wird für die entsprechenden */
                             /* Empfänger codiert...                 */
      CALL SAVER()
      REQTITEL="Choose a recipient..."
      empfaengerliste = GETEMPFAENGER()
        if empfaengerliste ~= '' then
            do
             ADDRESS COMMAND
             PGP '-esta +FORCE 'ORGFILENAME EMPFAENGERLISTE
             'c:copy >nil: 'ORGFILENAME'.asc 'ORGFILENAME
             'c:delete >nil: 'ORGFILENAME'.asc'
            end
      CALL LOADER()
REALLYQUIT()
end
/*-------------------------------------------------------------------*/


/*-------------------------------------------------------------------*/
ENCODE_normal:       /* Der Text wird mit einem Mantra verschlüsselt */

       CALL SAVER()
        ADDRESS COMMAND
        PGP '-cta ' ORGFILENAME
       'C:copy >nil: 'ORGFILENAME'.asc 'ORGFILENAME
       'c:delete >nil: 'ORGFILENAME'.asc'
       CALL LOADER()   /* 'OPEN AGAIN' */
REALLYQUIT()
end
/*-------------------------------------------------------------------*/


/*-------------------------------------------------------------------*/
DECODE_normal:       /* Der Text wird mit einem Mantra entschlüsselt */

       CALL SAVER()
        ADDRESS COMMAND
       PGP '-d +FORCE 'ORGFILENAME' -o'ORGFILENAME
       CALL LOADER()
REALLYQUIT()
end
/*-------------------------------------------------------------------*/

/*-------------------------------------------------------------------*/
UNTERSCHREIBEN:       /* Der Text wird mit der persönlichen Signatur */
                      /* unterschrieben, und ggfs. komprimiert       */

          TITXT = 'Add signature...'
          BTTXT = '_Yes|_No'
          BDTXT = 'Would you like the text compressed?'
          call ABFRAGE()
          if ergebnis =0 then
               signcmd=' -sat +clearsig=on '
            else
               signcmd=' -sat +clearsig=off '

       CALL SAVER()
           ADDRESS COMMAND
           PGP SIGNCMD ORGFILENAME
          'C:copy >nil: 'ORGFILENAME'.asc 'ORGFILENAME
          'c:delete >nil: 'ORGFILENAME'.asc'
       CALL LOADER()
REALLYQUIT()
end
/*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*/
KEY_aufnehmen:
     CALL SAVER()
     ADDRESS COMMAND
     PGP '-ka '|| ORGFILENAME
     'c:delete >nil: 'USERFILE
     CALL LOADER()
REALLYQUIT('key')
end
/*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*/
KEY_ansehen:
     REQTITEL="Look at which Key?..."
     empfaengerliste = GETEMPFAENGER()
     if empfaengerliste ~= '' then
        do
          ADDRESS COMMAND
          PGP '-kvvc '|| empfaengerliste
          REALLYQUIT('key')
        end
REALLYQUIT()
end
/*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*/
KEY_editieren:
     REQTITEL="Edit which Key?..."
     empfaengerliste = GETEMPFAENGER()
     if empfaengerliste ~= '' then
        do
          ADDRESS COMMAND
          PGP '-ke '|| empfaengerliste
          REALLYQUIT('key')
        end
REALLYQUIT()
end
/*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*/
KEY_entfernen:
     REQTITEL="Remove which Key?..."
     empfaengerliste = GETEMPFAENGER()
     if empfaengerliste ~= '' then
        do
          ADDRESS 'GOLDED.1'
          TITXT = 'Remove Public-key?'
          BTTXT = '_No|_Yes'
          BDTXT = namensliste
          call ABFRAGE()
          if ergebnis =0 then
            do
               ADDRESS COMMAND
               PGP '-kr ' empfaengerliste
               'c:delete >nil: 'USERFILE' T:users ALL'
               REALLYQUIT('key')
            end
        end
REALLYQUIT()
end
/*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*/
KEY_beglaubigen:
   REQTITEL="Authenticate which Key?..."
   empfaengerliste = GETEMPFAENGER()
     if empfaengerliste ~= '' then
        do
          ADDRESS COMMAND
          PGP '-ks '|| empfaengerliste
          REALLYQUIT('key')
        end
REALLYQUIT()
end
/*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*/
KEY_anhaengen:

   RADIXcmd='INSERT'
   REQTITEL="Insert RADIX-64-Key..."

     empfaengerliste = GETEMPFAENGER()
     if empfaengerliste ~= '' then
       do
            do i = 1 to words(empfaengerliste)
             ADDRESS COMMAND
             PGP '-fkxa 'word(empfaengerliste,i) ' >t:PGPextract.tmp'i
            end

             ADDRESS 'GOLDED.1'
            'QUERY ABSLINE VAR LIN'
            'QUERY COLUMN VAR COL'
            'REQUEST BODY="Wo wollen Sie den(die)|   RADIX-64 (ASCII)  |PublicKey(s) einfügen?"
             TITLE="   Radix-64 Public-Key insert:"
             BUTTON="_Cursor|Text_ende|_Vergiß es!" VAR ERGEBNIS'

            if ERGEBNIS = 2 then RADIXcmd='APPEND'

            if ERGEBNIS ~= 0 then
               do i = 1 to words(empfaengerliste)
                  'OPEN 'RADIXcmd' T:PGPextract.tmp'i
                  'SAVE ALL'
               end

            GOTO LINE LIN COLUMN COL
            address command 'c:delete >nil: t:PGPextract.tmp#?'

       end

REALLYQUIT()
end
/*--------------------------------------------------------------------*/


/*--------------------------------------------------------------------*/
KEY_generieren:
          TITXT = 'Generate a Secret Key?'
          BTTXT = '_No|_Yes'
          BDTXT = ' Would you like to | create a new | Secret Key?'
          call ABFRAGE()
          if ergebnis =0 then
           do
             ADDRESS COMMAND
              PGP '-kg '
              'c:delete >nil: '||USERFILE
             REALLYQUIT('key')
           end
REALLYQUIT()
end

/*--------------------------------------------------------------------*/



/* ---------------- Auswahl der Empfaenger--------------------------- */
GETEMPFAENGER:

ADDRESS COMMAND
drop empfaengerliste
PGPcmd   = ''
namensliste= ''

/* ist der T:user-Path schon da? */
 if ~EXISTS(UserPath) then 'C:makedir ' USERPATH

/* sind die UserIds schon extrahiert? */
 if ~EXISTS(USERFILE) then  call MAKEUSERLISTE()

call rtfilerequest("T:Users/", , REQTITEL, ,"rtfi_flags=freqf_multiselect rt_pubscrname=GOLDED.1",empfaenger)

if empfaenger == 1 then
  do
    do i=1 to empfaenger.count
      call Open('USID',empfaenger.i,"R")
      dummy = readch('USID',8)
      call Close('USID')

      if left(dummy,2)="0x" then
        do
          PGPcmd=PGPcmd dummy
      namensliste =namensliste right(empfaenger.i,length(empfaenger.i)-8) '|'
        end
    end
  end

  call rtfreefilebuffer()
return PGPcmd
/*--------------------------------------------------------------------*/


/* Erstellen der aus der pubring.key-datei extrahierten User Ids */
MAKEUSERLISTE:
    ADDRESS COMMAND PGP ' -kv >'USERFILE
       call Open('UFID',USERFILE,'R')
           do until EOF('UFID')=1
              dummy = READLN('UFID')

                if (UPPER(LEFT(dummy,3))="PUB")&(word(dummy,4)~='***') then

                  do
                    keyid = right(word(dummy,2),6)
                    namestart= wordindex(dummy,4)
                    nameend= pos('<',dummy)
                     if nameend=0 then nameend=LENGTH(dummy)+2
                    namelength=nameend-namestart-1
                    name=substr(dummy,namestart,namelength)
                    name=compress(name,':;/><')

                    call Open('currentUser',UserPath'/'name,'W')
                    call Writech('currentUser',IDSTRING||KEYID)
                    call Close('currentUser')

                  end

           end
       call Close('UFID')
say Clrscr
return
/*--------------------------------------------------------------------*/


/* ------------------- diverse Unterprogramme ----------------------- */

SAVER:               /* Speichert, je nachdem, ob die Blockmarkierung */
                     /* aktiviert wurde oder nicht, den ganzen Text,  */
                     /* oder nur einen Ausschnitt daraus ab...        */
ADDRESS "GOLDED.1"
if BLOCKMARKIERUNG="FALSE" then
    do
      'SAVE ALL'
    return 0
    end

if BLOCKMARKIERUNG="TRUE" then
    do
      SAVE BLOCK NAME ORGFILENAME
    return 0
    end
end

/*--------------------------------------------------------------------*/
LOADER:         /* Lädt, je nachdem, ob die Blockmarkierung aktiviert */
                /* wurde oder nicht, den ganzen Text, oder auch nur   */
                /* einen Block wieder ein...                          */

ADDRESS "GOLDED.1"
if BLOCKMARKIERUNG="FALSE" then
    do
      'OPEN AGAIN'
    return 0
    end

if BLOCKMARKIERUNG="TRUE" then
    do
      DELETE BLOCK
      OPEN INSERT NAME ORGFILENAME
      ADDRESS COMMAND 'c:delete >nil: 'ORGFILENAME
    return 0
    end
end


/*--------------------------------------------------------------------*/
SEARCHPATH:

ADDRESS COMMAND
if exists('env:PGPPATH') then
    do
     call Open('binpath','ENV:PGPPATH','R')
     dummy=readln('binpath')
     call Close('binpath')
     if (right(dummy, 1) ~= "/") & (right(dummy, 1) ~= ":") then
        dummy = dummy||'/'
     dummy='PGP="'dummy||'bin/pgp"'
     interpret  dummy
    end

else
    do
     ADDRESS "GOLDED.1"
     TITXT = 'PGP-AREXX-INTERNAL-ERROR'
     BTTXT = '_OK'
     BDTXT = "The PGPPATH variable is not set!|      Please declare this variable !    |    Until set 'C:PGP' will be used.   "
     call ABFRAGE()
     return 'c:pgp'
    end

ADDRESS COMMAND
return PGP
end


/*--------------------------------------------------------------------*/
ABFRAGE:                              /* Erstellt einen Requester...  */

ADDRESS "GOLDED.1"
'REQUEST TITLE="'TITXT'" BODY="'BDTXT'" BUTTON="'BTTXT'" VAR ERGEBNIS'
return 0
end


/*--------------------------------------------------------------------*/
REALLYQUIT:
ADDRESS "GOLDED.1"
arg QUITTER

if QUITTER~=''then
    do
      say NL 'Please press "Return" to continue...'
      pull QUITTER
    end
'NAME 'DEFAULTFILENAME
'UNLOCK'                                  /* Sehr wichtig: unlock GUI */
EXIT

/*--------------------------------------------------------------------*/
ERROR:
      say NL 'An error ('RC') occured in line:'SIGL' of PGP.ged :-('
      say    '-=> [Press return]'
      pull QUITTER

ADDRESS "GOLDED.1"
'NAME 'DEFAULTFILENAME
'UNLOCK'
EXIT


/*--------------------------------------------------------------------*/
SYNTAX:
 ADDRESS "GOLDED.1"
SAY "Sorry, Syntax-error line" SIGL ":" ERRORTEXT(RC) ":-("
'UNLOCK'
/*--------------------------------------------------------------------*/

