abstr type for signature

src/types.ml

@@ -65,30 +65,33 @@ end
 
 module Amount = Amount
 
-(* TODO key format *)
+(* TODO key format
+   - check what is the exact format in GNUNET
+   - endianess issue? *)
 module EddsaPublicKey = struct
   (* EdDSA and ECDHE public keys always point on Curve25519
      and represented  using the standard 256 bits Ed25519 compact format,
      converted to Crockford Base32. *)
   type t = Mirage_crypto_ec.Ed25519.pub
 
-  let of_string s =
+  let of_b32 s =
+    let open Syntax in
     let open Mirage_crypto_ec in
-    match B32.decode s with
-    | Error _ as err -> err
-    | Ok octets -> (
-        match Ed25519.pub_of_octets octets with
-        | Error e -> Fmt.error "%a" pp_error e
-        | Ok pub -> Ok pub)
+    let* octets = B32.decode s in
+    match Ed25519.pub_of_octets octets with
+    | Error e -> Fmt.error "%a" pp_error e
+    | Ok pub -> Ok pub
 
-  let to_string pub =
-    pub |> Mirage_crypto_ec.Ed25519.pub_to_octets |> B32.encode
+  let to_b32 pub = pub |> Mirage_crypto_ec.Ed25519.pub_to_octets |> B32.encode
 end
 
-(* TODO sig type
-   abstract type
-   same for RsaSignature *)
-module EddsaSignature = struct
+module EddsaSignature : sig
+  type t
+
+  val sign : key:Mirage_crypto_ec.Ed25519.priv -> string -> t
+  val of_b32 : string -> (t, string) result
+  val to_b32 : t -> string
+end = struct
   (* EdDSA signatures are transmitted as 64-bytes base32
      binary-encoded objects with just the R and S values (base32_ binary-only).
 
@@ -101,20 +104,26 @@ module EddsaSignature = struct
   let sign ~key s =
     (* mirage_crypto: "The result is the concatenation of r and s, as specified in RFC 8032." *)
     Mirage_crypto_ec.Ed25519.sign ~key s
+
+  let of_b32 s = B32.decode s
+
+  let to_b32 t =
+    let s = B32.encode t in
+    assert (String.length s = 64);
+    s
 end
 
 module RsaPublicKey = struct
-  (* RSA public key converted to Crockford Base32. *)
   type t = Mirage_crypto_pk.Rsa.pub
 
-  let of_string s =
+  let of_b32 s =
     let open Syntax in
     let* s = B32.decode s in
     let* v = Util.bin_of_string Binary_formats.RsaPublicKey.bin s in
     let+ v = Mirage_crypto_pk.Rsa.pub ~n:v.n ~e:v.e |> unwrap_err_msg in
     v
 
-  let to_string ({ n; e } : Mirage_crypto_pk.Rsa.pub) =
+  let to_b32 ({ n; e } : Mirage_crypto_pk.Rsa.pub) =
     let open Binary_formats.RsaPublicKey in
     let header = { n_len= Z.size n; e_len= Z.size e } in
     let v = { header; n; e } in
@@ -123,6 +132,24 @@ module RsaPublicKey = struct
     s
 end
 
+module RsaSignature : sig
+  type t
+
+  val sign : key:Mirage_crypto_pk.Rsa.priv -> string -> t
+  val of_b32 : string -> (t, string) result
+  val to_b32 : t -> string
+end = struct
+  type t = string
+
+  (* no Rsa.sign(?):
+     decrypt is equivalent to sign *)
+  let sign ~key s =
+    Mirage_crypto_pk.Rsa.decrypt ~crt_hardening:true ~mask:`Yes ~key s
+
+  let of_b32 s = B32.decode s
+  let to_b32 t = B32.encode t
+end
+
 module HashCode = struct
   (* 32-byte value representing a point on Curve25519. *)
   type cs25519Point = string