Digest computation matches

Author: ashton314

lib/zkp/srp_chor.ex

@@ -47,7 +47,7 @@ defmodule Zkp.SrpChor do
 
                     with SrpServer.(secret) <-
                            SrpServer.compute_secret(n, big_a, big_b, b_secret, tok) do
-                      if SrpServer.valid_m1?(big_a, big_b, k, m1) do
+                      if SrpServer.valid_m1?(big_a, big_b, secret, m1) do
                         SrpServer[L] ~> SrpClient
                         SrpServer.compute_m2(big_a, m1, secret) ~> SrpClient.(m2)
 
@@ -82,7 +82,7 @@ defmodule Zkp.SrpChor do
 
   def hash_things([a]), do: String.length("(#{a})") |> IO.inspect(label: "hash(#{a})")
   def hash_things([a, b]), do: String.length("(#{a} #{b})") |> IO.inspect(label: "hash(#{a}, #{b})")
-  def hash_things([a, b, c]), do: String.length("(#{a} #{b} #{c})")
+  def hash_things([a, b, c]), do: String.length("(#{a} #{b} #{c})") |> IO.inspect(label: "hash(#{a}, #{b}, #{c})")
 
   def hash_things(args) do
     args

lib/zkp/srp_client_impl.ex

@@ -8,34 +8,25 @@ defmodule Zkp.SrpClientImpl do
 	IO.gets("[Login] username: ") |> String.trim()
   end
 
-  def hash_passwd(id, salt, passwd) do
-    hash_things([id, salt, passwd])
-  end
-
   @impl true
   def compute_secret(g, n, s, big_b, k, id) do
     passwd = IO.gets("[Login] password: ") |> String.trim()
 
     # a = Enum.random(2..n)
     a = 7
-    big_a = :crypto.mod_pow(g, a, n) |> as_int()
+    big_a = :crypto.mod_pow(g, a, n)
+    big_a = as_int(big_a)
     big_b = as_int(big_b)
-    x = hash_passwd(id, s, passwd)
-    # IO.inspect(as_int(x), label: "[client] x")
-    mpow(g, x, n) |> as_int() |> IO.inspect(label: "[client] should match verif code")
+    x = hash_things([id, s, passwd])
 
-    u = as_int(hash_things([big_a, big_b]))
-    # u's match; x looks good
+    u = hash_things([big_a, big_b])
 
     k = as_int(k)
-    big_b = as_int(big_b)
-    # IO.inspect({as_int(big_b), k, g, as_int(x), a, u, n}, label: "[client] {big_b, k, g, x, a, u, n}")
-    secret_k = mpow(as_int(big_b) - (k * as_int(mpow(g, x, n))), (a + u * as_int(x)), n) |> as_int()
-    # IO.inspect(as_int(secret_k), label: "[client] secret_k")
+    secret_k = mpow(as_int(big_b) - (k * as_int(mpow(g, x, n))), (a + u * as_int(x)), n)
 
-    IO.puts("[client] a: #{a}, A: #{big_a}, x: #{x}, u: #{u}, k: #{k}, B: #{big_b}, secret: #{secret_k}")
+    IO.puts("[client] a: #{a}, A: #{big_a}, x: #{x}, u: #{u}, k: #{k}, B: #{big_b}, secret: #{as_int(secret_k)}")
 
-    m1 = hash_things([big_a, big_b, secret_k])
+    m1 = hash_things([big_a, big_b, as_int(secret_k)]) |> IO.inspect(label: "[client] m1")
     {big_a, m1, secret_k}
   end
 

lib/zkp/srp_server_impl.ex

@@ -41,24 +41,19 @@ defmodule Zkp.SrpServerImpl do
     big_a = as_int(big_a)
     big_b = as_int(big_b)
     u = hash_things([big_a, big_b])
-    # IO.inspect(as_int(u), label: "[server] u")
 
-    # IO.inspect({as_int(big_a), as_int(v), as_int(u), b, n}, label: "[server] {big_a, v, u, b n}")
+    secret_k = mpow((big_a * as_int(mpow(v, u, n))), b, n)
 
-    secret_k = mpow((as_int(big_a) * as_int(mpow(v, u, n))), b, n) |> as_int()
+    IO.puts("[server] A: #{big_a}, b: #{b}, B: #{big_b}, u: #{as_int(u)}, v: #{as_int(v)}, secret: #{as_int(secret_k)}")
 
-    # IO.inspect(as_int(secret_k), label: "[server] secret_k")
-    big_a = as_int(big_a)
-    big_b = as_int(big_b)
-    u = as_int(u)
-    v = as_int(v)
-
-    IO.puts("[server] A: #{big_a}, b: #{b}, B: #{big_b}, u: #{u}, v: #{v}, secret: #{secret_k}")
     secret_k
   end
 
   @impl true
   def valid_m1?(a, b, k, m1) do
+    b = as_int(b)
+    k = as_int(k)
+    IO.inspect({a, b, k, m1, hash_things([a, b, k])}, label: "[server] a b k m1 m1_verif")
 	hash_things([a, b, k]) == m1
   end