Introduces MinSaltLength class function and checked in BCrypt's Calc that the proper salt length is specified. Implemented further unit tests.

Author: MHumm

Source/DECHash.pas

@@ -1226,11 +1226,14 @@   THash_BCrypt = class(TDECPasswordHash)
     /// </summary>
     constructor Create; override;
     /// <summary>
-    ///   Returns the maximum supported length of the salt value
-    ///   in byte
+    ///   Returns the maximum supported length of the salt value in byte
     /// </summary>
     class function MaxSaltLength:UInt8; override;
     /// <summary>
+    ///   Returns the minimum supported length of the salt value in byte
+    /// </summary>
+    class function MinSaltLength:UInt8; override;
+    /// <summary>
     ///   Returns the maximum length of a user supplied password given for the
     ///   algorithm in byte
     /// </summary>
@@ -1334,7 +1337,8 @@ implementation
   sSHA3AbsorbFailure = 'Absorb: number of bits mod 8 <> 0 or squeezing active. '+
                        'Bits: %0:d, Squeezing: %1:s';
   /// <summary>
-  ///   Part of the failure message shown when setting HashSize of Shake algorithms to 0
+  ///   Part of the failure message shown when setting HashSize of Shake
+  ///   algorithms to 0.
   /// </summary>
   sHashOutputLength0 = 'HashSize must not be 0';
   /// <summary>
@@ -1347,6 +1351,12 @@ implementation
   ///   Exception message for password hashes when a too long password is specified
   /// </summary>
   sPasswordTooLong   = 'Password to be hashed is too long. Max. length: %0:d bytes';
+  /// <summary>
+  ///   Exception message for password hashes requiring a salt when a salt value
+  ///   which is either too short or too long has been specified
+  /// </summary>
+  sWrongSaltLength   = 'Length of specified salt value must be between %0:d '+
+                       'and %1:d bytes';
 
 { THash_MD2 }
 
@@ -5034,6 +5044,12 @@ procedure THash_BCrypt.Calc(const Data; DataSize: Integer);
   if (DataSize > MaxPasswordLength) then
     raise EDECHashException.CreateFmt(sPasswordTooLong, [MaxPasswordLength]);
 
+  // While this should normally be caught on setting salt already it is there
+  // especially to catch cases where no salt has been specified yet.
+  if (Length(FSalt) < MinSaltLength) or (Length(FSalt) > MaxSaltLength) then
+    raise EDECHashException.CreateFmt(sWrongSaltLength,
+                                      [MinSaltLength, MaxSaltLength]);
+
   // This automatically "adds" the required #0 terminator at the end of the password
   SetLength(PwdData, DataSize + 1);
   Move(Data, PwdData[0], DataSize);
@@ -5301,6 +5317,11 @@ class function THash_BCrypt.MinCost: UInt8;
   Result := 4;
 end;
 
+class function THash_BCrypt.MinSaltLength: UInt8;
+begin
+  Result := 16;
+end;
+
 procedure THash_BCrypt.SetCost(const Value: UInt32);
 begin
   if (Value in [MinCost..MaxCost]) then

Source/DECHashAuthentication.pas

@@ -631,7 +631,7 @@   TDECPasswordHash = class(TDECHashAuthentication)
     function  GetSalt: TBytes;
   strict protected
     /// <summary>
-    ///   Most if not all password hashing algorithms (like bcrypt) have a salt
+    ///   Most, if not all password hashing algorithms (like bcrypt) have a salt
     ///   parameter to modify the entered password value.
     /// </summary>
     FSalt : TBytes;
@@ -718,6 +718,11 @@   TDECPasswordHash = class(TDECHashAuthentication)
     /// </summary>
     class function MaxSaltLength:UInt8; virtual; abstract;
     /// <summary>
+    ///   Returns the minimum length of a salt value given for the algorithm
+    ///   in byte
+    /// </summary>
+    class function MinSaltLength:UInt8; virtual; abstract;
+    /// <summary>
     ///   Returns the maximum length of a user supplied password given for the
     ///   algorithm in byte
     /// </summary>
@@ -826,6 +831,10 @@ implementation
   /// </summary>
   sSaltValueTooLong     = 'Maximum allowed salt length (%0:d byte) exceeded';
   /// <summary>
+  ///   Exception message when specifying a salt value shorter than allowed
+  /// </summary>
+  sSaltValueTooShort    = 'Minumum allowed salt length (%0:d byte) exceeded';
+  /// <summary>
   ///   No class for the given crypt ID has been registered, so that ID is
   ///   not supported.
   /// </summary>
@@ -1408,6 +1417,9 @@ procedure TDECPasswordHash.SetSalt(const Value: TBytes);
   if (Length(Value) > MaxSaltLength) then
     raise EDECHashException.CreateFmt(sSaltValueTooLong, [MaxSaltLength]);
 
+  if (Length(Value) < MinSaltLength) then
+    raise EDECHashException.CreateFmt(sSaltValueTooShort, [MinSaltLength]);
+
   FSalt := Value;
 end;
 

Unit Tests/Tests/TestDECHash.pas

@@ -118,14 +118,14 @@   THash_TestTDECPasswordHash = class(TTestCase)
     procedure SetUp; override;
     procedure TearDown; override;
   protected
-//    procedure DoTestSalt0Exception;
     procedure DoTestSaltTooLongException;
+    procedure DoTestSaltTooShortException;
     procedure DoTestClassByCryptIdentityException;
   published
     procedure TestGetSalt;
     procedure TestSetSalt;
