Base64.pas und Delphi2009

[emsländer]

Moin,

Delphi2009 und Base64.pas beissen sich. Da ich jetzt ziemlich in der Luft hänge und Eile geboten ist, hier meine Frage, ob einer von den Cracks hier, der mit D2009 arbeitet, diese base64.pas anpassen kann?

Die Fehlermeldungen seht ihr in der Anlage

hier die base64.pas

Delphi-Quellcode:

{* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* 
* Unit Name : uBase64Codec 
* Author    : Daniel Wischnewski 
* Copyright : Copyright © 2001-2003 by gate(n)etwork GmbH. All Rights Reserved. 
* Creator   : Daniel Wischnewski 
* Contact   : Daniel Wischnewski (e-mail: delphi3000(at)wischnewski.tv); 
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *} 

//                               * * * License * * * 
// 
// The contents of this file are used with permission, subject to the Mozilla 
// Public License Version 1.1 (the "License"); you may not use this file except 
// in compliance with the License. You may obtain a copy of the License at 
// 
//                       [url]http://www.mozilla.org/MPL/MPL-1.1.html[/url] 
// 
// Software distributed under the License is distributed on an "AS IS" basis, 
// WITHOUT WARRANTY OF ANY KIND, either express or  implied. See the License for 
// the specific language governing rights and limitations under the License. 
// 

//                               * * * My Wish * * * 
// 
// If you come to use this unit for your work, I would like to know about it. 
// Drop me an e-mail and let me know how it worked out for you. If you wish, you 
// can send me a copy of your work. No obligations! 
// My e-mail address: delphi3000(at)wischnewski.tv 
// 

//                               * * * History * * * 
// 
// Version 1.0 (Oct-10 2002) 
//    first published on Delphi-PRAXiS ([url]www.delphipraxis.net[/url]) 
// 
// Version 1.1 (May-13 2003) 
//    introduced a compiler switch (SpeedDecode) to switch between a faster 
//    decoding variant (prior version) and a litte less fast, but secure variant 
//    to work around bad formatted data (decoding only!) 
//    
// Version 1.2 (Juni-09 2004) 
//    included compiler switch {$0+}. In Delphi 6 and 7 projects using this code 
//    with compiler optimizations turned off will raise an access violation 
//    {$O+} will ensure that this unit runs with compiler optimizations. 
//    This option does *not* influence other parts of the project including this 
//    unit. 
//    Thanks to Ralf Manschewski for pointing out this problem. 
// 

unit Base64; 

{$O+} 

interface 

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
// !! THE COMPILER SWITCH MAY BE USED TO ADJUST THE BEHAVIOR !! 
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 

// enable "SpeedDecode" 
//     the switch to gain speed while decoding the message, however, the codec 
//     will raise different exceptions/access violations or invalid output if 
//     the incoming data is invalid or missized. 

// disable "SpeedDecode" 
//     the switch to enable a data check, that will scan the data to decode to 
//     be valid. This method is to be used if you cannot guarantee to validity 
//     of the data to be decoded. 

{.DEFINE SpeedDecode} 

{$IFNDEF SpeedDecode} 
  {$DEFINE ValidityCheck} 
{$ENDIF} 


uses SysUtils; 

  // codiert einen String in die zugehörige Base64-Darstellung 
  function Base64Encode(const InText: AnsiString): AnsiString; overload; 
  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 
  function Base64Decode(const InText: AnsiString): AnsiString; overload; 

  // bestimmt die Größe der Base64-Darstellung 
  function CalcEncodedSize(InSize: Cardinal): Cardinal; 
  // bestimmt die Größe der binären Darstellung 
  function CalcDecodedSize(const InBuffer; InSize: Cardinal): Cardinal; 

  // codiert einen Buffer in die zugehörige Base64-Darstellung 
  procedure Base64Encode(const InBuffer; InSize: Cardinal; var OutBuffer); overload; register; 
  // decodiert die Base64-Darstellung in einen Buffer 
  {$IFDEF SpeedDecode} 
    procedure Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer); overload; register; 
  {$ENDIF} 
  {$IFDEF ValidityCheck} 
    function Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer): Boolean; overload; register; 
  {$ENDIF} 

  // codiert einen String in die zugehörige Base64-Darstellung 
  procedure Base64Encode(const InText: PAnsiChar; var OutText: PAnsiChar); overload; 
  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 
  procedure Base64Decode(const InText: PAnsiChar; var OutText: PAnsiChar); overload; 

  // codiert einen String in die zugehörige Base64-Darstellung 
  procedure Base64Encode(const InText: AnsiString; var OutText: AnsiString); overload; 
  // decodiert die Base64-Darstellung eines Strings in den zugehörigen String 
  procedure Base64Decode(const InText: AnsiString; var OutText: AnsiString); overload; 


