Increase Salt randomness (#18179)

- The current implementation of `RandomString` doesn't give you a most-possible unique randomness. It gives you 6*`length` instead of the possible 8*`length` bits(or as `length`x bytes) randomness. This is because `RandomString` is being limited to a max value of 63, this in order to represent the random byte as a letter/digit.
- The recommendation of pbkdf2 is to use 64+ bit salt, which the `RandomString` doesn't give with a length of 10, instead of increasing 10 to a higher number, this patch adds a new function called `RandomBytes` which does give you the guarentee of 8*`length` randomness and thus corresponding of `length`x bytes randomness.
- Use hexadecimal to store the bytes value in the database, as mentioned, it doesn't play nice in order to convert it to a string. This will always be a length of 32(with `length` being 16).
- When we detect on `Authenticate`(source: db) that a user has the old format of salt, re-hash the password such that the user will have it's password hashed with increased salt.

Thanks to @zeripath for working out the rouge edges from my first commit 😄.

Co-authored-by: lafriks <lauris@nix.lv>
Co-authored-by: zeripath <art27@cantab.net>

2 files changed, 29 insertions, 2 deletions

diff --git a/modules/util/util.go b/modules/util/util.go
index cbc6eb4f8a..c2117a6525 100644
--- a/modules/util/util.go
+++ b/modules/util/util.go
@@ -139,11 +139,11 @@ func MergeInto(dict map[string]interface{}, values ...interface{}) (map[string]i
 
 // RandomInt returns a random integer between 0 and limit, inclusive
 func RandomInt(limit int64) (int64, error) {
-	int, err := rand.Int(rand.Reader, big.NewInt(limit))
+	rInt, err := rand.Int(rand.Reader, big.NewInt(limit))
 	if err != nil {
 		return 0, err
 	}
-	return int.Int64(), nil
+	return rInt.Int64(), nil
 }
 
 const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
@@ -161,3 +161,12 @@ func RandomString(length int64) (string, error) {
 	}
 	return string(bytes), nil
 }
+
+// RandomBytes generates `length` bytes
+// This differs from RandomString, as RandomString is limits each byte to have
+// a maximum value of 63 instead of 255(max byte size)
+func RandomBytes(length int64) ([]byte, error) {
+	bytes := make([]byte, length)
+	_, err := rand.Read(bytes)
+	return bytes, err
+}
diff --git a/modules/util/util_test.go b/modules/util/util_test.go
index 39cf07c855..f42b1a930f 100644
--- a/modules/util/util_test.go
+++ b/modules/util/util_test.go
@@ -157,6 +157,24 @@ func Test_RandomString(t *testing.T) {
 	assert.NotEqual(t, str3, str4)
 }
 
+func Test_RandomBytes(t *testing.T) {
+	bytes1, err := RandomBytes(32)
+	assert.NoError(t, err)
+
+	bytes2, err := RandomBytes(32)
+	assert.NoError(t, err)
+
+	assert.NotEqual(t, bytes1, bytes2)
+
+	bytes3, err := RandomBytes(256)
+	assert.NoError(t, err)
+
+	bytes4, err := RandomBytes(256)
+	assert.NoError(t, err)
+
+	assert.NotEqual(t, bytes3, bytes4)
+}
+
 func Test_OptionalBool(t *testing.T) {
 	assert.Equal(t, OptionalBoolNone, OptionalBoolParse(""))
 	assert.Equal(t, OptionalBoolNone, OptionalBoolParse("x"))