* PChar -> PAnsiChar

packages/fcl-hash/src/fpasn.pp

@@ -35,7 +35,7 @@ const
   // ASN_organizationName = '2.5.4.10';
   // ASN_organizationalUnitName = '2.5.4.11';
   // ASN_countryName = '2.5.4.6';
-  // ASN_stateOrProvinceName = '2.5.4.8';
+  // ASN_stateOrProvince Name = '2.5.4.8';
   // ASN_localityName = '2.5.4.7';
   ASN_ecPublicKey = '1.2.840.10045.2.1';
   // ASN_prime256v1 = '1.2.840.10045.3.1.7';
@@ -50,8 +50,8 @@ const
 //------------------------------------------------------------------------------
 // ASN
 //------------------------------------------------------------------------------
-procedure ASNEncodeOID(const Value: Int64; var Result: String);
-function ASNDecodeOID(var Start: Integer; const S: String): Int64; overload;
+procedure ASNEncodeOID(const Value: Int64; var Result: AnsiString);
+function ASNDecodeOID(var Start: Integer; const S: AnsiString): Int64; overload;
 function ASNDecodeOID(var Buffer: PByte; BufferEnd: PByte): Int64; overload;
 function ASNGetEncodedLen(const Len: Integer): Integer;
 procedure ASNEncodeLen(const Len: Integer; var Buffer: TBytes);
@@ -69,11 +69,11 @@ function ASNWriteBitStrBegin(s: TMemoryStream): int64;
 procedure ASNWriteBitStrEnd(BitStrBegin: int64; s: TMemoryStream);
 
 // Encodes ASN.1 object to binary form
-procedure ASNObject(const Data: String; const ASNType: Integer; var Buffer: TBytes);
+procedure ASNObject(const Data: AnsiString; const ASNType: Integer; var Buffer: TBytes);
 // Encodes an MIB OID String to binary form
-procedure MibToId(Mib: String; var Result: String);
+procedure MibToId(Mib: AnsiString; var Result: AnsiString);
 // Decodes MIB OID from binary form to String form.
-procedure IdToMib(const Id: String; var Result: String); overload;
+procedure IdToMib(const Id: AnsiString; var Result: AnsiString); overload;
 function IdToMib(Buffer, BufferEnd: PByte): string; overload;
 
 procedure ASNDebug(const Buffer: TBytes; var Output: TBytes);