implementation 

const 
  cBase64Codec: array[0..63] of AnsiChar = 
    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; 
  Base64Filler = '='; 

function Base64Encode(const InText: string): string; overload; 
begin 
  Base64Encode(InText, Result); 
end; 

function Base64Decode(const InText: string): string; overload; 
begin 
  Base64Decode(InText, Result); 
end; 

function CalcEncodedSize(InSize: Cardinal): Cardinal; 
begin 
  // no buffers passed along, calculate outbuffer size needed 
  Result := (InSize div 3) shl 2; 
  if ((InSize mod 3) > 0) 
  then Inc(Result, 4); 
end; 

function CalcDecodedSize(const InBuffer; InSize: Cardinal): Cardinal; 
type 
  BA = array of Byte; 
begin 
  Result := 0; 
  if InSize = 0 then 
    Exit; 
  if InSize mod 4 <> 0 then 
    Exit; 
  Result := InSize div 4 * 3; 
  if (BA(InBuffer)[InSize - 2] = Ord(Base64Filler)) 
  then Dec(Result, 2) 
  else if BA(InBuffer)[InSize - 1] = Ord(Base64Filler) 
       then Dec(Result); 
end; 

procedure Base64Encode(const InBuffer; InSize: Cardinal; var OutBuffer 
    ); register; 
var 
  ByThrees, LeftOver: Cardinal; 
  // reset in- and outbytes positions 
asm 
  // load addresses for source and destination 
  // PBYTE(InBuffer); 
  mov  ESI, [EAX] 
  // PBYTE(OutBuffer); 
  mov  EDI, [ECX] 
  // ByThrees := InSize div 3; 
  // LeftOver := InSize mod 3; 
  // load InSize (stored in EBX) 
  mov  EAX, EBX 
  // load 3 
  mov  ECX, $03 
  // clear upper 32 bits 
  xor  EDX, EDX 
  // divide by ECX 
  div  ECX 
  // save result 
  mov  ByThrees, EAX 
  // save remainder 
  mov  LeftOver, EDX 
  // load addresses 
  lea  ECX, cBase64Codec[0] 
  // while I < ByThrees do 
  // begin 
  xor  EAX, EAX 
  xor  EBX, EBX 
  xor  EDX, EDX 
  cmp  ByThrees, 0 
  jz   @@LeftOver 
  @@LoopStart: 
    // load the first two bytes of the source triplet 
    LODSW 
    // write Bits 0..5 to destination 
    mov  BL, AL 
    shr  BL, 2 
    mov  DL, BYTE PTR [ECX + EBX] 
    // save the Bits 12..15 for later use [1] 
    mov  BH, AH 
    and  BH, $0F 
    // save Bits 6..11 
    rol  AX, 4 
    and  AX, $3F 
    mov  DH, BYTE PTR [ECX + EAX] 
    mov  AX, DX 
    // store the first two bytes of the destination quadruple 
    STOSW 
    // laod last byte (Bits 16..23) of the source triplet 
    LODSB 
    // extend bits 12..15 [1] with Bits 16..17 and save them 
    mov  BL, AL 
    shr  BX, 6 
    mov  DL, BYTE PTR [ECX + EBX] 
    // save bits 18..23 
    and  AL, $3F 
    xor  AH, AH 
    mov  DH, BYTE PTR [ECX + EAX] 
    mov  AX, DX 
    // store the last two bytes of the destination quadruple 
    STOSW 
    dec  ByThrees 
  jnz  @@LoopStart 
  @@LeftOver: 
  // there are up to two more bytes to encode 
  cmp  LeftOver, 0 
  jz   @@Done 
  // clear result 
  xor  EAX, EAX 
  xor  EBX, EBX 
  xor  EDX, EDX 
  // get left over 1 
  LODSB 
  // load the first six bits 
  shl  AX, 6 
  mov  BL, AH 
  // save them 
  mov  DL, BYTE PTR [ECX + EBX] 
  // another byte ? 
  dec  LeftOver 
  jz   @@SaveOne 
  // save remaining two bits 
  shl  AX, 2 
  and  AH, $03 
  // get left over 2 
  LODSB 
  // load next 4 bits 
  shl  AX, 4 
  mov  BL, AH 
  // save all 6 bits 
  mov  DH, BYTE PTR [ECX + EBX] 
  shl  EDX, 16 
  // save last 4 bits 
  shr  AL, 2 
  mov  BL, AL 
  // save them 
  mov  DL, BYTE PTR [ECX + EBX] 
  // load base 64 'no more data flag' 
  mov  DH, Base64Filler 
  jmp  @@WriteLast4 
  @@SaveOne: 
  // adjust the last two bits 
  shr  AL, 2 
  mov  BL, AL 
  // save them 
  mov  DH, BYTE PTR [ECX + EBX] 
  shl  EDX, 16 
  // load base 64 'no more data flags' 
  mov  DH, Base64Filler 
  mov  DL, Base64Filler 
  // ignore jump, as jump reference is next line ! 
  // jmp  @@WriteLast4 
  @@WriteLast4: 
    // load and adjust result 
    mov  EAX, EDX 
    ror EAX, 16 
    // save it to destination 
    STOSD 
  @@Done: 
