add more algorithms

Author: ba0f3

README.md

@@ -1,2 +1,13 @@
 # scram
 Salted Challenge Response Authentication Mechanism (SCRAM) 
+
+
+```nim
+var s = newScramClient[Sha256Digest]()
+s.clientNonce = "VeAOLsQ22fn/tjalHQIz7cQT"
+
+echo s.prepareFirstMessage("bob")
+let finalMessage = s.prepareFinalMessage("secret", "r=VeAOLsQ22fn/tjalHQIz7cQTmeE5qJh8qKEe8wALMut1,s=ldZSefTzKxPNJhP73AmW/A==,i=4096")
+echo finalMessage
+assert(finalMessage == "c=biws,r=VeAOLsQ22fn/tjalHQIz7cQTmeE5qJh8qKEe8wALMut1,p=AtNtxGzsMA8evcWBM0MXFjxN8OcG1KRkLkFyoHlupOU=")
+```

scram.nimble

@@ -1,6 +1,6 @@
-version       = "0.1.0"
+version       = "0.1.1"
 author        = "Huy Doan"
 description   = "Salted Challenge Response Authentication Mechanism (SCRAM) "
 license       = "MIT"
 
-requires "nim >= 0.17.0", "hmac >= 0.1.2"
+requires "nim >= 0.17.0", "hmac >= 0.1.3"

scram/client.nim

@@ -1,26 +1,14 @@
-import base64, pegs, random, strutils, hmac, nimSHA2, private/utils
+import base64, pegs, random, strutils, hmac, nimSHA2, securehash, md5, private/[utils,types]
 
-type
-  ScramError* = object of SystemError
-
-  ScramState = enum
-    INITIAL
-    FIRST_PREPARED
-    FINAL_PREPARED
-    ENDED
+export MD5Digest, Sha256Digest, Sha512Digest
 
-  DigestType* = enum
-    SHA1
-    SHA256
-    SHA512
-
-  ScramClient = ref object of RootObj
+type
+  ScramClient[T] = ref object of RootObj
     clientNonce: string
     clientFirstBareMessage: string
-    digestType: DigestType
     state: ScramState
     isSuccessful: bool
-    serverSignature: string
+    serverSignature: T
 
 const
   GS2_HEADER = "n,,"
@@ -32,28 +20,46 @@ let
   SERVER_FIRST_MESSAGE = peg"'r='{[^,]*}',s='{[^,]*}',i='{\d+}$"
   SERVER_FINAL_MESSAGE = peg"'v='{[^,]*}$"
 
-proc hi(s: ScramClient, password, salt: string, iterations: int): string =
-  var previous: string
-  result = $hmac_sha256(password, salt & INT_1)
+
+proc HMAC[T](password, salt: string): T =
+  when T is MD5Digest:
+    result = hmac_md5(password, salt)
+  elif T is Sha1Digest:
+    result = Sha1Digest(hmac_sha1(password, salt))
+  elif T is Sha256Digest:
+    result = hmac_sha256(password, salt)
+  elif T is Sha512Digest:
+    result = hmac_sha512(password, salt)
+
+proc HASH[T](s: string): T =
+  when T is MD5Digest:
+    result = hash_md5(s)
+  elif T is Sha1Digest:
+    result = Sha1Digest(hash_sha1(s))
+  elif T is Sha256Digest:
+    result = hash_sha256(s)
+  elif T is Sha512Digest:
+    result = hash_sha512(s)
+
+
+proc hi[T](s: ScramClient[T], password, salt: string, iterations: int): T =
+  var previous: T
+  result = HMAC[T](password, salt & INT_1)
   previous = result
   for _ in 1..<iterations:
-    previous = $hmac_sha256(password, previous)
+    previous = HMAC[T](password, $previous)
     result ^= previous
 
-proc newScramClient*(digestType: DigestType): ScramClient =
-  result = new(ScramClient)
+proc newScramClient*[T](): ScramClient[T] =
+  result = new(ScramClient[T])
   result.state = INITIAL
-  result.digestType = digestType
   result.clientNonce = makeNonce()
   result.isSuccessful = false
 
 proc prepareFirstMessage*(s: ScramClient, username: string): string {.raises: [ScramError]} =
   if username.isNilOrEmpty:
     raise newException(ScramError, "username cannot be nil or empty")
-
   var username = username.replace("=", "=3D").replace(",", "=2C")
-
-
   s.clientFirstBareMessage = "n="
   s.clientFirstBareMessage.add(username)
   s.clientFirstBareMessage.add(",r=")
