untested: rsa pub binary format

src/types.ml

@@ -30,97 +30,16 @@ module RelativeTime = struct
     | Forever
 end
 
-module Amount = struct
-  (* TODO
-     have safe amount arithmetic
-     make type private *)
-  (* Amounts of currency, serialized as `<Currency>:<IntegerPart>.<FractionalPart>`
-     Fixed-precision numbers with 8 decimal places.
-     - <Currency> must be at most 11 characters long
-       only consist of ASCII letters (a-zA-Z).
-     - integer part of <DecimalAmount> may be at most 2^52.
-     - fractional part of <DecimalAmount> may contain at most 8 decimal digits.
+module Amount = Amount
 
-     Prefixed with '+' or '-' in certain contexts.
-     When no sign is present, the amount is assumed to be positive. *)
-  type t = {
-    sign: [ `Plus | `Minus ] option;
-    currency: [ `Eur ];
-    value: Int64.t;
-    fraction: Int64.t;
-  }
-
-  let make ~sign ~currency ~value ~fraction =
-    let open Syntax in
-    let value_upper_bound = Z.(pow (of_int 2) 52) |> Z.to_int64 in
-    let fraction_upper_bound = Int64.of_int 99_999_999 in
-    let* () = if value < Int64.zero then Error "value is negative" else Ok () in
-    let* () =
-      if fraction < Int64.zero then Error "fraction is negative" else Ok ()
-    in
-    let* () =
-      if value > value_upper_bound then Error "value is greater than 2^52"
-      else Ok ()
-    in
-    let* () =
-      if fraction > fraction_upper_bound then
-        Error "fraction have more than 8 decimal digits"
-      else Ok ()
-    in
-    Ok { sign; currency; value; fraction }
-
-  let to_string =
-    let pp =
-      let open Fmt in
-      let pp_sign ppf = function
-        | `Plus -> char ppf '+'
-        | `Minus -> char ppf '-'
-      in
-      let pp_currency ppf = function `Eur -> string ppf "EUR" in
-      fun ppf { sign; currency; value; fraction } ->
-        pf ppf "%a%a:%Ld.%Ld" (Fmt.option pp_sign) sign pp_currency currency
-          value fraction
-    in
-    Fmt.str "%a" pp
-
-  let of_string =
-    let open Angstrom in
-    let parse_sign =
-      choice
-        [
-          char '+' *> return (Some `Plus); char '-' *> return (Some `Minus);
-          return None;
-        ]
-    in
-    let parse_currency = string "EUR" *> return `Eur in
-    let parse_int =
-      take_while1 (function '0' .. '9' -> true | _ -> false)
-      >>| Int64.of_string_opt
-      >>= function
-      | None -> fail "invalid integer"
-      | Some n -> return n
-    in
-    let parse_t =
-      lift4
-        (fun sign currency value fraction ->
-          make ~sign ~currency ~value ~fraction)
-        parse_sign parse_currency
-        (char ':' *> parse_int)
-        (char '.' *> parse_int)
-    in
-    fun s -> parse_string ~consume:Consume.All parse_t s |> Result.join
-end
-
-module Eddsa = struct
-  (* TODO test *)
+(* TODO key format *)
+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. *)
-  (* EdDSA signatures are transmitted as 64-bytes `base32`
-     binary-encoded objects with just the R and S values (base32_ binary-only). *)
-  type pub = Mirage_crypto_ec.Ed25519.pub
+  type t = Mirage_crypto_ec.Ed25519.pub
 
-  let pub_of_string s =
+  let of_string s =
     let open Mirage_crypto_ec in
     match Base_32.decode s with
     | Error _ as err -> err
@@ -129,24 +48,44 @@ module Eddsa = struct
         | Error e -> Fmt.error "%a" pp_error e
         | Ok pub -> Ok pub)
 
-  let pub_to_string pub =
+  let to_string pub =
     pub |> Mirage_crypto_ec.Ed25519.pub_to_octets |> Base_32.encode
+end
 
+module EddsaSignature = struct
   (* EdDSA signatures are transmitted as 64-bytes base32
      binary-encoded objects with just the R and S values (base32_ binary-only).
 
      They are signature over a c-struct like `TALER_xxxPS` + with a purpose *)
-  type signature = string
+  type t = string
+
+  (* TODO key format
+     is it exactly like in GNU_CRYPTO?
+     endianess issue? *)
+  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
 end
 
-module Rsa = struct
-  (* TODO
-     GNUNET_CRYPTO custom encode/decode *)
+module RsaPublicKey = struct
   (* RSA public key converted to Crockford Base32. *)
   type pub = Mirage_crypto_pk.Rsa.pub
 
-  let pub_of_string _s = assert false
-  let pub_to_string _pub = assert false
+  let pub_of_string s =
+    (* TODO bin
+       - no [Bin.of_string] ?
+       - what to do with the int ref? *)
+    let off = ref 0 in
+    let v = Bin.decode Binary_formats.RsaPublicKey.bin s off in
+    let res = Mirage_crypto_pk.Rsa.pub ~n:v.n ~e:v.e in
+    match res with Error (`Msg e) -> Error e | Ok pub -> Ok pub
+
+  let pub_to_string ({ 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
+    let s = Bin.to_string bin v in
+    s
 end
 
 module HashCode = struct
@@ -178,7 +117,7 @@ end
 module FutureSignKey = struct
   type t = {
     (* The actual exchange's EdDSA signing public key *)
-    key: Eddsa.pub;
+    key: EddsaPublicKey.t;
     (* Initial validity date for the signing key. *)
     stamp_start: Timestamp.t;
     (* Date when the exchange will stop using the signing key, allowed to overlap
@@ -190,6 +129,6 @@ module FutureSignKey = struct
     (* Signature over TALER_SigningKeyAnnouncementPS
        for this signing key by the signkey security
        module using purpose TALER_SIGNATURE_SM_SIGNING_KEY. *)
-    signkey_secmod_sig: Eddsa.signature;
+    signkey_secmod_sig: EddsaSignature.t;
   }
 end