home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / rsys-1.3.lha / RSys-1.3 / src / RSysCrypt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-12  |  20.7 KB  |  769 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysCrypt.c
  6. *
  7. * Inhalt:
  8. *    int OpenCryptWindow(void);
  9. *    void CryptFile(void);
  10. *
  11. * Bemerkungen:
  12. *    Verschlüsselungsroutinen von RSys.
  13. *
  14. * Erstellungsdatum:
  15. *    07-Jul-93    Rolf Böhme
  16. *
  17. * Änderungen:
  18. *    07-Jul-93    Rolf Böhme    Erstellung
  19. *
  20. ***************************************************************************
  21. */
  22.  
  23. #include "RSysFunc.h"
  24. #include "RSysDebug.h"
  25.  
  26.    /*
  27.     * Standardtyp der Verschlüsselungart.
  28.     */
  29. static int type = CRY;
  30.  
  31. static enum
  32. {
  33.    GD_SourceStrGad,
  34.    GD_CryptStrGad,
  35.    GD_SelSourceGad,
  36.    GD_SelDestGad,
  37.    GD_CryptGad,
  38.    GD_DeccryptGad,
  39.    GD_PwdGad,
  40.    GD_TypeCYGad
  41. };
  42.  
  43. #define Crypt_CNT 8
  44.  
  45.    /*
  46.     * Die Intuition-Objekte für den Aufbau des
  47.     * Crypt-Windows.
  48.     */
  49. static struct Window *CryptWnd = NULL;
  50. static struct Gadget *CryptGList = NULL;
  51. static struct Gadget *CryptGadgets[8];
  52. static UWORD CryptLeft = 213;
  53. static UWORD CryptTop = 76;
  54. static UWORD CryptWidth = 278;
  55. static UWORD CryptHeight = 76;
  56. static UBYTE *CryptWdt = (UBYTE *) NAME " " VERSION " - Crypting Files";
  57.  
  58.    /*
  59.     * Diese Datei-lokale Struktur beinhaltet die Namen
  60.     * der Original- und der verschlüsselten Datei, sowie
  61.     * das Paßwort im Falle der Verschlüsselung mit dem
  62.     * "zellulären Automaten".
  63.     */
  64. static struct _cryptdata
  65. {
  66.    char  cr_datafile[MAXFULLNAME],
  67.          cr_cryptfile[MAXFULLNAME],
  68.          cr_pwd[20];
  69. }     cd =
  70.  
  71. {
  72.    "", "", "tiger"
  73. };
  74.  
  75. static UBYTE *TypeCYGad0Labels[] = {
  76.    (UBYTE *)"Crypt",
  77.    (UBYTE *)"ROT 13",
  78.    NULL };
  79.  
  80. static UWORD CryptGTypes[] = {
  81.    STRING_KIND,
  82.    STRING_KIND,
  83.    BUTTON_KIND,
  84.    BUTTON_KIND,
  85.    BUTTON_KIND,
  86.    BUTTON_KIND,
  87.    STRING_KIND,
  88.    CYCLE_KIND
  89. };
  90.  
  91. static struct NewGadget CryptNGad[] = {
  92.    66, 5, 132, 13, (UBYTE *)"Source", NULL, GD_SourceStrGad, PLACETEXT_LEFT, NULL, NULL,
  93.    66, 19, 132, 13, (UBYTE *)"Dest", NULL, GD_CryptStrGad, PLACETEXT_LEFT, NULL, NULL,
  94.    204, 5, 69, 13, (UBYTE *)"Select", NULL, GD_SelSourceGad, PLACETEXT_IN, NULL, NULL,
  95.    204, 19, 69, 13, (UBYTE *)"Select", NULL, GD_SelDestGad, PLACETEXT_IN, NULL, NULL,
  96.    98, 59, 81, 13, (UBYTE *)"Encrypt", NULL, GD_CryptGad, PLACETEXT_IN, NULL, NULL,
  97.    192, 59, 81, 13, (UBYTE *)"Decrypt", NULL, GD_DeccryptGad, PLACETEXT_IN, NULL, NULL,
  98.    66, 39, 207, 13, (UBYTE *)"Passwd", NULL, GD_PwdGad, PLACETEXT_LEFT,NULL,NULL,
  99.    4, 59, 81, 13, NULL, NULL, GD_TypeCYGad, 0, NULL, NULL
  100. };
  101.  
  102. static ULONG *CryptGTags[] = {
  103.    (ULONG *)(GTST_MaxChars), (ULONG *)MAXLINESIZE, (ULONG *)(TAG_DONE),
  104.    (ULONG *)(GTST_MaxChars), (ULONG *)MAXLINESIZE, (ULONG *)(TAG_DONE),
  105.    (ULONG *)(TAG_DONE),
  106.    (ULONG *)(TAG_DONE),
  107.    (ULONG *)(TAG_DONE),
  108.    (ULONG *)(TAG_DONE),
  109.    (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  110.    (ULONG * )(GTCY_Labels), (ULONG *)&TypeCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE)
  111. };
  112.  
  113.    /*
  114.     * Die Prozedur WindTitleInfo() läßt eine Nachricht in
  115.     * der Titelzeile des Crypt-Fensters erscheinen.
  116.     */
  117. static void
  118. WindTitleInfo(char *msg)
  119. {
  120.    SetWindowTitles(CryptWnd,(UBYTE *)(msg),(UBYTE *)(-1));
  121.    return;
  122. }
  123.  
  124.    /*
  125.     * OpenCryptWindow() öffnet ein Fenster mit allen Kontrollelementen
  126.     */
  127. int
  128. OpenCryptWindow( void )
  129. {
  130.    struct NewGadget   ng;
  131.    struct Gadget   *g;
  132.    UWORD      lc, tc;
  133.    UWORD      wleft = CryptLeft, wtop = CryptTop, ww, wh;
  134.    int gl[] = {0,1,6};
  135.  
  136.    DPOS;
  137.  
  138.    ComputeFont( Scr,CryptWidth, CryptHeight );
  139.  
  140.    ww = ComputeX( CryptWidth );
  141.    wh = ComputeY( CryptHeight );
  142.  
  143.    if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
  144.    if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
  145.  
  146.    ww = compute((UWORD) (OffX + Scr->WBorRight), FontX, (int)CryptWidth);
  147.    wh = compute((UWORD) (OffY + Scr->WBorBottom), FontY, (int)CryptHeight);
  148.  
  149.    CenterWindow(Scr, &wtop, &wleft, ww, wh);
  150.  
  151.    if ( ! ( g = CreateContext( &CryptGList )))
  152.       return( 1L );
  153.  
  154.    for( lc = 0, tc = 0; lc < Crypt_CNT; lc++ ) {
  155.  
  156.       CopyMem((char * )&CryptNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  157.  
  158.       ng.ng_VisualInfo = VisualInfo;
  159.       ng.ng_TextAttr   = Font;
  160.       ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  161.       ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  162.       ng.ng_Width      = ComputeX( ng.ng_Width );
  163.       ng.ng_Height     = ComputeY( ng.ng_Height);
  164.  
  165.       CryptGadgets[ lc ] = g = CreateGadgetA((ULONG)CryptGTypes[ lc ], g, &ng, ( struct TagItem * )&CryptGTags[ tc ] );
  166.  
  167.       makelabelvisible(CryptGadgets[lc]);
  168.  
  169.       while( CryptGTags[ tc ] ) tc += 2;
  170.       tc++;
  171.  
  172.       if ( NOT g )
  173.          return( 2L );
  174.    }
  175.  
  176.    if ( ! ( CryptWnd = OpenWindowTags( NULL,
  177.             WA_Left,   wleft,
  178.             WA_Top,      wtop,
  179.             WA_Width,   ww,
  180.             WA_Height,   wh,
  181.             WA_IDCMP,   IDCMP_VANILLAKEY|
  182.                         STRINGIDCMP|
  183.                         BUTTONIDCMP|
  184.                         IDCMP_CLOSEWINDOW|
  185.                         IDCMP_REFRESHWINDOW,
  186.             WA_Flags,   WFLG_DRAGBAR|
  187.                         WFLG_DEPTHGADGET|
  188.                         WFLG_CLOSEGADGET|
  189.                         WFLG_SMART_REFRESH|
  190.                         WFLG_ACTIVATE|
  191.                         WFLG_RMBTRAP,
  192.             WA_Gadgets,   CryptGList,
  193.             WA_Title,   CryptWdt,
  194.             WA_PubScreenFallBack,TRUE,
  195.             WA_PubScreen, Scr,
  196.             TAG_DONE )))
  197.       return( 4L );
  198.  
  199.    RefreshRastPort(CryptWnd,CryptGadgets,gl, 3);
  200.  
  201.    if(Flags.autofront)
  202.    {
  203.       WindowToFront(CryptWnd);
  204.       ActivateWindow(CryptWnd);
  205.    }
  206.  
  207.    return( 0L );
  208. }
  209.  
  210.    /*
  211.     * refreshstrgad() erneuert den Inhalt eines Stringgadgets
  212.     */
  213. static void
  214. refreshstrgad(struct Gadget *gad, char *str)
  215. {
  216.    GT_SetGadgetAttrs(gad, CryptWnd, NULL,
  217.                      GTST_String, (UBYTE *) str,
  218.                      TAG_DONE);
  219.  
  220.    return;
  221. }
  222.  
  223.    /*
  224.     * Die nächsten Kommentare sind dem Programm-Quelltext von TERM entnommen.
  225.     * Olsen, danke für die Comments :-)
  226.     */
  227.     /*
  228.      * The width of the cell ring is defined here. A word of warning: never
  229.      * encrypt a file and forget the access password, since it will be
  230.      * extremely hard to break the code (with 30 cells there are 256^30
  231.      * possible values each cell may be initialized to which means that
  232.      * you could have to try more than 1.7e+72 combinations for each single
  233.      * password character before actually finding the matching password).
  234.      * See `Random sequence generation by cellular automata' by Steven
  235.      * Wolfram (Institute for Advanced Study; Advances in Applied
  236.      * Mathematics) for more information.
  237.      */
  238.  
  239. #define CELL_WIDTH 30
  240.  
  241.     /*
  242.      * The cell ring and the ring index pointers.
  243.      */
  244.  
  245. static UBYTE Cell[2][CELL_WIDTH + 2],
  246.       From,
  247.       To;
  248.  
  249.     /*
  250.      *  Automaton():
  251.      *
  252.      *   A cellular automaton working on a ring of celles, producing
  253.      *   random data in each single cell .
  254.      */
  255.  
  256. static UBYTE
  257. Automaton(void)
  258. {
  259.    register WORD i;
  260.  
  261.     /*
  262.      * Operate on the cell ring...
  263.      */
  264.  
  265.    for (i = 1; i <= CELL_WIDTH; i++)
  266.       Cell[To][i] = Cell[From][i - 1] ^ (Cell[From][i] | Cell[From][i + 1]);
  267.  
  268.     /*
  269.      * Operate on first and last element.
  270.      */
  271.  
  272.    Cell[To][0] = Cell[From][CELL_WIDTH + 1] ^ (Cell[From][0] | Cell[From][1]);
  273.    Cell[To][CELL_WIDTH + 1] = Cell[From][CELL_WIDTH] ^ (Cell[From][CELL_WIDTH + 1] | Cell[From][0]);
  274.  
  275.       /*
  276.        * Swap cell rings.
  277.        */
  278.    To = From;
  279.    From ^= 1;
  280.  
  281.       /*
  282.        * Return contents of first cell.
  283.        */
  284.    return (Cell[From][0]);
  285. }
  286.  
  287.     /*
  288.      * Encrypt(UBYTE *Source,UBYTE *Destination,UBYTE *Key):
  289.      * Encrypt data using cellular automaton as a random number generator.
  290.      */
  291.  
  292. static UBYTE *
  293. Encrypt(UBYTE * Source, long SourceLen, UBYTE * Destination, UBYTE * Key, WORD KeyLen)
  294. {
  295.    register long i,
  296.          j;
  297.  
  298.       /*
  299.        * Set up cell ring index pointers.
  300.        */
  301.    From = 0;
  302.    To = 1;
  303.  
  304.       /*
  305.        * Initialize the cell ring with the key contents.
  306.        */
  307.    for (i = 0, j = KeyLen - 1; i < CELL_WIDTH + 2; i++)
  308.    {
  309.       Cell[0][i] = Key[j];
  310.  
  311.       if (j)
  312.          j--;
  313.       else
  314.          j = KeyLen - 1;
  315.    }
  316.  
  317.       /*
  318.        * Encrypt the source data.
  319.        */
  320.    for (i = 0; i < SourceLen; i++)
  321.       Destination[i] = (UBYTE) (((WORD) Source[i] + Automaton())% 256);
  322.  
  323.       /*
  324.        * Return result.
  325.        */
  326.    return (Destination);
  327. }
  328.  
  329.     /*
  330.      * Decrypt(UBYTE *Source,UBYTE *Destination,UBYTE *Key):
  331.      *
  332.      *   Decrypt data using cellular automaton as a random number generator.
  333.      */
  334.  
  335. static UBYTE *
  336. Decrypt(UBYTE * Source, long SourceLen, UBYTE * Destination, UBYTE * Key, WORD KeyLen)
  337. {
  338.    register long i,
  339.          j,
  340.          Code;
  341.  
  342.       /*
  343.        * Set up cell ring index pointers.
  344.        */
  345.    From = 0;
  346.    To = 1;
  347.  
  348.       /*
  349.        * Initialize the cell ring with the key contents.
  350.        */
  351.    for (i = 0, j = KeyLen - 1; i < CELL_WIDTH + 2; i++)
  352.    {
  353.       Cell[0][i] = Key[j];
  354.  
  355.       if (j)
  356.          j--;
  357.       else
  358.          j = KeyLen - 1;
  359.    }
  360.  
  361.       /*
  362.        * Decrypt the source data.
  363.        */
  364.    for (i = 0; i < SourceLen; i++)
  365.    {
  366.       if ((Code = Source[i] - Automaton())< 0)
  367.          Code = 256 + Code;
  368.  
  369.       Destination[i] = (UBYTE) Code;
  370.    }
  371.  
  372.    return (Destination);
  373. }
  374.  
  375.    /*
  376.     * Die Prozedur MakeROT13() erzeugt aus einem
  377.     * Eingabestring buff eine Ausgabestring dest
  378.     * dergestalt, daß jeder Buchstabe um 13 Zeichen nach
  379.     * vorne oder hinten verschoben wird. Hier die
  380.     * Translationsliste:
  381.     *
  382.     * Input:      abcdefghijklmnopqrstuvwxyz
  383.     * Output:     nopqrstuvwxyzabcdefghijklm
  384.     *
  385.     * Input:      ABCDEFGHIJKLMNOPQRSTUVWXYZ
  386.     * Output:     NOPQRSTUVWXYZABCDEFGHIJKLM
  387.     */
  388. static void
  389. MakeROT13(UBYTE * buff, UBYTE * dest)
  390. {
  391.    UBYTE *destptr = &dest[0];
  392.    char  ch;
  393.  
  394.    strcpy((char *)dest, (char *)buff);
  395.  
  396.    while (*destptr)
  397.    {
  398.       ch = (char)(*destptr);
  399.  
  400.       if (isalpha((int)ch))
  401.       {
  402.          if (((ch >= 'A') && (ch < 'N')) ||
  403.              ((ch >= 'a') && (ch < 'n')))
  404.             *destptr = (UBYTE) (ch + 13);
  405.  
  406.          if (((ch >= 'N') && (ch <= 'Z')) ||
  407.              ((ch >= 'n') && (ch <= 'z')))
  408.             *destptr = (UBYTE) (ch - 13);
  409.       }
  410.  
  411.       destptr++;
  412.    }
  413.  
  414.    return;
  415. }
  416.  
  417.    /*
  418.     * Crypt() ver- oder entschlüsselt eine Datei
  419.     */
  420. static void
  421. Crypt(int encrypt)
  422. {
  423.    long  fsize;
  424.    char  pwd[PWDLEN+1],
  425.          cpwd[PWDLEN+1];
  426.    BPTR  Dfile,
  427.          Cfile;
  428.    UBYTE *Dbuffer,
  429.         *Cbuffer;
  430.    int   pwdlen;
  431.  
  432.    if (strlen(cd.cr_pwd) == 0)
  433.       strcpy(pwd, "tiger");
  434.    else
  435.       strncpy(pwd, cd.cr_pwd, PWDLEN);
  436.  
  437.    pwdlen = strlen(pwd);
  438.  
  439.    if (encrypt)
  440.    {
  441.       if (NOT(exist(cd.cr_datafile)))
  442.       {
  443.          ErrorHandle(FILE_ERR, EXIST_FAIL, NO_KILL);
  444.          return;
  445.       }
  446.  
  447.       if (type == R13)
  448.       {
  449.          extern int global_type;
  450.  
  451.          filetype(cd.cr_datafile);
  452.          if (global_type != TYPE_TEXT)
  453.          {
  454.             ErrorHandle(FILE_ERR, TYPE_FAIL, NO_KILL);
  455.             return;
  456.          }
  457.       }
  458.  
  459.       fsize = SizeOfFile(cd.cr_datafile);
  460.       if (fsize == 0L)
  461.       {
  462.          ErrorHandle(FILE_ERR, SIZE_FAIL, NO_KILL);
  463.          return;
  464.       }
  465.  
  466.       if (exist(cd.cr_cryptfile) &&
  467.           NOT(Question(CryptWnd, "Crypt file exist!\n"
  468.                        "Do you want to overwrite them?", YES)))
  469.          return;
  470.  
  471.       if (Dfile = Open((UBYTE *) cd.cr_datafile, MODE_OLDFILE))
  472.       {
  473.          if (Cfile = Open((UBYTE *) cd.cr_cryptfile, MODE_NEWFILE))
  474.          {
  475.             if ((Dbuffer = MyAllocVec((fsize + 1) * sizeof(UBYTE), MEMF_CLEAR, NO_KILL)) &&
  476.                 (Cbuffer = MyAllocVec((fsize + 1) * sizeof(UBYTE), MEMF_CLEAR, NO_KILL)))
  477.             {
  478.                WindTitleInfo("Reading datafile...");
  479.                if (fsize == Read(Dfile, Dbuffer, fsize))
  480.                {
  481.                   if (NOT(type))
  482.                   {
  483.                      WindTitleInfo("Encrypt password...");
  484.                      Encrypt((UBYTE *) pwd, (long) pwdlen, (UBYTE *) cpwd,
  485.                              (UBYTE *) pwd, (WORD) pwdlen);
  486.  
  487.                      if (pwdlen != Write(Cfile, cpwd, pwdlen))
  488.                         ErrorHandle(FILE_ERR, WRITE_FAIL, NO_KILL);
  489.                      else
  490.                      {
  491.                         WindTitleInfo("Encrypt data file...");
  492.                         Cbuffer = Encrypt(Dbuffer, (long)fsize,
  493.                                           Cbuffer, (UBYTE *) pwd, (WORD) pwdlen);
  494.                      }
  495.                   }
  496.                   else
  497.                   {
  498.                      WindTitleInfo("Rotate data file...");
  499.                      MakeROT13(Dbuffer, Cbuffer);
  500.                   }
  501.  
  502.                   WindTitleInfo(type ? "Writing ROT13 file..." : "Writing crypt file...");
  503.                   if (fsize != Write(Cfile, Cbuffer, fsize))
  504.                      ErrorHandle(FILE_ERR, WRITE_FAIL, NO_KILL);
  505.                }
  506.                else
  507.                   ErrorHandle(FILE_ERR, READ_FAIL, NO_KILL);
  508.  
  509.                MyFreeVec(Cbuffer);
  510.                MyFreeVec(Dbuffer);
  511.             }
  512.  
  513.             Close(Cfile);
  514.          }
  515.          else
  516.             ErrorHandle(FILE_ERR, OPEN_FAIL, NO_KILL);
  517.  
  518.          Close(Dfile);
  519.       }
  520.       else
  521.          ErrorHandle(FILE_ERR, OPEN_FAIL, NO_KILL);
  522.    }
  523.    else
  524.    {
  525.       if (NOT(exist(cd.cr_cryptfile)))
  526.       {
  527.          ErrorHandle(FILE_ERR, EXIST_FAIL, NO_KILL);
  528.          return;
  529.       }
  530.  
  531.       fsize = SizeOfFile(cd.cr_cryptfile);
  532.       if (fsize == 0L)
  533.       {
  534.          ErrorHandle(FILE_ERR, SIZE_FAIL, NO_KILL);
  535.          return;
  536.       }
  537.  
  538.       if (exist(cd.cr_datafile) &&
  539.           NOT(Question(CryptWnd, "Data file exist!\n"
  540.                        "Do you want to overwrite them?", YES)))
  541.          return;
  542.  
  543.       if (Dfile = Open((UBYTE *) cd.cr_datafile, MODE_NEWFILE))
  544.       {
  545.          if (Cfile = Open((UBYTE *) cd.cr_cryptfile, MODE_OLDFILE))
  546.          {
  547.             if ((Dbuffer = MyAllocVec((fsize + 1) * sizeof(UBYTE), MEMF_CLEAR, NO_KILL)) &&
  548.                 (Cbuffer = MyAllocVec((fsize + 1) * sizeof(UBYTE), MEMF_CLEAR, NO_KILL)))
  549.             {
  550.                WindTitleInfo(type ? "Reading ROT13 file..." : "Reading crypt file...");
  551.                if (fsize == Read(Cfile, Cbuffer, fsize))
  552.                {
  553.                   if (NOT(type))
  554.                   {
  555.                      WindTitleInfo("Decrypt password...");
  556.  
  557.                      strncpy(cpwd, (char *)Cbuffer, pwdlen);
  558.                      Decrypt((UBYTE *) cpwd, (long)pwdlen,
  559.                              (UBYTE *) pwd, (UBYTE *) pwd, (WORD) pwdlen);
  560.  
  561.                      if (strcmp(cd.cr_pwd, pwd))
  562.                         ErrorHandle(MISC_ERR, WRONG_FAIL, NO_KILL);
  563.                      else
  564.                      {
  565.                         WindTitleInfo("Decrypt crypt file...");
  566.                         Dbuffer = Decrypt(&Cbuffer[pwdlen], (long)(fsize - pwdlen),
  567.                                           Dbuffer, (UBYTE *) pwd, (WORD) pwdlen);
  568.                      }
  569.                   }
  570.                   else
  571.                   {
  572.                      WindTitleInfo("Derotate ROT13-File...");
  573.                      MakeROT13(Cbuffer, Dbuffer);
  574.                   }
  575.  
  576.                   WindTitleInfo("Writing data file...");
  577.  
  578.                   fsize -= (type ? 0 : pwdlen);
  579.                   if (fsize != Write(Dfile, Dbuffer, fsize))
  580.                      ErrorHandle(FILE_ERR, WRITE_FAIL, NO_KILL);
  581.                }
  582.                else
  583.                   ErrorHandle(FILE_ERR, READ_FAIL, NO_KILL);
  584.  
  585.                MyFreeVec(Cbuffer);
  586.                MyFreeVec(Dbuffer);
  587.             }
  588.  
  589.             Close(Cfile);
  590.          }
  591.          else
  592.             ErrorHandle(FILE_ERR, OPEN_FAIL, NO_KILL);
  593.  
  594.          Close(Dfile);
  595.       }
  596.       else
  597.          ErrorHandle(FILE_ERR, OPEN_FAIL, NO_KILL);
  598.    }
  599.  
  600.    WindTitleInfo((char *)CryptWdt);
  601.  
  602.    return;
  603. }
  604.  
  605.    /*
  606.     * CryptFile() bietet eine kleine Benutzeroberfläche an und
  607.     * kontrolliert die Ein- und Ausgabedateien sowie das Paßwort
  608.     */
  609. void
  610. CryptFile(void)
  611. {
  612.    register struct IntuiMessage *message;
  613.    ULONG class,
  614.          code;
  615.    APTR  object;
  616.    APTR  req = NULL,reqcrypt = NULL;
  617.    char *gadbuff;
  618.  
  619.    DPOS;
  620.  
  621.    Flags.quit_cr = 0;
  622.  
  623.    cd.cr_datafile[0] = STRINGEND;
  624.    cd.cr_cryptfile[0] = STRINGEND;
  625.    strcpy(cd.cr_pwd,"tiger");
  626.  
  627.    if (OpenASysWindow(OpenCryptWindow,NO_KILL))
  628.    {
  629.       if (SysWnd)
  630.          req = LockWindow(SysWnd);
  631.  
  632.       refreshstrgad(CryptGadgets[GD_SourceStrGad],cd.cr_datafile);
  633.       refreshstrgad(CryptGadgets[GD_CryptStrGad],cd.cr_cryptfile);
  634.       refreshstrgad(CryptGadgets[GD_PwdGad],cd.cr_pwd);
  635.  
  636.       do
  637.       {
  638.          Wait(1L << CryptWnd->UserPort->mp_SigBit);
  639.  
  640.          while ((message = (struct IntuiMessage *)
  641.                  GT_GetIMsg(CryptWnd->UserPort)) != NULL)
  642.          {
  643.             object = message->IAddress;
  644.             class = message->Class;
  645.             code = message->Code;
  646.  
  647.             GT_ReplyIMsg(message);
  648.  
  649.             switch (class)
  650.             {
  651.                case IDCMP_GADGETUP:
  652.                   switch (((struct Gadget *) object)->GadgetID)
  653.                   {
  654.                      case GD_SourceStrGad:
  655.                         gadbuff = gadgetbuff(CryptGadgets[GD_SourceStrGad]);
  656.  
  657.                         strncpy(cd.cr_datafile, gadbuff, MAXFULLNAME);
  658.                         strncpy(cd.cr_cryptfile, gadbuff, MAXFULLNAME);
  659.                         strcat(cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  660.  
  661.                         refreshstrgad(CryptGadgets[GD_CryptStrGad],
  662.                                       cd.cr_cryptfile);
  663.                         break;
  664.  
  665.                      case GD_CryptStrGad:
  666.                         gadbuff = gadgetbuff(CryptGadgets[GD_CryptStrGad]);
  667.                         strncpy(cd.cr_cryptfile, gadbuff, MAXFULLNAME);
  668.                         break;
  669.  
  670.                      case GD_SelSourceGad:
  671.                         if (GetFile(CryptWnd,NULL,NULL,NULL,
  672.                                     "Select File to crypt","Select"))
  673.                         {
  674.                            strncpy(cd.cr_datafile,(char *)_fullpath,
  675.                                   MAXFULLNAME);
  676.  
  677.                            strncpy(cd.cr_cryptfile,(char *)_fullpath,
  678.                                   MAXFULLNAME-4);
  679.                            strcat(cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  680.  
  681.                            refreshstrgad(CryptGadgets[GD_SourceStrGad],
  682.                                          cd.cr_datafile);
  683.                            refreshstrgad(CryptGadgets[GD_CryptStrGad],
  684.                                          cd.cr_cryptfile);
  685.                         }
  686.  
  687.                         break;
  688.  
  689.                      case GD_SelDestGad:
  690.                         if (GetFile(CryptWnd,NULL,NULL,
  691.                                     (type ? "#?.ROT" :"#?.CPT"),
  692.                                     (type ? "Select ROT13 file" :"Select Crypt file"),
  693.                                     "Select"))
  694.                         {
  695.                            strncpy(cd.cr_cryptfile, (char *)_fullpath,MAXFULLNAME);
  696.                            refreshstrgad(CryptGadgets[GD_CryptStrGad],
  697.                                          cd.cr_cryptfile);
  698.                         }
  699.                         break;
  700.  
  701.                      case GD_CryptGad:
  702.                         reqcrypt = LockWindow(CryptWnd);
  703.  
  704.                         Crypt(TRUE);
  705.  
  706.                         if(reqcrypt)
  707.                            UnlockWindow(reqcrypt);
  708.                         break;
  709.  
  710.                      case GD_DeccryptGad:
  711.                         reqcrypt = LockWindow(CryptWnd);
  712.  
  713.                         Crypt(FALSE);
  714.  
  715.                         if(reqcrypt)
  716.                            UnlockWindow(reqcrypt);
  717.                         break;
  718.  
  719.                      case GD_PwdGad:
  720.                         strncpy(cd.cr_pwd, gadgetbuff(CryptGadgets[GD_PwdGad]), 20);
  721.                         break;
  722.  
  723.                      case GD_TypeCYGad:
  724.                         type = (int)code;
  725.                         GT_SetGadgetAttrs(CryptGadgets[GD_PwdGad], CryptWnd,
  726.                                        NULL,
  727.                                        GA_Disabled, type,
  728.                                        TAG_DONE);
  729.  
  730.                         if(cd.cr_datafile[0])
  731.                         {
  732.                            strncpy(cd.cr_cryptfile, cd.cr_datafile, MAXFULLNAME-4);
  733.                            strcat(cd.cr_cryptfile, (type ? ".ROT" : ".CPT"));
  734.  
  735.                            refreshstrgad(CryptGadgets[GD_CryptStrGad],
  736.                                          cd.cr_cryptfile);
  737.                         }
  738.                         break;
  739.                   }
  740.  
  741.                   break;
  742.  
  743.                case IDCMP_VANILLAKEY:
  744.                   if (code == '\33')
  745.                      Flags.quit_cr = 1;
  746.                   break;
  747.  
  748.                case IDCMP_CLOSEWINDOW:
  749.                   Flags.quit_cr = 1;
  750.                   break;
  751.             }
  752.          }
  753.       }
  754.       while (NOT(Flags.quit_cr));
  755.  
  756.       CloseASysWindow(&CryptWnd, &CryptGList, NULL);
  757.  
  758.       if (SysWnd)
  759.       {
  760.          UnlockWindow(req);
  761.          RefreshMainWindowPattern();
  762.          RefreshList(LastID);
  763.       }
  764.    }
  765.  
  766.    return;
  767. }
  768.  
  769.