home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / encrypt.swg / 0008_ENDECODE.PAS.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1993-05-28  |  3.8 KB  |  112 lines
  1. Unit endecode;
  2.  { Simple encryption/decryption routines.                  }
  3.  
  4. Interface
  5.  
  6. Type
  7.   stArray = Array[0..255] of Byte;
  8.  
  9. Function Key(Var s): LongInt;
  10. Function EncryptStr(key : LongInt; s: String): String;
  11. Function DecryptStr(key : LongInt; s: String): String;
  12.  
  13. Implementation
  14.  
  15. Function MakeCodeStr(key : LongInt; Var s): String;
  16.   {--------------------------------------------------------}
  17.   { Creates a "randomly" Constructed String of a similar   }
  18.   { length as the String which is to be encrypted. A       }
  19.   { LongInt key is used to permit "passWord" Type          }
  20.   { encryption. This key may be passed as a literal or     }
  21.   { some passWord used to calculate it. Using this key,    }
  22.   { the last Character of the String to be encrypted and   }
  23.   { the length of the String, a "code String" is produced. }
  24.   { This code String is then xord With the original String }
  25.   { to produce the encrypted String. The last Character    }
  26.   { however must be treated differently so that it can be  }
  27.   { easily decoded in order to reproduce the coded String  }
  28.   { used For decoding. This is done by xoring it With the  }
  29.   { length of the String. to decrypt a String the last     }
  30.   { Character must be decoded first and then the key coded }
  31.   { String produced in order to decrypt each Character.    }
  32.   {--------------------------------------------------------}
  33.  
  34.   Var
  35.     x   : Word;
  36.     len : Byte Absolute s;
  37.     st  : Array[0..255] of Byte Absolute s;
  38.  
  39.   begin
  40.     RandSeed := (key * len) div st[len];
  41.     {This ensures that no two code Strings will be similar UNLESS they are
  42.      of identical length, have identical last Characters and the same
  43.      key is used.}
  44.     MakeCodeStr[0] := chr(len);
  45.     For x := 1 to len do
  46.       MakeCodeStr[x] := chr(32 + Random(95));
  47.       {Keeping the Character between 32 and 127 ensures that the high bit
  48.        is never set on the original encrypted Character and thereFore allows
  49.        this to be used as flag to indicate that the coded Char was < #32.
  50.        This will then permit the encrypted String to be printed without fear
  51.        of having embedded control codes play havoc With the Printer.}
  52.   end;
  53.  
  54. Function Key(Var s): LongInt;
  55.   { Creates a key For seeding the random number generator. st can be a
  56.     passWord }
  57.   Var
  58.     x     : Byte;
  59.     temp  : LongInt;
  60.     c     : Array[1..64] of LongInt Absolute s;
  61.     len   : Byte Absolute s;
  62.   begin
  63.     temp  := 0;
  64.     For x := 1 to len div 4 do
  65.       temp := temp xor c[x];
  66.     Key := Abs(temp);
  67.   end;
  68.  
  69. Function EncryptStr(key : LongInt; s: String): String;
  70.   Var
  71.     cnt,x          : Byte;
  72.     len            : Byte Absolute s;
  73.     st             : Array[0..255] of Byte Absolute s;
  74.     CodeStr        : stArray;
  75.     temp           : String Absolute CodeStr;
  76.   begin
  77.     temp           := MakeCodeStr(key,st);
  78.     EncryptStr[0]  := chr(len);
  79.     EncryptStr[len]:= chr(st[len]);
  80.     For x := 1 to len-1 do begin
  81.       cnt := st[x] xor CodeStr[x];
  82.       inc(cnt,128 * ord(cnt < 32));
  83.       EncryptStr[x]:= chr(cnt);
  84.     end;  { For }
  85.     cnt := st[len] xor (len and 127);
  86.     inc(cnt,128 * ord(cnt < 32));
  87.     EncryptStr[len]:= chr(cnt);
  88.   end;
  89.  
  90. Function DecryptStr(key : LongInt; s: String): String;
  91.   Var
  92.     cnt,x        : Byte;
  93.     st           : stArray Absolute s;
  94.     len          : Byte Absolute s;
  95.     CodeStr      : stArray;
  96.     temp         : String Absolute CodeStr;
  97.     ch           : Char;
  98.   begin
  99.     cnt          := st[len] and 127;
  100.     st[len]      := cnt xor len;
  101.     temp         := MakeCodeStr(key,st);
  102.     DecryptStr[0]:= chr(len);
  103.     DecryptStr[len]:= chr(st[len]);
  104.     For x := 1 to len-1 do begin
  105.       cnt        := st[x];
  106.       dec(cnt,128 * ord(st[x] > 127));
  107.       DecryptStr[x] := chr(cnt xor CodeStr[x]);
  108.     end;  { For }
  109.   end;
  110.  
  111. end.
  112.