@@ -83,6 +83,7 @@ procedure ASNParse_GetItem(List: TStrings; Index: integer; out ASNType, ASNSize:
 function ASNParse_GetIntBytes(List: TStrings; ListIndex: integer; ID: int64): TBytes;
 function ASNFetch(var Buffer: PByte; BufferEnd: PByte; Out ASNType, ASNSize: Int32): Boolean; overload;
 function ASNFetchOID(var Buffer: PByte; BufferEnd: PByte; out OID: String): Boolean; overload;
+function ASNFetchOID(var Buffer: PByte; BufferEnd: PByte; out OID: AnsiString): Boolean; overload;
 
 implementation
 
@@ -90,13 +91,13 @@ implementation
 // ASN
 //------------------------------------------------------------------------------
 
-procedure ASNEncodeOID(const Value: Int64; var Result: String);
+procedure ASNEncodeOID(const Value: Int64; var Result: AnsiString);
 var
   B: Boolean;
   I: Integer;
   x: Int64;
   Modulo: Byte;
-  S: String;
+  S: AnsiString;
 
 begin
   S:='';
@@ -109,14 +110,14 @@ begin
       Modulo := Modulo or $80;
     if x > 0 then
       B := True;
-    S:=S+Char(Modulo);
+    S:=S+AnsiChar(Modulo);
   until x = 0;
   for I:=Length(S) downto 1 do
     Result:=Result+S[I];
 end;
 
 // @Start=0
-function ASNDecodeOID(var Start: Integer; const S: String): Int64;
+function ASNDecodeOID(var Start: Integer; const S: AnsiString): Int64;
 var
   x: Integer;
 begin
@@ -160,11 +161,11 @@ begin
   repeat
     y := x mod 256;
     x := x div 256;
-    S:=S+Char(y);
+    S:=S+AnsiChar(y);
   until x = 0;
   y := Length(S);
   y := y or $80;
-  S:=S+Char(y);
+  S:=S+AnsiChar(y);
   for x := Length(S) downto 1 do
     Buffer:=Concat(Buffer,[Ord(S[x])]);
 end;
@@ -212,7 +213,7 @@ var
   x: Int64;
   y: byte;
   neg: Boolean;
-  S : String;
+  S : AnsiString;
 begin
   S:='';
   neg := Value < 0;
@@ -309,7 +310,7 @@ end;
 
 procedure ASNWriteObjID(const ObjID: string; s: TStream);
 var
-  Mib: string;
+  Mib: Ansistring;
   aLen: TBytes;
 begin
   Mib:='';
@@ -363,7 +364,7 @@ begin
   ASNWriteSequenceEnd(BitStrBegin,s);
 end;
 
-Procedure AppendStringToBuffer(var Buffer: TBytes; const aString : String);
+Procedure AppendStringToBuffer(var Buffer: TBytes; const aString : AnsiString);
 Var
   Buflen,sLen : integer;
 begin
@@ -374,7 +375,7 @@ begin
     Move(aString[1],Buffer[Buflen],sLen);
 end;
 
-procedure ASNObject(const Data: String; const ASNType: Integer; var Buffer: TBytes);
+procedure ASNObject(const Data: AnsiString; const ASNType: Integer; var Buffer: TBytes);
 begin
   Buffer:=Concat(Buffer,[ASNType]);
   ASNEncodeLen(Length(Data), Buffer);
@@ -401,14 +402,14 @@ begin
   end;
 end;
 
-procedure OutputHexa(var Output: TBytes; const S: String);
+procedure OutputHexa(var Output: TBytes; const S: AnsiString);
 
 var
   I: Integer;
   P: PByte;
 
 begin
-  P := PByte(PChar(S));
+  P := PByte(PAnsiChar(S));
   for I := 1 to Length(S) do
   begin
     AppendStringToBuffer(Output, HexStr(P^,2));
@@ -416,9 +417,9 @@ begin
   end;
 end;
 
-procedure MibToId(Mib: String; var Result: String);
+procedure MibToId(Mib: AnsiString; var Result: AnsiString);
 
-  function WalkInt(var S: String): Integer;
+  function WalkInt(var S: AnsiString): Integer;
   var
     P : Integer;
   begin
@@ -442,7 +443,7 @@ begin
   end;
 end;
 
-procedure IdToMib(const Id: String; var Result: String);
+procedure IdToMib(const Id: AnsiString; var Result: AnsiString);
 var
   x, y, Index: Integer;
 begin
@@ -506,21 +507,24 @@ end;
 // Decode the ASN.1 item of the next element in @Buffer. Type of item is stored in @ASNType
 procedure ASNDebugItem(var Buffer: PByte; BufferEnd: PByte; Out ASNType, ASNSize: Integer; var Output: TBytes);
 
-  procedure BufToString(out S : String);
+  procedure BufToString(out S : AnsiString);
+  
+  var
+    SA : AnsiString;
 
   begin
-    S:='';
-    SetLength(S,ASNSize);
+    SetLength(SA,ASNSize);
     if ASNSize>0 then
     begin
-      Move(Buffer^,S[1],ASNSize);
+      Move(Buffer^,SA[1],ASNSize);
       inc(Buffer,ASNSize);
     end;
+    S:=SA;
   end;
 
 var
   n: Integer;
-  S, S2: String;
+  S, S2: AnsiString;
   y: Int64;
   OldBuffer: PByte;
 begin
@@ -689,7 +693,7 @@ end;
 procedure ASNDebug(const Buffer: TBytes; var Output: TBytes);
 
 const
-  SSpaces: String = '                                                                     ';
+  SSpaces: AnsiString = '                                                                     ';
 
 var
   ASNSize, ASNType, n: Integer;
@@ -706,7 +710,7 @@ begin
   EndP:=StartP+length(Buffer);
   while p<EndP do
   begin
-    //writeln('ASNDebug p=',p-StartP,' Type=',hexstr(p^,2),' Indent=',length(IndentList));
+    writeln('ASNDebug p=',p-StartP,' Type=',hexstr(p^,2),' Indent=',length(IndentList));
     // check if any sequence/set has ended and unindent
     for n := Length(IndentList)-1 downto 0 do
     begin
@@ -740,18 +744,19 @@ end;
 
 procedure ASNParseAddInt(var Buffer: PByte; BufferEnd: PByte; List: TStrings; const ASNType, ASNSize: Integer; Signed: boolean);
 
-  procedure BufToString(var S : String);
+  procedure BufToString(var S : AnsiString);
 
   begin
     SetLength(S,ASNSize);
-    if ASNSize=0 then exit;
+    if ASNSize=0 then
+      exit;
     Move(Buffer^,S[1],ASNSize);
     inc(Buffer, ASNSize);
   end;
 
 var
-  S, S2: String;
-  y: Int64;
+  S, S2: AnsiString;
+  y:  Int64;
 begin
   S:='';
   S2:='';
@@ -765,7 +770,7 @@ begin
   end else
   begin
     BufToString(S2);
-    if S2[1] = Char(#00) then
+    if S2[1] = AnsiChar(#00) then
       Delete(S2,1,1);
     BytesToHexStr(S,GetRawStringBytes(S2));
   end;
@@ -799,6 +804,16 @@ begin
   Result:=true;
 end;
 
+function ASNFetchOID(var Buffer: PByte; BufferEnd: PByte; out OID: AnsiString): Boolean; overload;
+
+Var
+  OIDS : String;
+
+begin
+  Result:=ASNFetchOID(Buffer,BufferEnd,OIDS);
+  OID:=OIDS;
+end;
+
 function ASNFetchOID(var Buffer: PByte; BufferEnd: PByte; out OID: String): Boolean;
 var
   ASNType, ASNSize: Int32;
@@ -828,18 +843,18 @@ end;
 
 function ASNParseItem(var Buffer: PByte; BufferEnd: PByte; List: TStrings): boolean;
 
-  function BufToString(Len : Integer): String;
+  function BufToString(Len : Integer): AnsiString;
   begin
     SetLength(Result{%H-},Len);
     if Len=0 then exit;
-    Move(Buffer^,Result[1],Len);
+      Move(Buffer^,Result[1],Len);
     inc(Buffer, Len);
   end;
 
 var
   ASNType, ASNSize: Integer;
   n: Integer;
-  S, S2: String;
+  S,S2: AnsiString;
   y: Int64;
   OldBuffer: PByte;
 
@@ -937,7 +952,10 @@ end;
 procedure ASNParse(const Buffer: TBytes; List: TStrings);
 var
   P, EndP: PByte;
+  O : Tbytes;
 begin
+  ASNDebug(Buffer,O);
+  Writeln(TEncoding.UTF8.GetAnsiString(O));
   if length(Buffer)=0 then exit;
   P:=@Buffer[0];
   EndP:=P+length(Buffer);

packages/fcl-hash/src/fphashutils.pp

@@ -33,8 +33,9 @@ Procedure BytesToVar(const aBytes : TBytes; out aLocation; aSize : Integer);
 Procedure BytesToVar(const aBytes : TBytes; Out aLocation : Pointer);
 
 Procedure HexStrToBytes(Const aHexStr : String; out aBytes : TBytes); overload;
+Procedure HexStrToBytes(Const aHexStr : AnsiString; out aBytes : TBytes); overload;
 Function HexStrToBytes(Const aHexStr : String) : TBytes; overload;
-Function HexStrToString(Const aHexStr : String) : String; overload;
+Function HexStrToString(Const aHexStr :  String) : AnsiString; overload;
 
 Function BytesToHexStr(Const aSource : AnsiString) : Ansistring; overload;
 Procedure BytesToHexStr(out aHexStr : AnsiString;Const aSource : AnsiString); overload;
@@ -42,7 +43,7 @@ Procedure BytesToHexStr(out aHexStr : AnsiString; aBytes : PByte; aSize : Intege
 Procedure BytesToHexStr(out aHexStr : AnsiString; aBytes : TBytes); overload;
 Function BytesToHexStr(aBytes : TBytes) : AnsiString; overload;
 Procedure BytesToHexStrAppend(aBytes : TBytes;var aHexStr : AnsiString);
-Function StringToHex(const s: string): string; overload;
+Function StringToHex(const s: ansistring): ansistring; overload;
 
 Procedure BytesEncodeBase64(Source: Tbytes; out Dest: AnsiString; const IsURL, MultiLines, Padding: Boolean);
 Function BytesEncodeBase64(Source: Tbytes; const IsURL, MultiLines, Padding: Boolean) : AnsiString;
@@ -99,7 +100,7 @@ begin
   HexStrToBytes(aHexStr,Result);
 end;
 
-function HexStrToString(const aHexStr: String): String;
+function HexStrToString(const aHexStr: String): AnsiString;
 var
   aBytes: TBytes;
   l: SizeInt;
@@ -112,7 +113,7 @@ begin
   Move(aBytes[0],Result[1],l);
 end;
 
-procedure HexStrToBytes(const aHexStr: String; out aBytes: TBytes);
+Procedure HexStrToBytes(Const aHexStr : AnsiString; out aBytes : TBytes); overload;
 
 const
   Convert: array['0'..'f'] of SmallInt =
@@ -142,6 +143,37 @@ begin
   end;
 end;
 
+
+procedure HexStrToBytes(const aHexStr: String; out aBytes: TBytes);
+
+const
+  Convert: array['0'..'f'] of SmallInt =
+    ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
+     -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+     -1,10,11,12,13,14,15);
+
+Var
+  Len : LongInt;
+  P: PChar;
+  PResult: PByte;
+
+begin
+  Len:=Length(aHexStr);
+  aBytes:=[];
+  SetLength(aBytes, (Len+1) div 2);
+  if Len=0 then Exit;
+  P := PChar(aHexStr);
+  PResult := PByte(aBytes);
+  while Len > 0 do
+  begin
+    PResult^ := (Convert[P[0]] shl 4) + Convert[P[1]];
+    Inc(PResult);
+    Inc(P, 2);
+    Dec(Len, 2);
+  end;
+end;
+
 function BytesToHexStr(const aSource: AnsiString): Ansistring;
 
 begin
@@ -151,7 +183,7 @@ end;
 procedure BytesToHexStr(out aHexStr: AnsiString; const aSource: AnsiString);
 
 begin
-  BytesToHexStr(aHexStr,PByte(PChar(aSource)),Length(aSource))
+  BytesToHexStr(aHexStr,PByte(PAnsiChar(aSource)),Length(aSource))
 end;
 
 procedure BytesToHexStr(out aHexStr : AnsiString; aBytes : PByte; aSize : Integer);
@@ -166,7 +198,7 @@ begin
     exit;
   SetLength(aHexStr,aSize*2);
   PB:=aBytes;
-  PC:=PChar(aHexStr);
+  PC:=PAnsiChar(aHexStr);
   for I:=0 to aSize-1 do
     begin
     PC^:=HexDigits[PB^ shr 4];
@@ -195,7 +227,7 @@ begin
   aHexStr:=aHexStr+BytesToHexStr(aBytes);
 end;
 
-function StringToHex(const s: string): string;
+function StringToHex(const s: ansistring): ansistring;
 begin
   if s='' then exit;
   BytesToHexStr(Result,@s[1],length(s));
@@ -325,7 +357,7 @@ begin
       DestBuf[0] := Ord('=');
       Inc(DestSize);
     end;
-  end else if Index = BufSize-1 then // Last remaining char
+  end else if Index = BufSize-1 then // Last remaining AnsiChar
   begin
     Ch1 := Source[Index];
     XBufferEncode64_1(DestBuf, Ch1, IsURL);

packages/fcl-hash/src/fppem.pp

@@ -65,7 +65,7 @@ end;
 procedure PemLoadPublicKey64FromList(List: TStrings; out PrivateKey: TEccPrivateKey; out PublicKey: TEccPublicKey; out PublicKeyX64, PublicKeyY64: AnsiString);
 
 var
-  SPrivateKeyHexa, SPublicKeyHexa: String;
+  SPrivateKeyHexa, SPublicKeyHexa: AnsiString;
   DecompressedPublicKey, SPrivateKey : TBytes;
 
 begin
@@ -149,6 +149,7 @@ begin
   ASNParsePemSection(Buffer, List, _BEGIN_EC_PRIVATE_KEY, _END_EC_PRIVATE_KEY);
   if List.Count < 7 then
     Exit;
+  Writeln(List.Text);
   CurveOID := List.Strings[4];
   Result := (CurveOID=ASN_secp256r1);
 end;
@@ -320,7 +321,8 @@ end;
 function PemToDER(const PEM, BeginTag, EndTag: String): TBytes;
 var
   sl: TStringList;
-  Line, TxtBase64: String;
+  Line :  AnsiString;
+  TxtBase64: AnsiString;
   StartIndex, EndIndex, i: Integer;
 begin
   Result:=[];

packages/fcl-hash/src/fprsa.pas

@@ -52,8 +52,8 @@ type
     Exponent1,           // dp
     Exponent2,           // dq
     Coefficient: TBytes; // qi
-    procedure InitWithHexStrings(const n, e, d, p, q, dp, dq, qi: string);
-    procedure InitWithBase64UrlEncoded(const n, e, d, p, q, dp, dq, qi: string);
+    procedure InitWithHexStrings(const n, e, d, p, q, dp, dq, qi: ansistring);
+    procedure InitWithBase64UrlEncoded(const n, e, d, p, q, dp, dq, qi: ansistring);
     procedure WriteASN(ms: TMemoryStream);
     function AsDER: TBytes;
   end;
@@ -63,8 +63,8 @@ type
   TX509RSAPublicKey = record
     Modulus: TBytes; // m or n
     Exponent: TBytes; // e
-    procedure InitWithHexStrings(const n, e: string);
-    procedure InitWithBase64UrlEncoded(const n, e: string);
+    procedure InitWithHexStrings(const n, e: AnsiString);
+    procedure InitWithBase64UrlEncoded(const n, e: ansistring);
     procedure WriteASN(ms: TMemoryStream);
     function AsDER: TBytes;
   end;
@@ -72,9 +72,9 @@ type
 procedure RSACreate(out RSA: TRSA);
 procedure RSAFree(var RSA: TRSA);
 
-procedure RsaPublicKeyToHexa(const Modulus, Exponent: String; var PublicKeyHexa: String);
-procedure RsaPublicKeyFromHexa(const PublicKeyHexa: String; out Modulus, Exponent: String);
-procedure RsaInitFromPublicKey(var RSA: TRSA; const Modulus, Exponent: String); overload;
+procedure RsaPublicKeyToHexa(const Modulus, Exponent: AnsiString; var PublicKeyHexa: AnsiString);
+procedure RsaPublicKeyFromHexa(const PublicKeyHexa: AnsiString; out Modulus, Exponent: AnsiString);
+procedure RsaInitFromPublicKey(var RSA: TRSA; const Modulus, Exponent: AnsiString); overload;
 procedure RSAInitFromPublicKey(var RSA: TRSA; const RSAPublicKey: TX509RSAPublicKey); overload;
 procedure RSAInitFromPublicKeyDER(var RSA: TRSA; const PublicKeyDER: TBytes);
 procedure X509RsaPublicKeyInitFromDER(out RSA: TX509RSAPublicKey; const PublicKeyDER: TBytes);
@@ -195,14 +195,13 @@ begin
   BITerminate(RSA.Context);
 end;
 
-procedure RsaPublicKeyToHexa(const Modulus, Exponent: String;
-  var PublicKeyHexa: String);
+procedure RsaPublicKeyToHexa(const Modulus, Exponent: AnsiString;
+  var PublicKeyHexa: AnsiString);
 begin
   PublicKeyHexa:=PublicKeyHexa+BytesToHexStr(Exponent)+BytesToHexStr(Modulus);
 end;
 
-procedure RsaPublicKeyFromHexa(const PublicKeyHexa: String; out Modulus,
-  Exponent: String);
+procedure RsaPublicKeyFromHexa(const PublicKeyHexa: AnsiString; out Modulus, Exponent: AnsiString);
 var
   aBytes: TBytes;
 begin
@@ -215,7 +214,7 @@ begin
   Move(aBytes[3],Modulus[1],length(Modulus));
 end;
 
-procedure RsaInitFromPublicKey(var RSA: TRSA; const Modulus, Exponent: String);
+procedure RsaInitFromPublicKey(var RSA: TRSA; const Modulus, Exponent: AnsiString);
 begin
   RSA.ModulusLen := length(Modulus);
   RSA.M := BIImport(RSA.Context, Modulus);
@@ -635,13 +634,13 @@ begin
   end;
 end;
 
-function RsaVerify(const Modulus, Exponent, Hash, Signature: String): Boolean;
+function RsaVerify(const Modulus, Exponent, Hash, Signature: AnsiString): Boolean;
 var
   ASNType, ASNSize: Int32;
   Data: array[0..4095] of byte;
-  Digest: String;
+  Digest: AnsiString;
   DataP, DataEnd: PByte;
-  OID: String;
+  OID: AnsiString;
   RSA: TRSA;
   Size: Integer;
 begin
@@ -718,7 +717,7 @@ end;
 function RS256VerifyFromPublicKeyHexa(const PublicKeyHexa, SignatureBaseHash,
   Signature: String): Boolean;
 var
-  Modulus, Exponent: String;
+  Modulus, Exponent: AnsiString;
 begin
   RsaPublicKeyFromHexa(PublicKeyHexa, Modulus, Exponent);
   Result := RsaVerify(Modulus, Exponent, SignatureBaseHash, Signature);
@@ -737,7 +736,8 @@ const
                +'18BFB311B8377C0FACDED4CD2B1E2692E480BE260BE355F050EBABF89E24F2833F56F0A74C185225DB3B47B63612FB9BDEE1E1B8707807093E1551F24527A763'
                +'1947D033ED7052C439E50B8A46E4D0C06DBC38AF1D64B49766A5CF9A82644650FFD733B61942DB0BD8D47C8EF24A02DC9FD2EF557B12DED804519F2B2B6C284D';
 var
-  Exponent, Modulus, Hash, Signature: string;
+  Exponent, Modulus, Hash, Signature: Ansistring;
+
 begin
   Exponent:=HexStrToString(_Exponent);
   Modulus:=HexStrToString(_Modulus);
@@ -1060,7 +1060,7 @@ function MGF1(const InputStr: string; HashFunc: PRSAHashFuncInfo; Len: integer):
 begin
   SetLength(Result{%H-},Len);
   if Len=0 then exit;
-  MGF1(PByte(PChar(InputStr)){InputStr might be empty!},length(InputStr), HashFunc, @Result[1], Len);
+  MGF1(PByte(PAnsiChar(InputStr)){InputStr might be empty!},length(InputStr), HashFunc, @Result[1], Len);
 end;
 
 procedure MGF1(Input: PByte; InLen: Integer; HashFunc: PRSAHashFuncInfo;
@@ -1182,7 +1182,7 @@ end;
 
 { TX509RSAPrivateKey }
 
-procedure TX509RSAPrivateKey.InitWithHexStrings(const n, e, d, p, q, dp, dq, qi: string
+procedure TX509RSAPrivateKey.InitWithHexStrings(const n, e, d, p, q, dp, dq, qi: Ansistring
   );
 begin
   Version:=0;
@@ -1197,7 +1197,7 @@ begin
 end;
 
 procedure TX509RSAPrivateKey.InitWithBase64UrlEncoded(const n, e, d, p, q, dp,
-  dq, qi: string);
+  dq, qi: Ansistring);
 begin
   Version:=0;
   Modulus:=Base64URL.Decode(n,false);
@@ -1244,13 +1244,13 @@ end;
 
 { TX509RSAPublicKey }
 
-procedure TX509RSAPublicKey.InitWithHexStrings(const n, e: string);
+procedure TX509RSAPublicKey.InitWithHexStrings(const n, e: ansistring);
 begin
   Modulus:=HexStrToBytes(n);
   Exponent:=HexStrToBytes(e);
 end;
 
-procedure TX509RSAPublicKey.InitWithBase64UrlEncoded(const n, e: string);
+procedure TX509RSAPublicKey.InitWithBase64UrlEncoded(const n, e: ansistring);
 begin
   Modulus:=Base64URL.Decode(n,false);
   Exponent:=Base64URL.Decode(e,false);

packages/fcl-hash/src/fptlsbigint.pas

@@ -1176,7 +1176,7 @@ end;
 
 function BIToString(BI: PBigInt): AnsiString;
 const
-  Digits: Array[0..15] of char = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
+  Digits: Array[0..15] of AnsiChar = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
 var
   I,J,K: Integer;
   Num: TBIComponent;

packages/fcl-hash/src/onetimepass.pp

@@ -32,7 +32,7 @@ function HOTPCalculateToken(const aSecret: AnsiString; const Counter: LongInt):
 function TOTPCalculateToken(const aSecret: AnsiString): LongInt;
 function TOTPGenerateToken(const aSecret: AnsiString): LongInt;
 function TOTPValidate(const aSecret: AnsiString; const Token: LongInt; const WindowSize: LongInt; var Counter: LongInt): Boolean;
-Function TOTPSharedSecret(aRandom : TRandomBytes = Nil) : String;
+Function TOTPSharedSecret(aRandom : TRandomBytes = Nil) : AnsiString;
 
 implementation
 
@@ -51,13 +51,13 @@ begin
     Result:=Result+AnsiChar(B[I]);
 end;
 
-function TOTPCalculateToken(const aSecret: String): Longint;
+function TOTPCalculateToken(const aSecret: AnsiString): Longint;
 
 begin
   Result:=HOTPCalculateToken(aSecret,-1);
 end;
 
-function HOTPCalculateToken(const aSecret: String; const Counter: Longint): Longint;
+function HOTPCalculateToken(const aSecret: AnsiString; const Counter: Longint): Longint;
 
 var
   Digest: TSHA1Digest;
@@ -65,16 +65,17 @@ var
   Offset: Longint;
   Part1, Part2, Part3, Part4: UInt32;
   SecretBinBuf: TBytes;
-  STime, SSecretBin: String;
+  STime, SSecretBin: RawbyteString;
   Time: Longint;
 
 begin
   Time := Counter;
   if Time=-1 then
     Time := DateTimeToUnix(Now,False) div TOTP_KeyRegeneration;
+  SSecretBin:='';
   SecretBinBuf:=Base32.Decode(aSecret);
   STime:=Int64ToRawString(Time);
-  SetLength(SSecretBin{%H-},length(SecretBinBuf));
+  SetLength(SSecretBin,length(SecretBinBuf));
   Move(SecretBinBuf[0],SSecretBin[1],length(SecretBinBuf));
   Digest:=HMACSHA1Digest(SSecretBin, STime);
   Offset := Digest[19] and $0F;
@@ -91,7 +92,7 @@ begin
   Result := HOTPCalculateToken(aSecret, -1);
 end;
 
-Function TOTPSharedSecret(aRandom : TRandomBytes = Nil) : String;
+Function TOTPSharedSecret(aRandom : TRandomBytes = Nil) : AnsiString;
 
 var
   RandomKey: TByteDynArray;
@@ -109,7 +110,7 @@ begin
 end;
 
 // @Secret Base32 encoded, @WindowSize=1
-function TOTPValidate(const aSecret: String; const Token: LongInt; const WindowSize: LongInt; var Counter: LongInt): Boolean;
+function TOTPValidate(const aSecret: AnsiString; const Token: LongInt; const WindowSize: LongInt; var Counter: LongInt): Boolean;
 var
   TimeStamp: Longint;
   UnixTime: Longint;

packages/fcl-hash/tests/testhash.lpi

@@ -81,9 +81,13 @@
       <Filename Value="testhash"/>
     </Target>
     <SearchPaths>
+      <IncludeFiles Value="$(ProjOutDir)"/>
       <OtherUnitFiles Value="../src"/>
       <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>
+    <Other>
+      <CustomOptions Value="-tunicodertl"/>
+    </Other>
   </CompilerOptions>
   <Debugging>
     <Exceptions>

packages/fcl-hash/tests/testhash.pp

@@ -5,6 +5,9 @@ program testhash;
 {$mode objfpc}
 
 uses
+{$ifdef unix}
+  cwstring,
+{$endif}
   consoletestrunner, utestsha256, utestonetimepass, utestsha512, utestpem, fpECC, fphashutils, fpsha256;
 
 var

packages/fcl-hash/tests/utestpem.pp

@@ -14,7 +14,7 @@ Type
 
   TTestPEM = Class(TTestCase)
   protected
-    procedure GetPEM_PrivateKeyRSA2048bit(out PrivatePEM, PublicPEM: string);
+    procedure GetPEM_PrivateKeyRSA2048bit(out PrivatePEM, PublicPEM: Ansistring);
   Published
     Procedure TestECC_Load;
     Procedure TestRSA_RS256Verify;
@@ -36,7 +36,7 @@ end;
 Const
   PrivateKeyFile = 'private-key.pem';
 
-procedure TTestPEM.GetPEM_PrivateKeyRSA2048bit(out PrivatePEM, PublicPEM: string
+procedure TTestPEM.GetPEM_PrivateKeyRSA2048bit(out PrivatePEM, PublicPEM: Ansistring
   );
 begin
   // generated with
@@ -112,7 +112,10 @@ var
 begin
   List := TStringList.Create;
   try
+    PrivateKey:=Default(TEccPrivateKey);
+    PublicKey:=Default(TEccPublicKey);
     Res:=FileExists(PrivateKeyFile) and PemIsECDSA(PrivateKeyFile, List);
+    AssertTrue('Have file with Key',Res);
     if Res then
       PemLoadPublicKey64FromList(List, PrivateKey, PublicKey, PublicKeyX64, PublicKeyY64);
     AssertEquals('Private key',resprivatekey,BytesToHexStr(BytesFromVar(@PrivateKey,Sizeof(PrivateKey))));
@@ -140,7 +143,7 @@ procedure TTestPEM.TestRSA_PrivatePublicPEM_NoPassphrase;
 const
   SecretMsg = 'FreePascal RSA Test';
 var
-  PrivatePEM, PublicPEM, Original, Encrypted, Decrypted: string;
+  PrivatePEM, PublicPEM, Original, Encrypted, Decrypted: Ansistring;
   DER: TBytes;
   PrivateRSA, PublicRSA: TRSA;
   EncryptedLen, DecryptedLen: Integer;

packages/fcl-hash/tests/utestsha512.pp

@@ -112,7 +112,7 @@ end;
 procedure TTestSHA512.TestSmallString;
 
 Var
-  S : String;
+  S : AnsiString;
 begin
   BytesToHexStr(S,@Test1Out,SizeOf(Test1Out));
   TestHexString('abc',S);
@@ -120,7 +120,7 @@ end;
 
 procedure TTestSHA512.TestLargeString;
 Var
-  S : String;
+  S : AnsiString;
 begin
   BytesToHexStr(S,@Test2Out,SizeOf(Test2Out));
   TestHexString('abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',S);
@@ -153,7 +153,7 @@ procedure TTestSHA512.TestHMACStream;
 
 Var
   S : TStringStream;
-  res : String;
+  res : AnsiString;
 
 begin
   BytesToHexStr(Res,@Test1Out,SizeOf(Test1Out));
@@ -223,7 +223,7 @@ end;
 
 procedure TTestSHA384.TestSmallString;
 Var
-  S : String;
+  S : AnsiString;
 begin
   BytesToHexStr(S,@Test1Out384,SizeOf(Test1Out384));
   TestHexString('abc',S);
@@ -231,7 +231,7 @@ end;
 
 procedure TTestSHA384.TestLargeString;
 Var
-  S : String;
+  S : AnsiString;
 begin
   BytesToHexStr(S,@Test2Out384,SizeOf(Test2Out384));
   TestHexString('abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu',S);
@@ -264,7 +264,7 @@ procedure TTestSHA384.TestHMACStream;
 
 Var
   S : TStringStream;
-  res : String;
+  res : AnsiString;
 
 begin
   BytesToHexStr(Res,@Test1Out384,SizeOf(Test1Out384));