swrup/mte
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[@@unboxed] type sig_

Browse source
This commit is contained in:
swrup 2026-03-21 09:50:04 +01:00 • committed by Swrup
parent ec4e166173
commit 6d73af2169
3 changed files with 61 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/config.ml
View file

@ -190,6 +190,14 @@ module Coin = struct
let section_name =
String.sub section.header 5 (String.length section.header - 5)
in
let rsa_keysize s =
let nbits = int s in
let len = ((nbits - 1) / 8) + 1 in
if 8 * len <> nbits then
(* because of [kdf_mod_n] *)
invalid_arg "RSA keysize must be multiple of 8"
else nbits
in
{
section_name;
value= get "value" |> amount;
@ -201,7 +209,7 @@ module Coin = struct
fee_refresh= get "fee_refresh" |> amount;
fee_refund= get "fee_refund" |> amount;
cipher= (get "cipher" |> const_value "RSA" |> fun _s -> `RSA);
rsa_keysize= get "rsa_keysize" |> int;
rsa_keysize= get "rsa_keysize" |> rsa_keysize;
age_restricted=
( get "age_restricted" |> yes_no |> function
| `NO -> `NO

54
src/eddsa.ml
View file

@ -1,21 +1,19 @@
open Syntax
module Mirage_eddsa = Mirage_crypto_ec.Ed25519
type priv = Mirage_crypto_ec.Ed25519.priv
type pub = Mirage_crypto_ec.Ed25519.pub
let pp_error = Mirage_crypto_ec.pp_error
(* transmitted as 64-bytes base32
binary-encoded objects with just the R and S values *)
type sig_ = Sig of string
type priv = Mirage_eddsa.priv
type pub = Mirage_eddsa.pub
type sig_ = S of string [@@unboxed]
let generate = Mirage_crypto_ec.Ed25519.generate
let pub_of_priv = Mirage_crypto_ec.Ed25519.pub_of_priv
let priv_to_octets t = Mirage_crypto_ec.Ed25519.priv_to_octets t
let generate = Mirage_eddsa.generate
let pub_of_priv = Mirage_eddsa.pub_of_priv
let priv_to_octets t = Mirage_eddsa.priv_to_octets t
let priv_of_octets t =
Mirage_crypto_ec.Ed25519.priv_of_octets t |> function
| Error err ->
let err = Fmt.str "%a" Mirage_crypto_ec.pp_error err in
Error err
Mirage_eddsa.priv_of_octets t |> function
| Error err -> Fmt.error "%a" pp_error err
| Ok v -> Ok v
let priv_bin =
@ -30,11 +28,11 @@ let priv_jsont =
let to_b32 t = B32.encode (priv_to_octets t) in
Jsont.of_of_string ~kind:"EddsaPrivateKey" of_b32 ~enc:to_b32
let pub_to_octets t = Mirage_crypto_ec.Ed25519.pub_to_octets t
let pub_to_octets t = Mirage_eddsa.pub_to_octets t
let pub_of_octets t =
Mirage_crypto_ec.Ed25519.pub_of_octets t |> function
| Error e -> Fmt.error "%a" Mirage_crypto_ec.pp_error e
Mirage_eddsa.pub_of_octets t |> function
| Error e -> Fmt.error "%a" pp_error e
| Ok v -> Ok v
let pub_bin =
@ -57,25 +55,19 @@ let pub_caqti =
Caqti_type.octets
let sign ~key s =
let sig_ = Mirage_crypto_ec.Ed25519.sign ~key s in
Sig sig_
let sig_ = Mirage_eddsa.sign ~key s in
S sig_
let verify ~key (Sig s) ~msg =
let b = Mirage_crypto_ec.Ed25519.verify ~key s ~msg in
match b with
| false -> Error "EddsaSignature verification: invalid signature"
| true -> Ok ()
let verify ~key (S s) ~msg =
let b = Mirage_eddsa.verify ~key s ~msg in
match b with false -> Error "Eddsa verify: not valid" | true -> Ok ()
let sig_to_octets (Sig s) = s
let check_size s =
match String.length s = 64 with
| false -> Error "EddsaSignature of_octets: data is not 64 bytes."
| true -> Ok ()
let sig_to_octets (S s) = s
let sig_of_octets s =
let+ () = check_size s in
Sig s
match String.length s = 64 with
| false -> Error "Eddsa decode signature (binary): invalid data"
| true -> Ok (S s)
let sig_bin =
let sig_of_octets_exn t = sig_of_octets t |> Result.get_ok in
@ -86,7 +78,7 @@ let sig_jsont =
let* s = B32.decode s in
sig_of_octets s
in
let sig_to_b32 (Sig s) = B32.encode s in
let sig_to_b32 (S s) = B32.encode s in
Jsont.of_of_string ~kind:"EddsaSignature" sig_of_b32 ~enc:sig_to_b32
let sig_caqti =

60
src/rsa.ml
View file

@ -1,4 +1,6 @@
open Syntax
module Mirage_rsa = Mirage_crypto_pk.Rsa
module Z_extra = Mirage_crypto_pk.Z_extra
module Binary_format_rsa = struct
(* RSA public key binary format
@ -11,7 +13,7 @@ module Binary_format_rsa = struct
let z_array_to_octets (arr : Z.t array) =
let nb = Array.length arr in
let bits_arr = Array.map Mirage_crypto_pk.Z_extra.to_octets_be arr in
let bits_arr = Array.map Z_extra.to_octets_be arr in
let len_arr = Array.map String.length bits_arr in
let len = (2 * nb) + Array.fold_left ( + ) 0 len_arr in
let b = Bytes.make len '\x00' in
@ -47,49 +49,45 @@ module Binary_format_rsa = struct
Array.init nb (fun i ->
let len = len_arr.(i) in
let s = String.sub s !pos len in
let z = Mirage_crypto_pk.Z_extra.of_octets_be s in
let z = Z_extra.of_octets_be s in
pos := !pos + len;
z)
in
Ok z_arr
let pub_to_octets ({ n; e } : Mirage_crypto_pk.Rsa.pub) =
z_array_to_octets [| n; e |]
let pub_to_octets ({ n; e } : Mirage_rsa.pub) = z_array_to_octets [| n; e |]
let pub_of_octets s =
let* arr = z_array_of_octets ~nb:2 s in
match arr with
| [| n; e |] ->
let+ pub = Mirage_crypto_pk.Rsa.pub ~n ~e |> unwrap_msg in
let+ pub = Mirage_rsa.pub ~n ~e |> unwrap_msg in
pub
| _ -> assert false
(* custom private key binary format <> than gcrypt *)
let priv_to_octets ({ e; d; n; p; q; dp; dq; q' } : Mirage_crypto_pk.Rsa.priv)
=
let priv_to_octets ({ e; d; n; p; q; dp; dq; q' } : Mirage_rsa.priv) =
z_array_to_octets [| e; d; n; p; q; dp; dq; q' |]
let priv_of_octets s =
let* arr = z_array_of_octets ~nb:8 s in
match arr with
| [| e; d; n; p; q; dp; dq; q' |] ->
let+ priv =
Mirage_crypto_pk.Rsa.priv ~e ~d ~n ~p ~q ~dp ~dq ~q' |> unwrap_msg
in
let+ priv = Mirage_rsa.priv ~e ~d ~n ~p ~q ~dp ~dq ~q' |> unwrap_msg in
priv
| _ -> assert false
end
type priv = Mirage_crypto_pk.Rsa.priv
type pub = Mirage_crypto_pk.Rsa.pub
type sig_ = Sig of string
type priv = Mirage_rsa.priv
type pub = Mirage_rsa.pub
type sig_ = S of string [@@unboxed]
let generate ~bits () =
let priv = Mirage_crypto_pk.Rsa.generate ~bits () in
let pub = Mirage_crypto_pk.Rsa.pub_of_priv priv in
let priv = Mirage_rsa.generate ~bits () in
let pub = Mirage_rsa.pub_of_priv priv in
(priv, pub)
let pub_of_priv = Mirage_crypto_pk.Rsa.pub_of_priv
let pub_of_priv = Mirage_rsa.pub_of_priv
let priv_of_octets = Binary_format_rsa.priv_of_octets
let priv_to_octets = Binary_format_rsa.priv_to_octets
let pub_to_octets = Binary_format_rsa.pub_to_octets
@ -155,19 +153,19 @@ module Kdf = struct
let kdf_mod_n ~n ~xts ~ikm ~ctx =
let nbits = Z.numbits n in
let len = ((nbits - 1) / 8) + 1 in
assert (8 * len = nbits);
if 8 * len <> nbits then invalid_arg "RSA keysize must be multiple of 8";
let rec go ctr =
(* cat ctx ctr_be *)
let ctx =
(* String.cat ctx ctr_be *)
let ctx_ctr =
let ctx_len = String.length ctx in
let b = Bytes.create (ctx_len + 2) in
Bytes.blit_string ctx 0 b 0 ctx_len;
Bytes.set_uint16_be b ctx_len ctr;
Bytes.unsafe_to_string b
in
let okm = kdf ~xts ~ikm ~ctx ~len in
let okm = kdf ~xts ~ikm ~ctx:ctx_ctr ~len in
assert (String.length okm = len);
let r = Mirage_crypto_pk.Z_extra.of_octets_be okm in
let r = Z_extra.of_octets_be okm in
if Z.gt r n then go (succ ctr) else r
in
go 0
@ -195,10 +193,10 @@ let blind_msg pub ~bks msg =
let bkey = rsa_blinding_key_derive pub bks in
let r_e = Z.powm_sec bkey pub.e pub.n in
let data_r_e = Z.rem (Z.mul data r_e) pub.n in
Mirage_crypto_pk.Z_extra.to_octets_be data_r_e
Z_extra.to_octets_be data_r_e
let unblind_sig pub ~bks (Sig bsig) =
let data = Mirage_crypto_pk.Z_extra.of_octets_be bsig in
let unblind_sig pub ~bks (S bsig) =
let data = Z_extra.of_octets_be bsig in
let bkey = rsa_blinding_key_derive pub bks in
let r_inv =
try Z.invert bkey pub.n
@ -207,18 +205,18 @@ let unblind_sig pub ~bks (Sig bsig) =
assert false
in
let data = Z.rem (Z.mul data r_inv) pub.n in
let sig_ = Mirage_crypto_pk.Z_extra.to_octets_be data in
Sig sig_
let sig_ = Z_extra.to_octets_be data in
S sig_
let verify ~key (Sig s) ~msg =
let verify ~key (S s) ~msg =
let msg_fdh = rsa_full_domain_hash key msg in
let s1 = Mirage_crypto_pk.Z_extra.to_octets_be msg_fdh in
let s2 = Mirage_crypto_pk.Rsa.encrypt ~key s in
let s1 = Z_extra.to_octets_be msg_fdh in
let s2 = Mirage_rsa.encrypt ~key s in
match Eqaf.equal s1 s2 with
| false -> Fmt.error "RSA signature verification failed"
| true -> Ok ()
(* decrypt <=> sign *)
let sign ~key bmsg : sig_ =
let sig_ = Mirage_crypto_pk.Rsa.decrypt ~crt_hardening:true ~key bmsg in
Sig sig_
let sig_ = Mirage_rsa.decrypt ~crt_hardening:true ~key bmsg in
S sig_