end; 

{$IFDEF SpeedDecode} 
  procedure Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer); 
      overload; register; 
{$ENDIF} 
{$IFDEF ValidityCheck} 
  function Base64Decode(const InBuffer; InSize: Cardinal; var OutBuffer): 
      Boolean; overload; register; 
{$ENDIF} 
const 
  {$IFDEF SpeedDecode} 
    cBase64Codec: array[0..127] of Byte = 
  {$ENDIF} 
  {$IFDEF ValidityCheck} 
    cBase64Codec: array[0..255] of Byte = 
  {$ENDIF} 
  ( 
    $FF, $FF, $FF, $FF, $FF, {005>} $FF, $FF, $FF, $FF, $FF, // 000..009 
    $FF, $FF, $FF, $FF, $FF, {015>} $FF, $FF, $FF, $FF, $FF, // 010..019 
    $FF, $FF, $FF, $FF, $FF, {025>} $FF, $FF, $FF, $FF, $FF, // 020..029 
    $FF, $FF, $FF, $FF, $FF, {035>} $FF, $FF, $FF, $FF, $FF, // 030..039 
    $FF, $FF, $FF, $3E, $FF, {045>} $FF, $FF, $3F, $34, $35, // 040..049 
    $36, $37, $38, $39, $3A, {055>} $3B, $3C, $3D, $FF, $FF, // 050..059 
    $FF, $FF, $FF, $FF, $FF, {065>} $00, $01, $02, $03, $04, // 060..069 
    $05, $06, $07, $08, $09, {075>} $0A, $0B, $0C, $0D, $0E, // 070..079 
    $0F, $10, $11, $12, $13, {085>} $14, $15, $16, $17, $18, // 080..089 
    $19, $FF, $FF, $FF, $FF, {095>} $FF, $FF, $1A, $1B, $1C, // 090..099 
    $1D, $1E, $1F, $20, $21, {105>} $22, $23, $24, $25, $26, // 100..109 
    $27, $28, $29, $2A, $2B, {115>} $2C, $2D, $2E, $2F, $30, // 110..119 
    $31, $32, $33, $FF, $FF, {125>} $FF, $FF, $FF            // 120..127 

    {$IFDEF ValidityCheck} 
                               {125>}              , $FF, $FF, // 128..129 
      $FF, $FF, $FF, $FF, $FF, {135>} $FF, $FF, $FF, $FF, $FF, // 130..139 
      $FF, $FF, $FF, $FF, $FF, {145>} $FF, $FF, $FF, $FF, $FF, // 140..149 
      $FF, $FF, $FF, $FF, $FF, {155>} $FF, $FF, $FF, $FF, $FF, // 150..159 
      $FF, $FF, $FF, $FF, $FF, {165>} $FF, $FF, $FF, $FF, $FF, // 160..169 
      $FF, $FF, $FF, $FF, $FF, {175>} $FF, $FF, $FF, $FF, $FF, // 170..179 
      $FF, $FF, $FF, $FF, $FF, {185>} $FF, $FF, $FF, $FF, $FF, // 180..189 
      $FF, $FF, $FF, $FF, $FF, {195>} $FF, $FF, $FF, $FF, $FF, // 190..199 
      $FF, $FF, $FF, $FF, $FF, {205>} $FF, $FF, $FF, $FF, $FF, // 200..209 
      $FF, $FF, $FF, $FF, $FF, {215>} $FF, $FF, $FF, $FF, $FF, // 210..219 
      $FF, $FF, $FF, $FF, $FF, {225>} $FF, $FF, $FF, $FF, $FF, // 220..229 
      $FF, $FF, $FF, $FF, $FF, {235>} $FF, $FF, $FF, $FF, $FF, // 230..239 
      $FF, $FF, $FF, $FF, $FF, {245>} $FF, $FF, $FF, $FF, $FF, // 240..249 
      $FF, $FF, $FF, $FF, $FF, {255>} $FF                      // 250..255 
    {$ENDIF} 
  ); 
