adding group type for proposition deserialization

Author: Janis Erdmanis

Project.toml

@@ -1,7 +1,7 @@
 name = "SigmaProofs"
 uuid = "f8559b4c-f045-44a2-8db2-503e40bb7416"
 authors = ["Janis Erdmanis <[email protected]>"]
-version = "0.1.1"
+version = "0.1.2"
 
 [deps]
 CryptoGroups = "bc997328-bedd-407e-bcd3-5758e064a52d"

src/DecryptionProofs.jl

@@ -1,7 +1,7 @@
 module DecryptionProofs
 
 using ..Serializer: Serializer, Path, load
-using ..SigmaProofs.Parser: Parser, Tree
+using ..SigmaProofs.Parser: Parser, Tree, width_elgamal_vec
 using ..SigmaProofs: Proposition, Verifier, Simulator
 using ..ElGamal: ElGamalRow
 using ..LogProofs: ChaumPedersenProof, LogEquality
@@ -162,27 +162,37 @@ end
 
 Serializer.save(proof::ChaumPedersenProof, ::Type{<:Decryption}, path::Path) = Serializer.save(proof, path; prefix="Decryption")
 
-function Serializer.load(::Type{Decryption}, basedir::Path)
+function Serializer.load(::Type{T}, basedir::Path) where T <: Decryption
+
+    _extract_group(::Type{Decryption{G}}) where G <: Group = G
+    _extract_group(::Type{Decryption}) = nothing
+
+    G = _extract_group(T)
 
     publickey_tree = Parser.decode(read(joinpath(basedir, "publicKey.bt")))
     pk, g = Parser.unmarshal_publickey(publickey_tree; relative=true)
 
-    G = typeof(g)
+    if isnothing(G)
+        G = typeof(g)
+    else
+        pk = convert(G, pk)
+        g = convert(G, g)
+    end
 
     ciphertexts_tree = Parser.decode(read(joinpath(basedir, "Ciphertexts.bt")))
     plaintexts_tree = Parser.decode(read(joinpath(basedir, "Decryption.bt")))
-
-    N = 1 # ToDo: extract that from the tree
+    
+    N = width_elgamal_vec(G, ciphertexts_tree)
 
     ciphertexts = convert(Vector{ElGamalRow{G, N}}, ciphertexts_tree)
     plaintexts = convert(Vector{NTuple{N, G}}, plaintexts_tree)
 
     return Decryption(g, pk, ciphertexts, plaintexts)
 end
 
-Serializer.load(::Type{P}, ::Type{Decryption}, path::Path) where P <: ChaumPedersenProof = Serializer.load(P, path; prefix="Decryption")
+Serializer.load(::Type{Decryption{G}}, basedir::Path) where G <: Group = load(Decryption, basedir; G)
 
-# ToDO
+Serializer.load(::Type{P}, ::Type{Decryption}, path::Path) where P <: ChaumPedersenProof = Serializer.load(P, path; prefix="Decryption")
 
 function Serializer.save(proposition::DecryptionInv, dir::Path) 
 
@@ -199,17 +209,28 @@ end
 
 Serializer.save(proof::ChaumPedersenProof, ::Type{<:DecryptionInv}, path::Path) = Serializer.save(proof, path; prefix="DecryptionInv")
 
-function Serializer.load(::Type{DecryptionInv}, basedir::Path)
-    
+
+function Serializer.load(::Type{T}, basedir::Path) where T <: DecryptionInv
+
+    _extract_group(::Type{DecryptionInv{G}}) where G <: Group = G
+    _extract_group(::Type{DecryptionInv}) = nothing
+
+    G = _extract_group(T)
+
     publickey_tree = Parser.decode(read(joinpath(basedir, "publicKey.bt")))
     pk, g = Parser.unmarshal_publickey(publickey_tree; relative=true)
 
-    G = typeof(g)
+    if isnothing(G)
+        G = typeof(g)
+    else
+        pk = convert(G, pk)
+        g = convert(G, g)
+    end
 
     ciphertexts_tree = Parser.decode(read(joinpath(basedir, "Ciphertexts.bt")))
     plaintexts_tree = Parser.decode(read(joinpath(basedir, "DecryptionInv.bt")))
 
-    N = 1 # ToDo: extract that from the tree
+    N = width_elgamal_vec(G, ciphertexts_tree)
 
     ciphertexts = convert(Vector{ElGamalRow{G, N}}, ciphertexts_tree)
     plaintexts = convert(Vector{NTuple{N, G}}, plaintexts_tree)

src/Parser.jl

@@ -272,10 +272,29 @@ function marshal(x::PGroup)
     return tree
 end
 
