encrypteddatafile.pas

wbs43open-src.zip 数字隐藏工具

     newData:=TMemoryStream.Create;
     Data.Seek(0,soFromBeginning);
     pwdptr:=1;
     offset:=Ord(Pwd[pwdptr]) and $3F;
     DAsked:=offset;
     DRead:=DAsked;
     while DRead=DAsked do begin
       DAsked:=offset;
       DRead:=Data.Read(DBuffer,DAsked);
       newData.Write(DBuffer,DRead);
       if (offset<64) and (DRead=DAsked) then begin
         if Data.Read(DBuffer,1)>0 then newPwd:=newPwd+Chr(DBuffer[0]);
       end;
       if offset<64 then begin
         if pwdptr<Length(Pwd) then begin
           Inc(pwdPtr);
           offset:=Ord(Pwd[pwdptr]) and $3F;
         end
         else offset:=1024;
       end;
     end;
     Data.Free;
     pwdleft:=0;
     if Length(newPwd)<Length(Pwd) then begin
       pwdleft:=Length(Pwd)-Length(newPwd);
       newData.Seek(newData.Size-pwdleft,soFromBeginning);
       newData.Read(DBuffer,pwdLeft);
       for i:=0 to pwdleft-1 do newPwd:=newPwd+Chr(DBuffer[i]);
     end;
     Data:=TMemoryStream.Create;
     newData.Seek(0,soFromBeginning);
     Data.CopyFrom(newData,newData.Size-pwdleft);
     newData.Free;
     Pwd:=newPwd;
   end;

   procedure TEncryptedDataFile.Mix;
   var
     newData:      TMemoryStream;
     m,n:          Integer;
     l,r:          Integer;
     len:          Integer;
     i,j:          Integer;
     Block:        Array[0..255] of Byte;
     Matrix:       Array[0..15,0..15] of Byte;
     BRead:        Integer;
     BAsked:       Integer;
     redbytes:     Integer;
   begin
     redbytes:=0;
     newData:=TMemoryStream.Create;
     Data.Seek(0,soFromBeginning);
     len:=Length(Pwd);
     l:=1;
     r:=len;
     m:=Ord(Pwd[l]) and $0F;
     n:=Ord(Pwd[r]) and $0F;
     BAsked:=(m+1)*(n+1);
     BRead:=BAsked;
     while BRead=BAsked do begin
       BAsked:=(m+1)*(n+1);
       BRead:=Data.Read(Block,BAsked);
       if BRead<BAsked then begin
         //for i:=BRead to BAsked-1 do Block[i]:=0;
         //redbytes:=BAsked-BRead;
         m:=Ord(Pwd[1]);
         for i:=0 to BRead-1 do Block[i]:=(Block[i]+m) mod 256;
         newData.Write(Block,BRead);
       end
       else begin
         for i:=0 to m do
           for j:=0 to n do
             Matrix[i,j]:=Block[i*(n+1)+j];
         for j:=0 to n do
           for i:=m downto 0 do
         Block[j*(m+1)+(m-i)]:=Matrix[i,j];
         newData.Write(Block,BAsked);
         if l<Trunc(len/2) then Inc(l) else
         begin
           if Odd(len) and (l=Trunc(len/2)) then Inc(l)
           else l:=1;
         end;
         if r>Trunc(len/2)+1 then Dec(r) else
         begin
           if Odd(len) and (r=Trunc(len/2)+1) then Dec(r)
           else r:=len;
         end;
         m:=Ord(Pwd[l]) and $0F;
         n:=Ord(Pwd[r]) and $0F;
       end;
       Application.ProcessMessages;
     end;
     // prepend # of redundant bytes .. obsolete!!
     //Block[0]:=redbytes;
     Data.Free;
     Data:=TMemoryStream.Create;
     //Data.Write(Block,1);
     newData.Seek(0,soFromBeginning);
     Data.CopyFrom(newData,newData.Size);
     newData.Free;
   end;

   procedure TEncryptedDataFile.Unmix;
   var
     newData:      TMemoryStream;
     m,n:          Integer;
     l,r:          Integer;
     len:          Integer;
     i,j:          Integer;
     Block:        Array[0..255] of Byte;
     Matrix:       Array[0..15,0..15] of Byte;
     BRead:        Integer;
     BAsked:       Integer;
     redbytes:     Integer;
   begin
     newData:=TMemoryStream.Create;
     Data.Seek(0,soFromBeginning);
     // get # of redundant bytes ... obsolete
     //Data.Read(Block,1);
     //redbytes:=Block[0];
     len:=Length(Pwd);
     l:=1;
     r:=len;
     m:=Ord(Pwd[l]) and $0F;
     n:=Ord(Pwd[r]) and $0F;
     BAsked:=(m+1)*(n+1);
     BRead:=BAsked;
     while BRead=BAsked do begin
      BAsked:=(m+1)*(n+1);
      BRead:=Data.Read(Block,BAsked);
      if BRead>0 then begin
        if BRead=BAsked then begin
          for j:=0 to n do
            for i:=m downto 0 do
              Matrix[i,j]:=Block[j*(m+1)+(m-i)];
          for i:=0 to m do
            for j:=0 to n do
              Block[i*(n+1)+j]:=Matrix[i,j];
          newData.Write(Block,BAsked);
          if l<Trunc(len/2) then Inc(l) else
          begin
            if Odd(len) and (l=Trunc(len/2)) then Inc(l)
            else l:=1;
          end;
          if r>Trunc(len/2)+1 then Dec(r) else
          begin
            if Odd(len) and (r=Trunc(len/2)+1) then Dec(r)
            else r:=len;
          end;
          m:=Ord(Pwd[l]) and $0F;
          n:=Ord(Pwd[r]) and $0F;
       end
       else begin
         m:=Ord(Pwd[1]);
         for i:=0 to BRead-1 do Block[i]:=(Block[i]-m) mod 256;
         newData.Write(Block,BRead);
       end;
       Application.ProcessMessages;
      end;
     end;
     Data.Free;
     Data:=TMemoryStream.Create;
     newData.Seek(0,soFromBeginning);
     Data.CopyFrom(newData,newData.Size);
   end;

   procedure TEncryptedDataFile.Crypt;
   var
     RandGen:      TMLKBBSGenerator;
     newData:      TMemoryStream;
     DBuffer:      Array[0..1023] of Byte;
     DRead:        Integer;
     i:            Integer;
   begin
     RandGen:=TMLKBBSGenerator.Create(Pwd);
     newData:=TMemoryStream.Create;
     Data.Seek(0,soFromBeginning);
     DRead:=1024;
     while DRead=1024 do begin
       DRead:=Data.Read(DBuffer,1024);
       for i:=0 to DRead-1 do DBuffer[i]:=DBuffer[i] xor RandGen.NextValue;
       newData.Write(DBuffer,DRead);
     end;
     Data.Free;
     Data:=newData;
   end;

   // v. 4.x BLOCK CIPHERS

   procedure TEncryptedDataFile.Header4(var hdr: Array of byte);
   begin
     hdr[0]:=255;           // header id
     hdr[1]:=1;             // bytes in header (excl. id and this count)
     hdr[2]:=Algorithm;     // Algorithm id
   end;

   procedure TEncryptedDataFile.GenerateKey; // SHA-1
   var
     i:      Integer;
     Hash:   TDCP_sha1;
   begin
     Hash:= TDCP_sha1.Create(nil);
     Hash.Init;
     Hash.UpdateStr(Pwd);
     Hash.Final(Key);
     Hash.Free;
   end;

   procedure TEncryptedDataFile.EncryptBlockCipher;
   var
     Cipher:             TDCP_blockcipher;
     newData:            TMemoryStream;
     Buffer:             Array[0..4095] of Byte;
     bytesRead:          Longint;
     keySize:            Integer;
   begin
     if Algorithm>0 then begin
       case Algorithm of
         1:  Cipher:= TDCP_blowfish.Create(nil);
         2:  Cipher:= TDCP_twofish.Create(nil);
         3:  Cipher:= TDCP_cast128.Create(nil);
         4:  Cipher:= TDCP_rijndael.Create(nil);
       end;
       keySize:=160;
       if Algorithm=3 then keySize:=128;
       Cipher.Init(Key,keySize,nil);
       try
         newData:=TMemoryStream.Create;
         Data.Seek(0,soFromBeginning);
         bytesRead:=4096;
         while (bytesRead=4096) do begin
           bytesRead:=Data.Read(Buffer,4096);
           Cipher.EncryptCBC(Buffer,Buffer,bytesRead);
           newData.Write(Buffer,bytesRead);
         end;
       finally
         Data.Free;
         Data:=newData;
         Cipher.Burn;
         Cipher.Free;
       end;
     end;
   end;

   procedure TEncryptedDataFile.DecryptBlockCipher;
   var
     Cipher:             TDCP_blockcipher;
     newData:            TMemoryStream;
     Buffer:             Array[0..4095] of Byte;
     bytesRead:          Longint;
     keySize:            Integer;
   begin
     if Algorithm>0 then begin
       case Algorithm of
         1:  Cipher:= TDCP_blowfish.Create(nil);
         2:  Cipher:= TDCP_twofish.Create(nil);
         3:  Cipher:= TDCP_cast128.Create(nil);
         4:  Cipher:= TDCP_rijndael.Create(nil);
       end;
       keySize:=160;
       if Algorithm=3 then keySize:=128;
       Cipher.Init(Key,keySize,nil);
       try
         newData:=TMemoryStream.Create;
         Data.Seek(0,soFromBeginning);
         bytesRead:=4096;
         while (bytesRead=4096) do begin
           bytesRead:=Data.Read(Buffer,4096);
           Cipher.DecryptCBC(Buffer,Buffer,bytesRead);
           newData.Write(Buffer,bytesRead);
         end;
       finally
         Data.Free;
         Data:=newData;
         Cipher.Burn;
         Cipher.Free;
       end;
     end;
   end;

end.