asm 
  push EBX 
  mov  ESI, [EAX] 
  mov  EDI, [ECX] 
  {$IFDEF ValidityCheck} 
    mov  EAX, InSize 
    and  EAX, $03 
    cmp  EAX, $00 
    jz   @@DecodeStart 
    jmp  @@ErrorDone 
    @@DecodeStart: 
  {$ENDIF} 
  mov  EAX, InSize 
  shr  EAX, 2 
  jz   @@Done 
  lea  ECX, cBase64Codec[0] 
  xor  EBX, EBX 
  dec  EAX 
  jz   @@LeftOver 
  push EBP 
  mov  EBP, EAX 
  @@LoopStart: 
    // load four bytes into EAX 
    LODSD 
    // save them to EDX as AX is used to store results 
    mov  EDX, EAX 
    // get bits 0..5 
    mov  BL, DL 
    // decode 
    mov  AH, BYTE PTR [ECX + EBX] 
    {$IFDEF ValidityCheck} 
      // check valid code 
      cmp  AH, $FF 
      jz   @@ErrorDoneAndPopEBP 
    {$ENDIF} 
    // get bits 6..11 
    mov  BL, DH 
    // decode 
    mov  AL, BYTE PTR [ECX + EBX] 
    {$IFDEF ValidityCheck} 
      // check valid code 
      cmp  AL, $FF 
      jz   @@ErrorDoneAndPopEBP 
    {$ENDIF} 
    // align last 6 bits 
    shl  AL, 2 
    // get first 8 bits 
    ror  AX, 6 
    // store first byte 
    STOSB 
    // align remaining 4 bits 
    shr  AX, 12 
    // get next two bytes from source quad 
    shr  EDX, 16 
    // load bits 12..17 
    mov  BL, DL 
    // decode 
    mov  AH, BYTE PTR [ECX + EBX] 
    {$IFDEF ValidityCheck} 
      // check valid code 
      cmp  AH, $FF 
      jz   @@ErrorDoneAndPopEBP 
    {$ENDIF} 
    // align ... 
    shl  AH, 2 
    // ... and adjust 
    rol  AX, 4 
    // get last bits 18..23 
    mov  BL, DH 
    // decord 
    mov  BL, BYTE PTR [ECX + EBX] 
    {$IFDEF ValidityCheck} 
      // check valid code 
      cmp  BL, $FF 
      jz   @@ErrorDoneAndPopEBP 
    {$ENDIF} 
    // enter in destination word 
    or   AH, BL 
    // and store to destination 
    STOSW 
    // more coming ? 
    dec  EBP 
  jnz  @@LoopStart 
  pop  EBP 
  // no 
  // last four bytes are handled separately, as special checking is needed 
  // on the last two bytes (may be end of data signals '=' or '==') 
  @@LeftOver: 
  // get the last four bytes 
  LODSD 
  // save them to EDX as AX is used to store results 
  mov  EDX, EAX 
  // get bits 0..5 
  mov  BL, DL 
  // decode 
  mov  AH, BYTE PTR [ECX + EBX] 
  {$IFDEF ValidityCheck} 
    // check valid code 
    cmp  AH, $FF 
    jz   @@ErrorDone 
  {$ENDIF} 
  // get bits 6..11 
  mov  BL, DH 
  // decode 
  mov  AL, BYTE PTR [ECX + EBX] 
  {$IFDEF ValidityCheck} 
    // check valid code 
    cmp  AL, $FF 
    jz   @@ErrorDone 
  {$ENDIF} 
  // align last 6 bits 
  shl  AL, 2 
  // get first 8 bits 
  ror  AX, 6 
  // store first byte 
  STOSB 
  // get next two bytes from source quad 
  shr  EDX, 16 
  // check DL for "end of data signal" 
  cmp  DL, Base64Filler 
  jz   @@SuccessDone 
  // align remaining 4 bits 
  shr  AX, 12 
  // load bits 12..17 
  mov  BL, DL 
  // decode 
  mov  AH, BYTE PTR [ECX + EBX] 
  {$IFDEF ValidityCheck} 
    // check valid code 
    cmp  AH, $FF 
    jz   @@ErrorDone 
  {$ENDIF} 
  // align ... 
  shl  AH, 2 
  // ... and adjust 
  rol  AX, 4 
  // store second byte 
  STOSB 
  // check DH for "end of data signal" 
  cmp  DH, Base64Filler 
  jz   @@SuccessDone 
  // get last bits 18..23 
  mov  BL, DH 
  // decord 
  mov  BL, BYTE PTR [ECX + EBX] 
  {$IFDEF ValidityCheck} 
    // check valid code 
    cmp  BL, $FF 
    jz   @@ErrorDone 
  {$ENDIF} 
  // enter in destination word 
  or   AH, BL 
  // AH - AL for saving last byte 
  mov  AL, AH 
  // store third byte 
  STOSB 
  @@SuccessDone: 
  {$IFDEF ValidityCheck} 
    mov  Result, $01 
    jmp  @@Done 
    @@ErrorDoneAndPopEBP: 
    pop  EBP 
    @@ErrorDone: 
    mov  Result, $00 
  {$ENDIF} 
  @@Done: 
  pop  EBX 