+# A bit verbose; I could instead read all curve specifications and retrieve the NIST name
+function normalize_ecgroup_name(x::String)
+    name = replace(x, "_"=>"-")
+
+    lcase = lowercase(name)
+
+    if lcase == "prime192v1"
+        return "P-192"
+    elseif lcase == "secp224r1"
+        return "P-224"
+    elseif lcase == "prime256v1"
+        return "P-256"
+    elseif lcase == "secp384r1"
+        return "P-384"
+    elseif lcase == "secp521r1"
+        return "P-521"
+    else
+        return name
+    end
 
-normalize_ecgroup_name(x::String) = replace(x, "_"=>"-")
-normalize_ecgroup_name(x::Symbol) = normalize_ecgroup_name(String(x))
+end
 
+normalize_ecgroup_name(x::Symbol) = normalize_ecgroup_name(String(x))
 
 function marshal(g::ECGroup)
 
@@ -293,7 +312,6 @@ function marshal(g::ECGroup)
     return tree
 end
 
-
 function unmarshal(tree::Tree)
 
     group_type = convert(String, tree.x[1])
@@ -307,7 +325,6 @@ function unmarshal(tree::Tree)
     end
 end
 
-
 function _unmarshal_pgroup(x::Node) 
 
     (p, q, g, e) = convert(Tuple{BigInt, BigInt, BigInt, UInt32}, x)
@@ -486,6 +503,22 @@ function unmarshal_privatekey(tree::Tree)
     return (s, g) ### The group can often be omited when not needed.
 end
 
+# Returns the depth of the tree
+function depth(tree::Tree)
+
+    if tree isa Leaf
+        return 0
+    else
+        return 1 + depth(tree[1])
+    end
+
+end
+
+width_elgamal_row(::Type{<:PGroup}, tree::Tree) = depth(tree) == 1 ? 1 : length(tree[1])
+width_elgamal_row(::Type{<:ECGroup}, tree::Tree) = depth(tree) == 2 ? 1 : length(tree[1])
+
+width_elgamal_vec(::Type{<:PGroup}, tree::Tree) = depth(tree) == 2 ? 1 : length(tree[1])
+width_elgamal_vec(::Type{<:ECGroup}, tree::Tree) = depth(tree) == 3 ? 1 : length(tree[1])
 
 Tree(x::Vector{BigInt}; L = bitlength(maximum(x))) = Node([Leaf(i, L) for i in x])
 

src/SigmaProofs.jl

@@ -23,8 +23,6 @@ struct Simulator{T<:Proposition}
         # Alternative is to do conversion here if necessary
         @assert isvalid(typeof(proof), proposition) "Inconsistent simulator"
 
-        #@assert typeof(proof) <: proof_type(proposition) 
-
         return new{typeof(proposition)}(proposition, proof, verifier)
     end
 end

src/Verificatum/GeneratorBasis.jl

@@ -6,8 +6,6 @@ using CryptoGroups.Specs: MODP, ECP
 using CryptoPRG.Verificatum: PRG, RO
 using CryptoUtils: is_quadratic_residue, sqrt_mod_prime
 
-# import ...SigmaProofs: generator_basis
-
 function modp_generator_basis(prg::PRG, p::Integer, q::Integer, N::Integer; nr::Integer = 0)
 
     np = bitlength(p)

src/Verificatum/Verificatum.jl

@@ -250,8 +250,14 @@ function Serializer.save(spec::ProtocolSpec, path::Path; name="undefined")
 end
 
 
-function Serializer.load(::Type{ProtocolSpec}, path::Path; auxsid = "default")
 
+function Serializer.load(::Type{T}, path::Path; auxsid = "default") where T <: ProtocolSpec
+
+    _extract_group(::Type{ProtocolSpec{G}}) where G <: Group = G
+    _extract_group(::Type{ProtocolSpec}) = nothing
+
+    G = _extract_group(T)
+    
     xml = read(path) |> String
 
     rohash = HashSpec(match(r"<rohash>(.*?)</rohash>", xml)[1] |> map_hash_name)
@@ -263,11 +269,14 @@ function Serializer.load(::Type{ProtocolSpec}, path::Path; auxsid = "default")
     ne = parse(Int32, match(r"<ebitlenro>(.*?)</ebitlenro>", xml)[1])
 
     g = unmarshal(decode(split(s_Gq, "::")[2]))
+    
+    if !isnothing(G)
+        g = convert(G, g)
+    end
 
     version = match(r"<version>(.*?)</version>", xml)[1] |> String
     sid = match(r"<sid>(.*?)</sid>", xml)[1] |> String
 
-
     return ProtocolSpec(; g, nr, nv, ne, prghash, rohash, version, sid, auxsid)
 end