@@ -62,15 +68,17 @@ proc prepareFirstMessage*(s: ScramClient, username: string): string {.raises: [S
   result = GS2_HEADER & s.clientFirstBareMessage
   s.state = FIRST_PREPARED
 
-proc prepareFinalMessage*(s: ScramClient, password, serverFirstMessage: string): string {.raises: [ScramError, OverflowError, ValueError].} =
+proc prepareFinalMessage*[T](s: ScramClient[T], password, serverFirstMessage: string): string {.raises: [ScramError, OverflowError, ValueError].} =
+  if s.state != FIRST_PREPARED:
+    raise newException(ScramError, "First message have not been prepared, call prepareFirstMessage() first")
+
   var
     nonce, salt: string
     iterations: int
 
-  if s.state != FIRST_PREPARED:
-    raise newException(ScramError, "First message have not been prepared, call prepareFirstMessage() first")
-
-  if serverFirstMessage =~ SERVER_FIRST_MESSAGE:
+  var matches: array[3, string]
+  if match(serverFirstMessage, SERVER_FIRST_MESSAGE, matches):
+#  if serverFirstMessage =~ SERVER_FIRST_MESSAGE:
     nonce = matches[0]
     salt = decode(matches[1])
     iterations = parseInt(matches[2])
@@ -84,14 +92,14 @@ proc prepareFinalMessage*(s: ScramClient, password, serverFirstMessage: string):
 
   let
     saltedPassword = s.hi(password, salt, iterations)
-    clientKey = $hmac_sha256(saltedPassword, CLIENT_KEY)
-    storedKey = $computeSHA256(clientKey)
-    serverKey = $hmac_sha256(saltedPassword, SERVER_KEY)
+    clientKey = HMAC[T]($saltedPassword, CLIENT_KEY)
+    storedKey = HASH[T]($clientKey)
+    serverKey = HMAC[T]($saltedPassword, SERVER_KEY)
     clientFinalMessageWithoutProof = "c=" & encode(GS2_HEADER) & ",r=" & nonce
     authMessage = s.clientFirstBareMessage & "," & serverFirstMessage & "," & clientFinalMessageWithoutProof
-    clientSignature = $hmac_sha256(storedKey, authMessage)
+    clientSignature = HMAC[T]($storedKey, authMessage)
 
-  s.serverSignature = $hmac_sha256(serverKey, authMessage)
+  s.serverSignature = HMAC[T]($serverKey, authMessage)
 
   var clientProof = clientKey
   clientProof ^= clientSignature
@@ -102,10 +110,10 @@ proc verifyServerFinalMessage*(s: ScramClient, serverFinalMessage: string): bool
   if s.state != FINAL_PREPARED:
     raise newException(ScramError, "You can call this method only once after calling prepareFinalMessage()")
   s.state = ENDED
-  if serverFinalMessage =~ SERVER_FINAL_MESSAGE:
+  var matches: array[1, string]
+  if match(serverFinalMessage, SERVER_FINAL_MESSAGE, matches):
     let proposedServerSignature = decode(matches[0])
     s.isSuccessful = proposedServerSignature == s.serverSignature
-
   result = s.isSuccessful
 
 proc isSuccessful*(s: ScramClient): bool =
@@ -120,7 +128,7 @@ proc getState*(s: ScramClient): ScramState =
   result = s.state
 
 when isMainModule:
-  var s = newScramClient(SHA256)
+  var s = newScramClient[Sha256Digest]()
   s.clientNonce = "VeAOLsQ22fn/tjalHQIz7cQT"
 
   echo s.prepareFirstMessage("bob")

scram/private/types.nim

@@ -0,0 +1,16 @@
+type
+  ScramError* = object of SystemError
+
+  Sha1Digest* = array[20, uint8]
+  
+  DigestType* = enum
+    MD5
+    SHA1
+    SHA256
+    SHA512
+
+  ScramState* = enum
+    INITIAL
+    FIRST_PREPARED
+    FINAL_PREPARED
+    ENDED

scram/private/utils.nim

@@ -1,8 +1,16 @@
-import random, base64
+import random, base64, strutils, types
 randomize()
 
+proc `$`*(sha: Sha1Digest): string =
+  result = ""
+  for v in sha:
+    result.add(toHex(int(v), 2))
+
 proc makeNonce*(): string {.inline.} = result = encode($random(1.0))[0..^3]
 
 template `^=`*[T](a, b: T) =
-  for x in 0..<a.len:
-    a[x] = (a[x].int32 xor b[x].int32).char
+  for x in 0..<sizeof(a):
+    when T is Sha1Digest:
+      a[x] = (a[x].int32 xor b[x].int32).uint8
+    else:
+      a[x] = (a[x].int32 xor b[x].int32).char