end; 

procedure Base64Encode(const InText: PAnsiChar; var OutText: PAnsiChar); 
var 
  InSize, OutSize: Cardinal; 
begin 
  // get size of source 
  InSize := Length(InText); 
  // calculate size for destination 
  OutSize := CalcEncodedSize(InSize); 
  // reserve memory 
  OutText := StrAlloc(Succ(OutSize)); 
  OutText[OutSize] := #0; 
  // encode ! 
  Base64Encode(InText, InSize, OutText); 
end; 

procedure Base64Encode(const InText: AnsiString; var OutText: AnsiString); 
    overload; 
var 
  InSize, OutSize: Cardinal; 
  PIn, POut: Pointer; 
begin 
  // get size of source 
  InSize := Length(InText); 
  // calculate size for destination 
  OutSize := CalcEncodedSize(InSize); 
  // prepare string length to fit result data 
  SetLength(OutText, OutSize); 
  PIn := @InText[1]; 
  POut := @OutText[1]; 
  // encode ! 
  Base64Encode(PIn, InSize, POut); 
end; 

procedure Base64Decode(const InText: PAnsiChar; var OutText: PAnsiChar); 
    overload; 
var 
  InSize, OutSize: Cardinal; 
begin 
  // get size of source 
  InSize := Length(InText); 
  // calculate size for destination 
  OutSize := CalcDecodedSize(InText, InSize); 
  // reserve memory 
  OutText := StrAlloc(Succ(OutSize)); 
  OutText[OutSize] := #0; 
  // encode ! 
  {$IFDEF SpeedDecode} 
    Base64Decode(InText, InSize, OutText); 
  {$ENDIF} 
  {$IFDEF ValidityCheck} 
    if not Base64Decode(InText, InSize, OutText) then 
      OutText[0] := #0; 
  {$ENDIF} 
end; 

procedure Base64Decode(const InText: AnsiString; var OutText: AnsiString); 
    overload; 
var 
  InSize, OutSize: Cardinal; 
  PIn, POut: Pointer; 
begin 
  // get size of source 
  InSize := Length(InText); 
  // calculate size for destination 
  PIn := @InText[1]; 
  OutSize := CalcDecodedSize(PIn, InSize); 
  // prepare string length to fit result data 
  SetLength(OutText, OutSize); 
  FillChar(OutText[1], OutSize, '.'); 
  POut := @OutText[1]; 
  // encode ! 
  {$IFDEF SpeedDecode} 
    Base64Decode(PIn, InSize, POut); 
  {$ENDIF} 
  {$IFDEF ValidityCheck} 
    if not Base64Decode(PIn, InSize, POut) then 
      SetLength(OutText, 0); 
  {$ENDIF} 
end; 

end.

Vielen Dank im Voraus

EL