-//    procedure TestSalt0Exception;
     procedure TestSaltTooLongException;
+    procedure TestSaltTooShortException;
     procedure TestClassByCryptIdentitySuccess;
     procedure TestClassByCryptIdentityException;
   end;
@@ -677,20 +677,23 @@       TBCryptBSDTestData = record
     procedure SetUp; override;
     procedure DoTestCostFactorTooShortException;
     procedure DoTestCostFactorTooLongException;
+    procedure DoTestNoSaltSpecified;
   published
     procedure TestDigestSize;
     procedure TestBlockSize;
     procedure TestIsPasswordHash;
     procedure TestClassByName;
     procedure TestIdentity;
     procedure TestMaximumSaltLength;
+    procedure TestMinimumSaltLength;
     procedure TestMaximumPasswordLength;
     procedure TestMinCost;
     procedure TestMaxCost;
     procedure TestCostFactorTooShortException;
     procedure TestCostFactorTooLongException;
     procedure TestSetGetCostFactor;
     procedure TestCryptBSDFormat;
+    procedure TestNoSaltSpecified;
 //    procedure TestTooLongPasswordException;
   end;
 
@@ -6055,6 +6058,20 @@ procedure TestTHash_BCrypt.DoTestCostFactorTooShortException;
   THash_BCrypt(FHash).Cost := 3;
 end;
 
+procedure TestTHash_BCrypt.DoTestNoSaltSpecified;
+var
+  BCrypt : THash_BCrypt;
+begin
+  BCrypt := THash_BCrypt.Create;
+  try
+    BCrypt.Init;
+    BCrypt.Cost := 8;
+    BCrypt.CalcString('a');
+  finally
+    BCrypt.Free;
+  end;
+end;
+
 procedure TestTHash_BCrypt.SetUp;
 var
   lDataRow:IHashTestDataRowSetup;
@@ -6326,6 +6343,16 @@ procedure TestTHash_BCrypt.TestMinCost;
   CheckEquals(4, THash_BCrypt(FHash).MinCost);
 end;
 
+procedure TestTHash_BCrypt.TestMinimumSaltLength;
+begin
+  CheckEquals(16, TDECPasswordHash(FHash).MinSaltLength);
+end;
+
+procedure TestTHash_BCrypt.TestNoSaltSpecified;
+begin
+  CheckException(DoTestNoSaltSpecified, EDECHashException);
+end;
+
 procedure TestTHash_BCrypt.TestSetGetCostFactor;
 begin
   THash_BCrypt(FHash).Cost := 4;
@@ -6337,14 +6364,6 @@ procedure TestTHash_BCrypt.TestSetGetCostFactor;
 
 { THash_TestTDECPasswordHash }
 
-//procedure THash_TestTDECPasswordHash.DoTestSalt0Exception;
-//var
-//  EmptySalt : TBytes;
-//begin
-//  SetLength(EmptySalt, 0);
-//  FHash.Salt := EmptySalt;
-//end;
-
 procedure THash_TestTDECPasswordHash.DoTestClassByCryptIdentityException;
 begin
   TDECPasswordHash.ClassByCryptIdentity('nwrongID');
@@ -6359,6 +6378,14 @@ procedure THash_TestTDECPasswordHash.DoTestSaltTooLongException;
   FHash.Salt := EmptySalt;
 end;
 
+procedure THash_TestTDECPasswordHash.DoTestSaltTooShortException;
+var
+  EmptySalt : TBytes;
+begin
+  SetLength(EmptySalt, FHash.MinSaltLength - 1);
+
+  FHash.Salt := EmptySalt;
+end;
 
 procedure THash_TestTDECPasswordHash.SetUp;
 begin
@@ -6403,18 +6430,13 @@ procedure THash_TestTDECPasswordHash.TestGetSalt;
   ActSalt := FHash.Salt;
   CheckEquals(0, Length(ActSalt));
 
-  SetSalt := [1, 2, 3, 4];
+  SetSalt := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
   FHash.Salt := SetSalt;
 
   ActSalt := FHash.Salt;
   CheckEquals(true, System.SysUtils.CompareMem(@SetSalt[0], @ActSalt[0], Length(ActSalt)));
 end;
 
-//procedure THash_TestTDECPasswordHash.TestSalt0Exception;
-//begin
-//  CheckException(DoTestSalt0Exception, EDECHashException);
-//end;
-
 procedure THash_TestTDECPasswordHash.TestSaltTooLongException;
 var
   ActSalt : TBytes;
@@ -6428,11 +6450,24 @@ procedure THash_TestTDECPasswordHash.TestSaltTooLongException;
   CheckEquals(0, Length(ActSalt));
 end;
 
+procedure THash_TestTDECPasswordHash.TestSaltTooShortException;
+var
+  ActSalt : TBytes;
+begin
+  ActSalt := FHash.Salt;
+  CheckEquals(0, Length(ActSalt));
+
+  CheckException(DoTestSaltTooShortException, EDECHashException);
+
+  ActSalt := FHash.Salt;
+  CheckEquals(0, Length(ActSalt));
+end;
+
 procedure THash_TestTDECPasswordHash.TestSetSalt;
 var
   SetSalt, ActSalt : TBytes;
 begin
-  SetSalt := [1, 2, 3, 4];
+  SetSalt := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
   FHash.Salt := SetSalt;
 
   ActSalt := FHash.Salt;