mte/src/eddsa.ml

open Syntax
module Mirage_eddsa = Mirage_crypto_ec.Ed25519

let pp_mirage_error = Mirage_crypto_ec.pp_error

type priv = Mirage_eddsa.priv
type pub = Mirage_eddsa.pub
type sig_ = S of string [@@unboxed]

let generate = Mirage_eddsa.generate
let pub_of_priv = Mirage_eddsa.pub_of_priv

let sign ~key s =
  let sig_ = Mirage_eddsa.sign ~key s in
  S sig_

let verify ~key (S s) ~msg =
  let b = Mirage_eddsa.verify ~key s ~msg in
  if b then Ok () else Error `Invalid_signature_eddsa

module Priv = struct
  let priv_to_octets t = Mirage_eddsa.priv_to_octets t

  let priv_of_octets o =
    Mirage_eddsa.priv_of_octets o
    |> Result.map_error (Fmt.str "%a" pp_mirage_error)

  let priv_to_b32 t = priv_to_octets t |> B32.encode

  let priv_of_b32 s =
    let* octets = B32.decode s in
    priv_of_octets octets

  let priv_jsont =
    Jsont.of_of_string ~kind:"EddsaPrivateKey" priv_of_b32 ~enc:priv_to_b32

  let priv_bin =
    let priv_of_octets_exn t =
      match priv_of_octets t with Error e -> invalid_arg e | Ok v -> v
    in
    Bin.map (Bin.bytes 32) priv_of_octets_exn priv_to_octets
end

module Pub = struct
  let pub_to_octets t = Mirage_eddsa.pub_to_octets t

  let pub_of_octets t =
    Mirage_eddsa.pub_of_octets t
    |> Result.map_error (Fmt.str "%a" pp_mirage_error)

  let pub_to_b32 t = pub_to_octets t |> B32.encode

  let pub_of_b32 s =
    let* octets = B32.decode s in
    pub_of_octets octets

  let pub_jsont =
    Jsont.of_of_string ~kind:"EddsaPublicKey" pub_of_b32 ~enc:pub_to_b32

  let pub_bin =
    let pub_of_octets_exn t =
      match pub_of_octets t with Error e -> invalid_arg e | Ok v -> v
    in
    Bin.map (Bin.bytes 32) pub_of_octets_exn pub_to_octets

  let pub_caqti =
    Caqti_type.custom
      ~encode:(fun v -> Ok (pub_to_octets v))
      ~decode:pub_of_octets Caqti_type.octets
end

module Sig_ = struct
  let sig_to_octets (S s) = s

  let sig_of_octets s =
    match String.length s = 64 with
    | false -> Error "invalid eddsa signature length"
    | true -> Ok (S s)

  let sig_of_b32 s =
    let* s = B32.decode s in
    sig_of_octets s

  let sig_to_b32 (S s) = B32.encode s

  let sig_jsont =
    Jsont.of_of_string ~kind:"EddsaSignature" sig_of_b32 ~enc:sig_to_b32

  let sig_bin =
    let sig_of_octets_exn t =
      match sig_of_octets t with Error e -> invalid_arg e | Ok v -> v
    in
    Bin.map (Bin.bytes 64) sig_of_octets_exn sig_to_octets

  let sig_caqti =
    Caqti_type.custom
      ~encode:(fun v -> Ok (sig_to_octets v))
      ~decode:sig_of_octets Caqti_type.octets
end

include Priv
include Pub
include Sig_

let pp_pub ppf pub = Fmt.pf ppf "%s" (pub_to_b32 pub)