Increase salt bytes to 32 from 16 + use platform secure random generator for salt generation (#18)

* Increase salt size from 16 to 32 bytes

* Improve salt generation with cryptographically secure random using Security framework

* Simplify secure random implementation using direct array reference

* Add clean tests for secure random generation

* Fix salt tests to be more realistic about random distribution

* Remove overly complex salt generation test

* Fix: Use MemoryLayout.size instead of stride for accurate byte count

* use SystemRandomNumberGenerator for generating random UInt8

* move random(count:) to other extension

Author: hakonk

Sources/SRP/Array.swift

@@ -1,21 +1,24 @@
-
 extension Array where Element: FixedWidthInteger {
-    /// create array of random bytes
-    static func random(count: Int) -> [Element] {
-        var array = self.init()
-        for _ in 0 ..< count {
-            array.append(.random(in: Element.min ..< Element.max))
-        }
-        return array
-    }
-
     /// generate a hexdigest of the array of bytes
     func hexdigest() -> String {
         return map {
             let characters = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]
             return "\(characters[Int($0 >> 4)])\(characters[Int($0 & 0xF)])"
         }.joined()
     }
+
+    /// create array of random bytes using cryptographically secure random number generation
+    static func random(count: Int) -> [Element] {
+        var array = [Element]()
+        array.reserveCapacity(count)
+        var g = SystemRandomNumberGenerator()
+        var i = 0
+        while i < count {
+            array.append(Element.random(in: Element.min...Element.max, using: &g))
+            i += 1
+        }
+        return array
+    }
 }
 
 extension Array where Element == UInt8 {

Sources/SRP/client.swift

@@ -165,7 +165,7 @@ public struct SRPClient<H: HashFunction> {
     ///   - password: user password
     /// - Returns: tuple containing salt and password verifier
     public func generateSaltAndVerifier(username: String, password: String) -> (salt: [UInt8], verifier: SRPKey) {
-        let salt = [UInt8].random(count: 16)
+        let salt = [UInt8].random(count: 32)
         let verifier = generatePasswordVerifier(username: username, password: password, salt: salt)
         return (salt: salt, verifier: SRPKey(verifier, padding: configuration.sizeN))
     }

Tests/SRPTests/SRPTests.swift

@@ -4,6 +4,29 @@ import Crypto
 import XCTest
 
 final class SRPTests: XCTestCase {
+    func testSecureRandomGeneration() {
+        // Test that random generation produces arrays of the correct size
+        let size1 = 16
+        let randomArray1 = [UInt8].random(count: size1)
+        XCTAssertEqual(randomArray1.count, size1, "Random array should have the requested size")
+        
+        let size2 = 32
+        let randomArray2 = [UInt8].random(count: size2)
+        XCTAssertEqual(randomArray2.count, size2, "Random array should have the requested size")
+        
+        // Test that random values are actually random (very unlikely to be the same)
+        let randomArray3 = [UInt8].random(count: 16)
+        let randomArray4 = [UInt8].random(count: 16)
+        XCTAssertNotEqual(randomArray3, randomArray4, "Random arrays should be different")
+        
+        // Test that all values are within valid UInt8 range
+        for byte in randomArray1 {
+            XCTAssertGreaterThanOrEqual(byte, UInt8.min)
+            XCTAssertLessThanOrEqual(byte, UInt8.max)
+        }
+    }
+    
+
     func testKeyConversion() {
         let hex = "00000102030405060708090a0b0c0d0e0f"
         XCTAssertEqual(SRPKey(hex: hex)?.hex, hex)
@@ -267,7 +290,8 @@ final class SRPTests: XCTestCase {
         ("testServerSessionProof", testServerSessionProof),
         ("testRFC5054Appendix", testRFC5054Appendix),
         ("testMozillaTestVectors", testMozillaTestVectors),
-        ("testConstantTimeEqual", testConstantTimeEqual),
+        ("testSecureRandomGeneration", testSecureRandomGeneration),
+        ("testConstantTimeEqual", testConstantTimeEqual)
     ]
 }