开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
SBPEM.pas
资源名称：SecureBlackBox.rar　[点击查看]
上传用户：qdyddl
上传日期：2014-04-21
资源大小：11640k
文件大小：31k
源码类别：

Delphi控件源码

开发平台：

Delphi

SBPEM.pas：源码内容
  2. (******************************************************)
  3. (*                                                    *)
  4. (*            EldoS SecureBlackbox Library            *)
  5. (*                                                    *)
  6. (*      Copyright (c) 2002-2007 EldoS Corporation     *)
  7. (*           http://www.secureblackbox.com            *)
  8. (*                                                    *)
  9. (******************************************************)
  11. {$I SecBbox.inc}
  13. unit SBPEM;
  15. interface
  17. uses
  18.   SysUtils,
  19.   Classes,
  20.   {$ifndef CLX_USED}
  21.   Windows,
  22.   {$else}
  23.   Libc,
  24.   {$endif}
  25.   SBUtils;
  28. const
  29.   PEM_DECODE_RESULT_OK                  = Integer(0);
  30.   PEM_DECODE_RESULT_INVALID_FORMAT      = Integer($1D01);
  31.   PEM_DECODE_RESULT_INVALID_PASSPHRASE  = Integer($1D02);
  32.   PEM_DECODE_RESULT_NOT_ENOUGH_SPACE    = Integer($1D03);
  33.   PEM_DECODE_RESULT_UNKNOWN_CIPHER      = Integer($1D04);
  35. type
  37.   TSBBase64Context = record
  39.     Tail : array [0..3] of byte;
  40.     TailBytes : integer;
  41.     LineWritten : integer;
  42.     LineSize : integer;
  44.     fEOL : array [0..3] of byte;
  45.     EOLSize : integer;
  47.     OutBuf : array [0..3] of byte;
  48.     EQUCount : integer;
  49.   end;
  51.   TElPEMProcessor = class(TSBComponentBase)
  52.   protected
  53.     FHeader : string;
  54.     FPassphrase: string;
  56.   public
  57.     function PEMEncode(const InBuffer : ByteArray; var OutBuffer : ByteArray; Encrypt : boolean) : boolean; overload;
  58.     function PEMDecode(const InBuffer : ByteArray; var OutBuffer : ByteArray) : integer;  overload;
  60.     function PEMEncode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  61.       var OutSize : integer; Encrypt : boolean) : boolean; overload;
  62.     function PEMDecode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  63.       var OutSize : integer) : integer; overload;
  64.   published
  65.     property Header : string read FHeader write FHeader;
  66.     property Passphrase: string read FPassphrase write FPassphrase;
  67.   end;
  69. function Encode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  70.   var OutSize : integer; const Header : string; Encrypt : boolean;
  71.   const PassPhrase : string) : boolean;
  72. function Decode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  73.   const PassPhrase : string; var OutSize : integer; var Header : string) : integer;
  75. function IsBase64UnicodeSequence(Buffer : pointer; Size : integer) : boolean;
  76. function IsBase64Sequence(Buffer : pointer; Size : integer) : boolean;
  78. function B64InitializeEncoding(var Ctx : TSBBase64Context; LineSize : integer;
  79.   fEOL : TSBEOLMarker) : boolean;  
  80. function B64InitializeDecoding(var Ctx : TSBBase64Context) : boolean;  
  81. function B64Encode(var Ctx : TSBBase64Context; Buffer : pointer; Size : integer;
  82.   OutBuffer : pointer; var OutSize : integer) : boolean;
  83. function B64Decode(var Ctx : TSBBase64Context; Buffer : pointer; Size : integer;
  84.   OutBuffer: pointer; var OutSize : integer) : boolean;
  85. function B64FinalizeEncoding(var Ctx : TSBBase64Context;
  86.   OutBuffer : pointer; var OutSize : integer) : boolean;
  87. function B64FinalizeDecoding(var Ctx : TSBBase64Context;
  88.   OutBuffer : pointer; var OutSize : integer) : boolean;
  90. type
  91.   EPEMError =  class(ESecureBlackboxError);
  93. procedure RaisePEMError(ErrorCode : integer); 
  95. implementation
  97. uses
  98.   {$ifndef SBB_NO_DES}
  99.   SBDES,
  100.   SB3DES,
  101.   {$endif}
  102.   SBConstants,
  103.   SBMath,
  104.   SBMD
  105.   ;
  107. resourcestring
  109.   sInvalidPEMFormat     = 'Invalid file format (possibly not a PEM?)';
  110.   sIncorrectPassphrase  = 'Incorrect password';
  111.   sNotEnoughBufferSpace = 'Not enough buffer space';
  112.   sUnknownCipher        = 'Unsupported data encryption method';
  114. procedure RaisePEMError(ErrorCode : integer);
  115. begin
  116.   case ErrorCode of
  117.     PEM_DECODE_RESULT_INVALID_FORMAT     : raise EPEMError.Create(sInvalidPEMFormat, ErrorCode{$ifndef HAS_DEF_PARAMS}{$ifndef FPC}, 0{$endif}{$endif});
  118.     PEM_DECODE_RESULT_INVALID_PASSPHRASE : raise EPEMError.Create(sIncorrectPassphrase, ErrorCode{$ifndef HAS_DEF_PARAMS}{$ifndef FPC}, 0{$endif}{$endif});
  119.     PEM_DECODE_RESULT_NOT_ENOUGH_SPACE   : raise EPEMError.Create(sNotEnoughBufferSpace, ErrorCode{$ifndef HAS_DEF_PARAMS}{$ifndef FPC}, 0{$endif}{$endif});
  120.     PEM_DECODE_RESULT_UNKNOWN_CIPHER     : raise EPEMError.Create(sUnknownCipher, ErrorCode{$ifndef HAS_DEF_PARAMS}{$ifndef FPC}, 0{$endif}{$endif});
  121.     else
  122.       exit;
  123.   end;
  124. end;
  126. (*
  128. {$ifndef SBB_NO_DES}
  129. procedure ConvertPassPhraseToKey(const PassPhrase : string; var Key : TDESKey;
  130.   var IV : TDESBuffer);
  131. var
  132.   MD1, MD2, MD3 : TMessageDigest128;
  133.   {$ifdef DELPHI_NET}
  134.   TmpBuf : ByteArray;
  135.   TmpStr : AnsiString;
  136.   CnvPwd : ByteArray;
  137.   {$endif}
  138. begin
  139.   {$ifdef DELPHI_NET}
  140.   CnvPwd := Encoding.ASCII.GetBytes(PassPhrase);
  141. //  TmpStr := CloneBuffer(CnvPwd);
  142. //  SetLength(TmpBuf, Length(TmpStr));
  143. //  if Length(TmpBuf) > 0 then
  144. //    Move(TmpStr, 0, TmpBuf, 0, Length(TmpBuf));
  145. //  MD1 := HashMD5(TmpBuf, Length(TmpBuf));
  146.   MD1 := HashMD5(CnvPwd, Length(CnvPwd));
  148.   {$ifndef CHROME}
  149.   TmpStr := PassPhrase + base64Pad + PassPhrase;
  150.   {$else}
  151.   TmpStr := SBConcatBuffers(CnvPwd, base64PadByteArray);
  152.   TmpStr := SBConcatBuffers(TmpStr, CnvPwd);
  153.   {$endif}
  154.   {$ifndef CHROME}
  155.   SetLength(TmpBuf, Length(TmpStr));
  156.   if Length(TmpBuf) > 0 then
  157.     Move(TmpStr, 0, TmpBuf, 0, Length(TmpBuf));
  158.   {$else}
  159.   TmpBuf := TmpStr;
  160.   {$endif}
  162.   MD2 := HashMD5(TmpBuf, Length(TmpBuf));
  163.   {$else}
  164.   MD1 := HashMD5(PassPhrase);
  165.   MD2 := HashMD5(PassPhrase + base64Pad + PassPhrase);
  166.   {$endif}
  167.   MD3.A := MD1.A xor MD2.A;
  168.   MD3.B := MD1.B xor MD2.B;
  169.   MD3.C := MD1.C xor MD2.C;
  170.   MD3.D := MD1.D xor MD2.D;
  171.   {$ifdef DELPHI_NET}
  172.   TmpBuf := StructureToByteArray(MD3);
  173.   Move(TmpBuf, 0, Key, 0, 8);
  174.   Move(TmpBuf, 8, IV, 0, 8);
  175.   {$else}
  176.   Move(PByteArray(@MD3)[0], Key[0], 8);
  177.   Move(PByteArray(@MD3)[8], IV[0], 8);
  178.   {$endif}
  179. end;
  180. {$endif}
  181. *)
  183. function BytesToKey(const Passphrase : BufferType; const Salt : BufferType; Needed: integer) : BufferType;
  184. var
  185.   Context : TMD5Context;
  186.   AM : integer;
  187.   MDS, I, KeyCount : integer;
  188.   M128 : TMessageDigest128;
  189.   KeyPtr : ^byte;
  190. begin
  191.   AM := 0;
  192.   MDS := 0;
  193.   SetLength(Result, Needed);
  194.   KeyPtr := @Result[1];
  195.   KeyCount := Needed;
  196.   while true do
  197.   begin
  198.     SBMD.InitializeMD5(Context);
  199.     Inc(AM);
  200.     if (AM <> 0) then
  201.       SBMD.HashMD5(Context, @M128, MDS);
  202.     SBMD.HashMD5(Context, @Passphrase[1], Length(Passphrase));
  203.     if Length(Salt) <> 0 then
  204.       SBMD.HashMD5(Context, @Salt[1], Length(Salt));
  205.     M128 := SBMD.FinalizeMD5(Context);
  206.     I := 0;
  207.     MDS := 16;
  208.     while true do
  209.     begin
  210.       if KeyCount = 0 then
  211.         Break;
  212.       if I = MDS then
  213.         Break;
  214.       KeyPtr^ := PByteArray(@M128)[I];
  215.       Inc(KeyPtr);
  216.       Dec(KeyCount);
  217.       Inc(I);
  218.     end;
  219.     if KeyCount = 0 then
  220.       Break;
  221.   end;
  222. end;
  224. function Encode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  225.   var OutSize : integer; const Header : string; Encrypt : boolean;
  226.   const PassPhrase : string) : boolean;
  227. var
  228.   InBuf,
  229.   Buf : ByteArray;
  231.   Sz, I, EstSize : integer;
  232.   OutSz : cardinal;
  233.   PEMBeginLine, PEMEndLine, PEMHeaders : AnsiString;
  234.   {$ifndef SBB_NO_DES}
  235.   DESKey : T3DESKey;
  236.   DESIV : T3DESBuffer;
  237.   Ctx : T3DESContext;
  238.   {$endif}
  240.   Key, Salt : BufferType;
  242.   //RandCtx : TRC4RandomContext;
  243. begin
  244.   Result := true;
  245.   {$ifndef SBB_NO_DES}
  246.   if Encrypt then
  247.   begin
  248.     SetLength(Salt, 8);
  249.     //LRC4Init(RandCtx);
  250.     for I := 1 to 8 do
  251.       Salt[I] := Chr(SBRndGenerate(256){LRC4RandomByte(RandCtx)});
  252.     Key := BytesToKey(Passphrase, Salt, 24);
  253.     Move(Key[1], DESKey[0], 24);
  254.     Move(Salt[1], DESIV[0], 8);
  255.     PEMHeaders := 'Proc-Type: 4,ENCRYPTED'#$0A;
  256.     PEMHeaders := PEMHeaders + 'DEK-Info: DES-EDE3-CBC,';
  257.     for I := 0 to 7 do
  258.       PEMHeaders := PEMHeaders + IntToHex(DESIV[I], 2);
  259.     PEMHeaders := PEMHeaders + #$0A#$0A;
  260.     SetLength(InBuf, (InSize div 8 + 1) * 8);
  261.     Move(InBuffer^, InBuf[0], InSize);
  262.     FillChar(InBuf[InSize], Length(InBuf) - InSize, Chr(Length(InBuf) - InSize));
  263.     SB3DES.InitializeEncryptionCBC(Ctx, DESKey, DESIV);
  264.     OutSz := Length(InBuf);
  265.     SB3DES.EncryptCBC(Ctx, @InBuf[0], Length(InBuf), @InBuf[0], OutSz);
  266.     SetLength(Buf, Length(InBuf) * 2);
  267.     Sz := Length(InBuf) * 2;
  268.     if not Base64Encode(@InBuf[0], Length(InBuf), @Buf[0], Sz) then
  269.     begin
  270.       Result := false;
  271.       Exit;
  272.     end;
  273.   end
  274.   else
  275.   {$endif}
  276.   begin
  277.     SetLength(Buf, InSize * 2);
  278.     Sz := InSize * 2;
  279.     if not Base64Encode(InBuffer, InSize, @Buf[0], Sz) then
  280.     begin
  281.       Result := false;
  282.       Exit;
  283.     end;
  284.     PEMHeaders := '';
  285.   end;
  286.   
  287.   PEMBeginLine := BeginLine + Header + Line + #$0A + PEMHeaders;
  288.   PEMEndLine := EndLine + Header + Line + #$0A;
  290.   { Checking whether we have enough space in buffer }
  291.   EstSize := Length(PEMBeginLine) + Length(PEMEndLine) + Sz;
  292.   if (OutSize < EstSize)  then
  293.   begin
  294.     OutSize := EstSize;
  295.     Result := false;
  296.     Exit;
  297.   end;
  298.   Move(PEMBeginLine[1], PByteArray(OutBuffer)[0], Length(PEMBeginLine));
  299.   SetLength(Buf, Sz);
  300.   Move(Buf[0], PByteArray(OutBuffer)[Length(PEMBeginLine)], Length(Buf));
  301.   Move(PEMEndLine[1], PByteArray(OutBuffer)[Length(PEMBeginLine) + Length(Buf)],
  302.     Length(PEMEndLine));
  303.   OutSize := EstSize; //Length(PEMBeginLine) + Length(Buf) + Length(PEMEndLine);
  304.   SetLength(Buf, 0);
  305. end;
  307. function HexStringToBuffer(const HexStr : string) : BufferType;
  308.   function HexBytesToSym(B1, B2 : char) : byte;
  309.   var
  310.     P1, P2 : byte;
  311.   begin
  312.     if (B1 >= 'A') and (B1 <= 'F') then
  313.       P1 := Ord(B1) - Ord('A') + 10
  314.     else if (B1 >= '0') and (B1 <= '9') then
  315.       P1 := Ord(B1) - Ord('0')
  316.     else
  317.       P1 := 0;
  318.     if (B2 >= 'A') and (B2 <= 'F') then
  319.       P2 := Ord(B2) - Ord('A') + 10
  320.     else if (B2 >= '0') and (B2 <= '9') then
  321.       P2 := Ord(B2) - Ord('0')
  322.     else
  323.       P2 := 0;
  324.     Result := (P1 shl 4) or P2;
  325.   end;
  326. var
  327.   I : integer;
  328. begin
  329.   if Length(HexStr) mod 2 <> 0 then
  330.     SetLength(Result, 0)
  331.   else
  332.   begin
  333.     I := 1;
  334.     SetLength(Result, Length(HexStr) div 2);
  335.     while I <= Length(Result) do
  336.     begin
  337.       Result[I] := Chr(HexBytesToSym(HexStr[I * 2 - 1], HexStr[I * 2]));
  338.       Inc(I);
  339.     end;
  340.   end;
  341. end;
  343. function Decode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  344.   const PassPhrase : string; var OutSize : integer; var Header : string) : integer;
  345. var
  346.   S1, S2 : BufferType;
  347.   S, Headers, Tmp : String;
  348.   I, HeaderEnd, Res, Cipher, I1, I2, I3 : integer;
  349.   {$ifndef SBB_NO_DES}
  350.   DESIV : TDESBuffer;
  351.   DESEDE3IV : T3DESBuffer;
  352.   DESKey : TDESKey;
  353.   DESEDE3Key : T3DESKey;
  354.   Ctx : TDESContext;
  355.   CtxEDE : T3DESContext;
  356.   {$endif}
  357.   Sz : cardinal;
  358.   EolLen : integer;
  359. begin
  360.   Result := PEM_DECODE_RESULT_OK;
  361.   SetLength(S, InSize);
  362.   Move(InBuffer^, S[1], InSize);
  363.   if Pos(BeginLine, S) <= 0 then
  364.   begin
  365.     Result := PEM_DECODE_RESULT_INVALID_FORMAT;
  366.     Exit;
  367.   end;
  369.   I1 := Pos(#13#13#10, S);
  370.   I2 := Pos(#13#10, S);
  371.   I3 := Pos(#10, S);
  372.   if I1 = 0 then I1 := $7FFFFFFF;
  373.   if I2 = 0 then I2 := $7FFFFFFF;
  374.   if I3 = 0 then I3 := $7FFFFFFF;
  375.   I := Min(Min(I1, I2), I3);
  376.   if I = I1 then
  377.     EolLen := 3
  378.   else if I = I2 then
  379.     EolLen := 2
  380.   else
  381.     EolLen := 1;
  383.   if I = $7FFFFFFF then
  384.   begin
  385.     Result := PEM_DECODE_RESULT_INVALID_FORMAT;
  386.     OutSize := 0;
  387.     Exit;
  388.   end;
  390.   Header := Copy(S, Length(BeginLine) + 1, I - Length(Line) - Length(BeginLine) - 1);
  391.   S := Copy(S, I + EolLen, Length(S));
  393.   if Pos('Proc-Type', S) = 1 then
  394.   begin
  396.     HeaderEnd := Pos(#$0D#$0D#$0A#$0D#$0D#$0A, S);
  397.     if HeaderEnd = 0 then
  398.     begin
  399.       HeaderEnd := Pos(#$0A#$0A, S);
  400.       if HeaderEnd = 0 then
  401.         HeaderEnd := Pos(#$0D#$0A#$0D#$0A, S);
  402.     end;
  404.     Headers := Copy(S, 1, HeaderEnd - 1);
  405.     
  406.     while Pos('DEK-Info:', Headers) > 1 do
  407.     begin
  408.       I := Pos(#$0A, Headers);
  409.       Headers := Copy(Headers, I + 1, Length(Headers));
  410.     end;
  412.     if Pos('DEK-Info:', Headers) = 1 then
  413.     begin
  414.       I := Pos(#$0A, Headers);
  416.       if I > 0 then
  417.         Headers := Copy(Headers, 1, I - 1);
  418.       I := Pos(' ', Headers);
  419.       Headers := Copy(Headers, I + 1, Length(Headers));
  420.       I := Pos(',', Headers);
  421.       Tmp := Copy(Headers, 1, I - 1);
  423.       {$ifndef SBB_NO_DES}
  424.       if CompareStr('DES-CBC', Tmp) = integer(0) then
  425.         Cipher := SB_ALGORITHM_CNT_DES
  426.       else
  427.       if CompareStr('DES-EDE3-CBC', Tmp) = integer(0) then
  428.         Cipher := SB_ALGORITHM_CNT_3DES
  429.       else
  430.       {$endif}
  431.       begin
  432.         Result := PEM_DECODE_RESULT_UNKNOWN_CIPHER;
  433.         Exit;
  434.       end;
  435.       
  436.       Tmp := Copy(Headers, I + 1, Length(Headers));
  437.       S1 := HexStringToBuffer(Tmp);
  439.       {$ifndef SBB_NO_DES}
  440.       if Cipher = SB_ALGORITHM_CNT_DES then
  441.       begin
  442.         S2 := BytesToKey(Passphrase, S1, 8);
  443.         Move(S2[1], DESKey[0], 8);
  444.         Move(S1[1], DESIV[0], 8);
  445.       end
  446.       else
  447.       if Cipher = SB_ALGORITHM_CNT_3DES then
  448.       begin
  449.         S2 := BytesToKey(Passphrase, S1, 24);
  450.         Move(S2[1], DESEDE3Key[0], 24);
  451.         Move(S1[1], DESEDE3IV[0], 8);
  452.       end;
  453.       {$endif}
  454.       Headers := '';
  455.       {$ifndef SBB_NO_DES}
  456.       for I := 0 to 7 do
  457.         if Cipher = SB_ALGORITHM_CNT_DES then
  458.           Headers := Headers + IntToHex(DESIV[I], 2)
  459.         else
  460.         if Cipher = SB_ALGORITHM_CNT_3DES then
  461.           Headers := Headers + IntToHex(DESEDE3IV[I], 2);
  462.       {$endif}
  463.       if CompareStr(Headers, Tmp) <> integer(0) then
  464.       begin
  465.         Result := PEM_DECODE_RESULT_INVALID_PASSPHRASE;
  466.         Exit;
  467.       end;
  468.       I := Pos(EndLine, S);
  469.       Res := Base64Decode(@S[HeaderEnd + 2], I - HeaderEnd - 2, OutBuffer, OutSize);
  471.       if Res = 0 then
  472.       begin
  473.         {$ifndef SBB_NO_DES}
  474.         if Cipher = SB_ALGORITHM_CNT_DES then
  475.         begin
  476.           SBDES.InitializeDecryptionCBC(Ctx, DESKey, DESIV);
  477.           Sz := OutSize;
  478.           SBDES.DecryptCBC(Ctx, OutBuffer, OutSize, OutBuffer, Sz);
  479.         end
  480.         else
  481.         if Cipher = SB_ALGORITHM_CNT_3DES then
  482.         begin
  483.           SB3DES.InitializeDecryptionCBC(CtxEDE, DESEDE3Key, DESEDE3IV);
  484.           Sz := OutSize;
  485.           SB3DES.DecryptCBC(CtxEDE, OutBuffer, OutSize, OutBuffer, Sz);
  486.         end;
  487.         {$endif}
  488.         if PByteArray(OutBuffer)[Sz - 1] > 8 then
  489.         begin
  490.           Result := PEM_DECODE_RESULT_INVALID_PASSPHRASE;
  491.           Exit;
  492.         end;
  493.         OutSize := Sz - PByteArray(OutBuffer)[Sz - 1];
  494.         if OutSize < 0 then
  495.         begin
  496.           Result := PEM_DECODE_RESULT_INVALID_PASSPHRASE;
  497.           Exit;
  498.         end;
  499.         Result := PEM_DECODE_RESULT_OK;
  500.       end
  501.       else
  502.       if Res = BASE64_DECODE_NOT_ENOUGH_SPACE then
  503.       begin
  504.         Result := PEM_DECODE_RESULT_NOT_ENOUGH_SPACE;
  505.         Exit;
  506.       end
  507.       else
  508.       if Res = BASE64_DECODE_INVALID_CHARACTER then
  509.       begin
  510.         Result := PEM_DECODE_RESULT_INVALID_FORMAT;
  511.         Exit;
  512.       end;
  513.     end
  514.     else
  515.     begin
  516.       Result := PEM_DECODE_RESULT_INVALID_FORMAT;
  517.       Exit;
  518.     end;
  519.   end
  520.   else
  521.   begin
  522.     I := Pos(EndLine, S);
  523.     Result := Base64Decode(@S[1], I - 1, OutBuffer, OutSize);
  525.     case Result of
  526.       BASE64_DECODE_OK:
  527.         Result := PEM_DECODE_RESULT_OK;
  528.       BASE64_DECODE_NOT_ENOUGH_SPACE:
  529.         Result := PEM_DECODE_RESULT_NOT_ENOUGH_SPACE
  530.     else
  531.       Result := PEM_DECODE_RESULT_INVALID_FORMAT;
  532.     end;
  533.   end;
  534. end;
  536. function TElPEMProcessor.PEMEncode(const InBuffer : ByteArray; var OutBuffer : ByteArray; Encrypt : boolean) : boolean;
  537. var OutSize : integer;
  538. begin
  539.   OutSize := 0;
  540.   Encode(InBuffer, Length(InBuffer), nil, OutSize, FHeader, Encrypt, FPassphrase);
  541.   SetLength(OutBuffer, OutSize);
  542.   result := Encode(InBuffer, Length(InBuffer), OutBuffer, OutSize, FHeader, Encrypt, FPassphrase);
  543.   if result then
  544.   begin
  545.     if (Length(OutBuffer) <> OutSize) then
  546.      SetLength(OutBuffer, OutSize);
  547.   end
  548.   else
  549.     SetLength(OutBuffer, 0);
  550. end;
  552. function TElPEMProcessor.PEMEncode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  553.   var OutSize : integer; Encrypt : boolean) : boolean;
  554. begin
  555.   result := Encode(InBuffer, InSize, OutBuffer, OutSize, FHeader, Encrypt, FPassphrase);
  556. end;
  558. function TElPEMProcessor.PEMDecode(const InBuffer : ByteArray; var OutBuffer : ByteArray) : integer;
  559. var OutSize : integer;
  560. begin
  561.   OutSize := 0;
  562.   result := Decode(InBuffer, Length(InBuffer),  nil, FPassphrase, OutSize, FHeader);
  563.   if result = PEM_DECODE_RESULT_NOT_ENOUGH_SPACE then
  564.   begin
  565.     SetLength(OutBuffer, OutSize);
  566.     result := Decode(InBuffer, Length(InBuffer),  OutBuffer, FPassphrase, OutSize, FHeader);
  567.     if result = 0 then
  568.     begin
  569.       if (Length(OutBuffer) <> OutSize) then
  570.        SetLength(OutBuffer, OutSize);
  571.     end
  572.     else
  573.       SetLength(OutBuffer, 0);
  574.   end
  575.   else
  576.     SetLength(OutBuffer, 0);
  577. end;
  579. function TElPEMProcessor.PEMDecode(InBuffer : pointer; InSize : integer; OutBuffer : pointer;
  580.   var OutSize : integer) : integer;
  581. begin
  582.   result := Decode(InBuffer, InSize, OutBuffer, FPassphrase, OutSize, FHeader);
  583. end;
  585. function IsBase64UnicodeSequence(Buffer : pointer; Size : integer) : boolean;
  586. var i : integer;
  587.     eqcnt : integer;
  588. begin
  589.   result := true;
  590.   i := 0;
  591.   eqcnt := 0;
  592.   while i < Size do
  593.   begin
  594.     if PByteArray(Buffer)[i + 1] <> 0 then
  595.     begin
  596.       result := false;
  597.       exit;
  598.     end;
  599.     case Char(PByteArray(Buffer)[i]) of
  600.       'A' .. 'Z',
  601.       'a' .. 'z',
  602.       '0' .. '9',
  603.       '+',   '/':
  604.         begin
  605.           if eqcnt = 0 then
  606.           begin
  607.             inc(i, 2);
  608.             continue;
  609.           end
  610.           else
  611.           begin
  612.             result := false;
  613.             break;
  614.           end;
  615.         end;
  616.       #0:
  617.         begin
  618.           if eqcnt > 0 then
  619.           begin
  620.             inc(i, 2);
  621.             continue;
  622.           end
  623.           else
  624.           begin
  625.             result := false;
  626.             break;
  627.           end;
  628.         end;
  629.       #13, #10:
  630.         begin
  631.           inc(i, 2);
  632.           continue;
  633.         end;
  634.       '=':
  635.         begin
  636.           if eqcnt < 2 then
  637.           begin
  638.             inc(eqcnt);
  639.             inc(i, 2);
  640.             Continue;
  641.           end
  642.           else
  643.           begin
  644.             result := false;
  645.             exit;
  646.           end;
  647.         end;
  648.       else
  649.       begin
  650.         result := false;
  651.         exit;
  652.       end;
  653.     end;
  654.   end;
  655. end;
  657. function IsBase64Sequence(Buffer : pointer; Size : integer) : boolean;
  658. var i : integer;
  659.     eqcnt : integer;
  660. begin
  661.   result := true;
  662.   eqcnt := 0;
  663.   for i := 0 to Size - 1 do
  664.   begin
  665.     case Char(PByteArray(Buffer)[i]) of
  666.       'A' .. 'Z',
  667.       'a' .. 'z',
  668.       '0' .. '9',
  669.       '+',   '/':
  670.         begin
  671.           if eqcnt = 0 then
  672.             continue
  673.           else
  674.           begin
  675.             result := false;
  676.             break;
  677.           end;
  678.         end;
  679.       #0:
  680.         begin
  681.           if eqcnt > 0 then
  682.           begin
  683.             continue;
  684.           end
  685.           else
  686.           begin
  687.             result := false;
  688.             break;
  689.           end;
  690.         end;
  691.       #13, #10:
  692.         begin
  693.           continue;
  694.         end;
  695.       '=':
  696.         begin
  697.           if eqcnt < 2 then
  698.           begin
  699.             inc(eqcnt);
  700.             Continue;
  701.           end
  702.           else
  703.           begin
  704.             result := false;
  705.             exit;
  706.           end;
  707.         end;
  708.       else
  709.       begin
  710.         result := false;
  711.         exit;
  712.       end;
  713.     end;
  714.   end;
  715. end;
  717. { Base64 processing routines }
  719. const
  720.   Base64Symbols : array [0..63] of byte =
  721.     (
  722.      $41, $42, $43, $44, $45, $46, $47, $48, $49, $4A, $4B, $4C, $4D, $4E, $4F, $50,
  723.      $51, $52, $53, $54, $55, $56, $57, $58, $59, $5A, $61, $62, $63, $64, $65, $66,
  724.      $67, $68, $69, $6A, $6B, $6C, $6D, $6E, $6F, $70, $71, $72, $73, $74, $75, $76,
  725.      $77, $78, $79, $7A, $30, $31, $32, $33, $34, $35, $36, $37, $38, $39, $2B, $2F
  726.     );
  727.   Base64Values : array [0..255] of byte =
  728.     (
  729.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FE, $FE, $FF, $FF, $FE, $FF, $FF,
  730.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  731.      $FE, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $3E, $FF, $FF, $FF, $3F,
  732.      $34, $35, $36, $37, $38, $39, $3A, $3B, $3C, $3D, $FF, $FF, $FF, $FD, $FF, $FF,
  733.      $FF,  $0,  $1,  $2,  $3,  $4,  $5,  $6,  $7,  $8,  $9,  $A,  $B,  $C,  $D,  $E,
  734.       $F, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $FF, $FF, $FF, $FF, $FF,
  735.      $FF, $1A, $1B, $1C, $1D, $1E, $1F, $20, $21, $22, $23, $24, $25, $26, $27, $28,
  736.      $29, $2A, $2B, $2C, $2D, $2E, $2F, $30, $31, $32, $33, $FF, $FF, $FF, $FF, $FF,
  737.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  738.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  739.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  740.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  741.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  742.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  743.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF,
  744.      $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF
  745.     );
  747. function B64InitializeDecoding(var Ctx : TSBBase64Context) : boolean;
  748. begin
  749.   
  750.   Ctx.TailBytes := 0;
  751.   Ctx.EQUCount := 0;  
  752.  
  753.   Result := true;
  754. end;
  756. function B64InitializeEncoding(var Ctx : TSBBase64Context; LineSize : integer;
  757.   fEOL : TSBEOLMarker) : boolean;
  758. begin
  759.   
  760.   Result := false;
  761.   Ctx.TailBytes := 0;
  762.   Ctx.LineSize := LineSize;
  763.   Ctx.LineWritten := 0;
  764.   Ctx.EQUCount := 0;
  766.   if LineSize < 4 then Exit;
  768.   case fEOL of
  769.   emCRLF :
  770.     begin
  771.       Move(CRLFByteArray[1], Ctx.fEOL[0], Length(CRLFByteArray));
  772.       Ctx.EOLSize := Length(CRLFByteArray);
  773.     end;
  774.   emCR :
  775.     begin
  776.       Move(CRByteArray[1], Ctx.fEOL[0], Length(CRByteArray));
  777.       Ctx.EOLSize := Length(CRByteArray);
  778.     end;
  779.   emLF :
  780.     begin
  781.       Move(LFByteArray[1], Ctx.fEOL[0], Length(LFByteArray));
  782.       Ctx.EOLSize := Length(LFByteArray);
  783.     end;
  784.     else
  785.       Ctx.EOLSize := 0;
  786.   end;
  788.   Result := true;
  789. end;
  791. function B64Encode(var Ctx : TSBBase64Context; Buffer : pointer; Size : integer;
  792.   OutBuffer : pointer; var OutSize : integer) : boolean;
  793. var
  794.   EstSize, I, Chunks : integer;
  795. begin
  796.   EstSize := ((Size + Ctx.TailBytes) div 3) * 4;
  797.   if (Ctx.LineSize > 0) and (Ctx.EOLSize > 0) then
  798.     EstSize := EstSize + ((EstSize + Ctx.LineWritten) div Ctx.LineSize) * Ctx.EOLSize;
  800.   if OutSize < EstSize then
  801.   begin
  802.     OutSize := EstSize;
  803.     Result := false;
  804.     Exit;
  805.   end;
  807.   OutSize := EstSize;
  809.   if Size + Ctx.TailBytes < 3 then
  810.   begin
  811.     for I := 0 to Size - 1 do
  812.       Ctx.Tail[Ctx.TailBytes + I] := PByteArray(Buffer)^[I];
  813.     Inc(Ctx.TailBytes, Size);
  814.     Result := true;
  815.     OutSize := 0;
  816.     Exit;
  817.   end;
  819.   if Ctx.TailBytes > 0 then
  820.   begin
  821.     for I := 0 to 2 - Ctx.TailBytes do
  822.       Ctx.Tail[Ctx.TailBytes + I] := PByteArray(Buffer)^[I];
  824.     Inc(Cardinal(Buffer), 3 - Ctx.TailBytes);
  825.     Dec(Size, 3 - Ctx.TailBytes);
  827.     Ctx.TailBytes := 0;
  829.     Ctx.OutBuf[0] := Base64Symbols[Ctx.Tail[0] shr 2];
  830.     Ctx.OutBuf[1] := Base64Symbols[((Ctx.Tail[0] and 3) shl 4) or (Ctx.Tail[1] shr 4)];
  831.     Ctx.OutBuf[2] := Base64Symbols[((Ctx.Tail[1] and $f) shl 2) or (Ctx.Tail[2] shr 6)];
  832.     Ctx.OutBuf[3] := Base64Symbols[Ctx.Tail[2] and $3f];
  834.     if (Ctx.LineSize = 0) or (Ctx.LineWritten + 4 < Ctx.LineSize) then
  835.     begin
  836.       Move(Ctx.OutBuf[0], OutBuffer^, 4);
  837.       Inc(Cardinal(OutBuffer), 4);
  838.       Inc(Ctx.LineWritten, 4);
  839.     end
  840.     else
  841.     begin
  842.       I := Ctx.LineSize - Ctx.LineWritten;
  843.       Move(Ctx.OutBuf[0], OutBuffer^, I);
  844.       Inc(Cardinal(OutBuffer), I);
  845.       Move(Ctx.fEOL[0], OutBuffer^, Ctx.EOLSize);
  846.       Inc(Cardinal(OutBuffer), Ctx.EOLSize);
  847.       Move(Ctx.OutBuf[I], OutBuffer^, 4 - I);
  848.       Inc(Cardinal(OutBuffer), 4 - I);
  849.       Ctx.LineWritten := 4 - I;
  850.     end;
  851.   end;
  853.   while Size >= 3 do
  854.   begin
  855.     if Ctx.LineSize > 0 then
  856.     begin
  857.       Chunks := (Ctx.LineSize - Ctx.LineWritten) div 4;
  858.       if Chunks > Size div 3 then
  859.         Chunks := Size div 3;
  860.     end
  861.     else
  862.       Chunks := Size div 3;
  865.     for I := 0 to Chunks - 1 do
  866.     begin
  867.       PByte(OutBuffer)^ := Base64Symbols[PByteArray(Buffer)^[0] shr 2];
  868.       Inc(Cardinal(OutBuffer));
  869.       PByte(OutBuffer)^ := Base64Symbols[((PByteArray(Buffer)^[0] and 3) shl 4)
  870.         or (PByteArray(Buffer)^[1] shr 4)];
  871.       Inc(Cardinal(OutBuffer));
  872.       PByte(OutBuffer)^ := Base64Symbols[((PByteArray(Buffer)^[1] and $f) shl 2)
  873.         or (PByteArray(Buffer)^[2] shr 6)];
  874.       Inc(Cardinal(OutBuffer));
  875.       PByte(OutBuffer)^ := Base64Symbols[PByteArray(Buffer)^[2] and $3f];
  876.       Inc(Cardinal(OutBuffer));
  877.       Inc(Cardinal(Buffer), 3);
  878.     end;
  880.     Dec(Size, 3 * Chunks);
  882.     if Ctx.LineSize > 0 then
  883.     begin
  884.       Inc(Ctx.LineWritten, Chunks * 4);
  886.       if (Size >= 3) and (Ctx.LineSize - Ctx.LineWritten > 0) then
  887.       begin
  888.         Ctx.OutBuf[0] := Base64Symbols[PByteArray(Buffer)^[0] shr 2];
  889.         Ctx.OutBuf[1] := Base64Symbols[((PByteArray(Buffer)^[0] and 3) shl 4)
  890.           or (PByteArray(Buffer)^[1] shr 4)];
  891.         Ctx.OutBuf[2] := Base64Symbols[((PByteArray(Buffer)^[1] and $f) shl 2)
  892.           or (PByteArray(Buffer)^[2] shr 6)];
  893.         Ctx.OutBuf[3] := Base64Symbols[PByteArray(Buffer)^[2] and $3f];
  894.         Inc(Cardinal(Buffer), 3);
  896.         Dec(Size, 3);
  898.         I := Ctx.LineSize - Ctx.LineWritten;
  900.         Move(Ctx.OutBuf[0], OutBuffer^, I);
  901.         Inc(Cardinal(OutBuffer), I);
  902.         if Ctx.EOLSize > 0 then
  903.           Move(Ctx.fEOL[0], OutBuffer^, Ctx.EOLSize);
  904.         Inc(Cardinal(OutBuffer), Ctx.EOLSize);
  905.         Move(Ctx.OutBuf[I], OutBuffer^, 4 - I);
  906.         Inc(Cardinal(OutBuffer), 4 - I);
  908.         Ctx.LineWritten := 4 - I;
  909.       end
  910.       else if Ctx.LineWritten = Ctx.LineSize then
  911.       begin
  912.         Ctx.LineWritten := 0;
  913.         if Ctx.EOLSize > 0 then
  914.         begin
  915.           Move(Ctx.fEOL[0], OutBuffer^, Ctx.EOLSize);
  916.           Inc(Cardinal(OutBuffer), Ctx.EOLSize);
  917.         end;
  918.       end;
  919.     end;
  920.   end;
  922.   if Size > 0 then
  923.   begin
  924.     Move(Buffer^, Ctx.Tail[0], Size);
  925.     Ctx.TailBytes := Size;
  926.   end;
  928.   Result := true;
  929. end;
  931. function B64Decode(var Ctx : TSBBase64Context; Buffer : pointer; Size : integer;
  932.   OutBuffer : pointer; var OutSize : integer) : boolean;
  933. var
  934.   I, EstSize, EQUCount : integer;
  935.   BufPtr : pointer;
  936.   C : byte;
  937. begin
  938.   if Size = 0 then
  939.   begin
  940.     Result := true;
  941.     OutSize := 0;
  942.     Exit;
  943.   end;
  945.   EQUCount := Ctx.EQUCount;
  946.   EstSize := Ctx.TailBytes;
  947.   BufPtr := Buffer;
  949.   for I := 0 to Size - 1 do
  950.   begin
  951.     C := Base64Values[PByte(BufPtr)^];
  952.     if C < 64 then Inc(EstSize)
  953.     else if C = $ff then
  954.     begin
  955.       Result := false;
  956.       OutSize := 0;
  957.       Exit;
  958.     end
  959.     else if C = $fd then
  960.     begin
  961.       if EQUCount > 1 then
  962.       begin
  963.         Result := false;
  964.         OutSize := 0;
  965.         Exit;
  966.       end;
  968.       Inc(EQUCount);
  969.     end;
  971.     Inc(Cardinal(BufPtr));
  972.   end;
  974.   EstSize := (EstSize div 4) * 3;
  975.   if OutSize < EstSize then
  976.   begin
  977.     OutSize := EstSize;
  978.     Result := false;
  979.     Exit;
  980.   end;
  982.   Ctx.EQUCount := EQUCount;
  983.   OutSize := EstSize;
  985.   while Size > 0 do
  986.   begin
  987.     C := Base64Values[PByte(Buffer)^];
  988.     if C < 64 then
  989.     begin
  990.       Ctx.Tail[Ctx.TailBytes] := C;
  991.       Inc(Ctx.TailBytes);
  993.       if Ctx.TailBytes = 4 then
  994.       begin
  995.         PByte(OutBuffer)^ := (Ctx.Tail[0] shl 2) or (Ctx.Tail[1] shr 4);
  996.         Inc(Cardinal(OutBuffer));
  997.         PByte(OutBuffer)^ := ((Ctx.Tail[1] and $f) shl 4) or (Ctx.Tail[2] shr 2);
  998.         Inc(Cardinal(OutBuffer));
  999.         PByte(OutBuffer)^ := ((Ctx.Tail[2] and $3) shl 6) or Ctx.Tail[3];
  1000.         Inc(Cardinal(OutBuffer));
  1001.         Ctx.TailBytes := 0;
  1002.       end;
  1003.     end;
  1004.     Inc(Cardinal(Buffer));
  1005.     Dec(Size);
  1006.   end;
  1007.   Result := true;
  1008. end;
  1010. function B64FinalizeEncoding(var Ctx : TSBBase64Context;
  1011.   OutBuffer : pointer; var OutSize : integer) : boolean;
  1012. begin
  1013.   if Ctx.TailBytes = 0 then
  1014.   begin
  1015.     { writing trailing EOL }
  1016.     if (Ctx.EOLSize > 0) and (Ctx.LineWritten > 0) then
  1017.     begin
  1018.       if OutSize < Ctx.EOLSize then
  1019.       begin
  1020.         OutSize := Ctx.EOLSize;
  1021.         Result := false;
  1022.       end
  1023.       else
  1024.       begin
  1025.         OutSize := Ctx.EOLSize;
  1026.         Result := true;
  1027.         Move(Ctx.fEOL[0], OutBuffer^, Ctx.EOLSize);
  1028.       end;  
  1029.     end
  1030.     else
  1031.     begin
  1032.       OutSize := 0;
  1033.       Result := true;
  1034.     end;
  1036.     Exit;
  1037.   end;
  1039.   if OutSize < 4 + Ctx.EOLSize then
  1040.   begin
  1041.     OutSize := 4 + Ctx.EOLSize;
  1042.     Result := false;
  1043.     Exit;
  1044.   end;
  1046.   if Ctx.TailBytes = 1 then
  1047.   begin
  1048.     PByteArray(OutBuffer)^[0] := Base64Symbols[Ctx.Tail[0] shr 2];
  1049.     PByteArray(OutBuffer)^[1] := Base64Symbols[((Ctx.Tail[0] and 3) shl 4)];
  1050.     PByteArray(OutBuffer)^[2] := $3D; // '='
  1051.     PByteArray(OutBuffer)^[3] := $3D; // '='
  1052.   end
  1053.   else if Ctx.TailBytes = 2 then
  1054.   begin
  1055.     PByteArray(OutBuffer)^[0] := Base64Symbols[Ctx.Tail[0] shr 2];
  1056.     PByteArray(OutBuffer)^[1] := Base64Symbols[((Ctx.Tail[0] and 3) shl 4) or (Ctx.Tail[1] shr 4)];
  1057.     PByteArray(OutBuffer)^[2] := Base64Symbols[((Ctx.Tail[1] and $f) shl 2)];
  1058.     PByteArray(OutBuffer)^[3] := $3D; // '='
  1059.   end;
  1061.   if Ctx.EOLSize > 0 then
  1062.     Move(Ctx.fEOL[0], PByteArray(OutBuffer)^[4], Ctx.EOLSize);
  1063.     
  1064.   OutSize := 4 + Ctx.EOLSize;
  1065.   Result := true;
  1066. end;
  1068. function B64FinalizeDecoding(var Ctx : TSBBase64Context;
  1069.   OutBuffer : pointer; var OutSize : integer) : boolean;
  1070. begin
  1071.   if (Ctx.EQUCount = 0) then
  1072.   begin
  1073.     OutSize := 0;
  1074.     Result := Ctx.TailBytes = 0;
  1075.     Exit;
  1076.   end
  1077.   else if (Ctx.EQUCount = 1) then
  1078.   begin
  1079.     if Ctx.TailBytes <> 3 then
  1080.     begin
  1081.       Result := false;
  1082.       OutSize := 0;
  1083.       Exit;
  1084.     end;
  1086.     if OutSize < 2 then
  1087.     begin
  1088.       OutSize := 2;
  1089.       Result := false;
  1090.       Exit;
  1091.     end;
  1093.     PByte(OutBuffer)^ := (Ctx.Tail[0] shl 2) or (Ctx.Tail[1] shr 4);
  1094.     Inc(Cardinal(OutBuffer));
  1095.     PByte(OutBuffer)^ := ((Ctx.Tail[1] and $f) shl 4) or (Ctx.Tail[2] shr 2);
  1096.     OutSize := 2;
  1097.     Result := true;
  1098.   end
  1099.   else if (Ctx.EQUCount = 2) then
  1100.   begin
  1101.     if Ctx.TailBytes <> 2 then
  1102.     begin
  1103.       Result := false;
  1104.       OutSize := 0;
  1105.       Exit;
  1106.     end;
  1108.     if OutSize < 1 then
  1109.     begin
  1110.       OutSize := 1;
  1111.       Result := false;
  1112.       Exit;
  1113.     end;
  1115.     PByte(OutBuffer)^ := (Ctx.Tail[0] shl 2) or (Ctx.Tail[1] shr 4);
  1117.     OutSize := 1;
  1118.     Result := true;
  1119.   end
  1120.   else
  1121.   begin
  1122.     Result := false;
  1123.     OutSize := 0;
  1124.   end;
  1125. end;
  1127. end.