forked from
gazagnaire.org/ocaml-crypto
upstream: https://github.com/mirage/mirage-crypto
Merge pull request #134 from hannesm/cstruct-6
use Cstruct.length instead of deprecated Cstruct.len
authored by
Hannes Mehnert
and committed by
GitHub
87c1f5bb
e5d38d9c
+84
-84
+1
-1
bench/speed.ml
+1
-1
bench/speed.ml
···
304
304
let open Mirage_crypto_rng.Fortuna in
305
305
let g = create () in
306
306
reseed ~g (Cstruct.of_string "abcd") ;
307
-
throughput name (fun cs -> generate ~g (Cstruct.len cs))) ;
307
+
throughput name (fun cs -> generate ~g (Cstruct.length cs))) ;
308
308
309
309
bm "md5" (fun name -> throughput name MD5.digest) ;
310
310
bm "sha1" (fun name -> throughput name SHA1.digest) ;
+10
-10
ec/mirage_crypto_ec.ml
+10
-10
ec/mirage_crypto_ec.ml
···
134
134
let copy dst src = Bigarray.Array1.blit src dst
135
135
136
136
let checked_buffer cs =
137
-
assert (Cstruct.len cs = P.byte_length);
137
+
assert (Cstruct.length cs = P.byte_length);
138
138
Cstruct.to_bigarray cs
139
139
140
140
let from_bytes fe cs =
···
234
234
235
235
let of_cstruct cs =
236
236
let len = P.byte_length in
237
-
if Cstruct.len cs = 0 then
237
+
if Cstruct.length cs = 0 then
238
238
Error `Invalid_format
239
239
else
240
240
match Cstruct.get_uint8 cs 0 with
241
-
| 0x00 when Cstruct.len cs = 1 -> Ok (at_infinity ())
242
-
| 0x04 when Cstruct.len cs = 1 + len + len ->
241
+
| 0x00 when Cstruct.length cs = 1 -> Ok (at_infinity ())
242
+
| 0x04 when Cstruct.length cs = 1 + len + len ->
243
243
let x = Cstruct.sub cs 1 len in
244
244
let y = Cstruct.sub cs (1 + len) len in
245
245
validate_finite_point ~x ~y
···
417
417
let priv_to_cstruct = S.to_cstruct
418
418
419
419
let padded msg =
420
-
let l = Cstruct.len msg in
420
+
let l = Cstruct.length msg in
421
421
let bl = Param.byte_length in
422
422
let first_byte_ok () =
423
423
match Param.first_byte_bits with
···
809
809
secret, public secret
810
810
811
811
let secret_of_cs s =
812
-
if Cstruct.len s = key_len then
812
+
if Cstruct.length s = key_len then
813
813
Ok (s, public s)
814
814
else
815
815
Error `Invalid_length
···
819
819
fun cs -> Cstruct.equal zero cs
820
820
821
821
let key_exchange secret public =
822
-
if Cstruct.len public = key_len then
822
+
if Cstruct.length public = key_len then
823
823
let res = scalar_mult secret public in
824
824
if is_zero res then Error `Low_order else Ok res
825
825
else
···
857
857
let pub_of_priv secret = fst (public secret)
858
858
859
859
let priv_of_cstruct cs =
860
-
if Cstruct.len cs = key_len then Ok cs else Error `Invalid_length
860
+
if Cstruct.length cs = key_len then Ok cs else Error `Invalid_length
861
861
862
862
let priv_to_cstruct priv = priv
863
863
864
864
let pub_of_cstruct cs =
865
-
if Cstruct.len cs = key_len then
865
+
if Cstruct.length cs = key_len then
866
866
let cs_copy = Cstruct.create key_len in
867
867
Cstruct.blit cs 0 cs_copy 0 key_len;
868
868
if pub_ok cs_copy.Cstruct.buffer then
···
893
893
894
894
let verify ~key signature ~msg =
895
895
(* section 5.1.7 *)
896
-
if Cstruct.len signature = 2 * key_len then
896
+
if Cstruct.length signature = 2 * key_len then
897
897
let r, s = Cstruct.split signature key_len in
898
898
let s_smaller_l =
899
899
(* check s within 0 <= s < L *)
+1
-1
mirage-crypto-ec.opam
+1
-1
mirage-crypto-ec.opam
+1
-1
mirage-crypto-pk.opam
+1
-1
mirage-crypto-pk.opam
+1
-1
mirage-crypto-rng.opam
+1
-1
mirage-crypto-rng.opam
+1
-1
mirage-crypto.opam
+1
-1
mirage-crypto.opam
+1
-1
pk/dsa.ml
+1
-1
pk/dsa.ml
···
160
160
161
161
let massage ~key:({ q; _ }: pub) digest =
162
162
let bits = Z.numbits q in
163
-
if bits >= Cstruct.len digest * 8 then digest else
163
+
if bits >= Cstruct.length digest * 8 then digest else
164
164
let cs = Z_extra.(to_cstruct_be Z.(of_cstruct_be digest mod q)) in
165
165
Cs.(cs lsl ((8 - bits mod 8) mod 8))
+11
-11
pk/rsa.ml
+11
-11
pk/rsa.ml
···
235
235
go Mirage_crypto_rng.(generate ?g k) 0 0
236
236
237
237
let pad ~mark ~padding k msg =
238
-
let pad = padding (k - len msg - 3 |> imax min_pad) in
238
+
let pad = padding (k - length msg - 3 |> imax min_pad) in
239
239
cat [ bx00 ; b mark ; pad ; bx00 ; msg ]
240
240
241
241
let unpad ~mark ~is_pad cs =
···
246
246
and c3 = get_uint8 cs i = 0x00
247
247
and c4 = min_pad <= i - 2 in
248
248
if c1 && c2 && c3 && c4 then
249
-
Some (sub cs (i + 1) (len cs - i - 1))
249
+
Some (sub cs (i + 1) (length cs - i - 1))
250
250
else None
251
251
252
252
let pad_01 =
···
264
264
let padded pad transform keybits msg =
265
265
let n = keybits // 8 in
266
266
let p = pad n msg in
267
-
if len p = n then transform p else raise Insufficient_key
267
+
if length p = n then transform p else raise Insufficient_key
268
268
269
269
let unpadded unpad transform keybits msg =
270
-
if len msg = keybits // 8 then
270
+
if length msg = keybits // 8 then
271
271
try unpad (transform msg) with Insufficient_key -> None
272
272
else None
273
273
···
311
311
~default:false
312
312
313
313
let min_key hash =
314
-
(len (asn_of_hash hash) + Hash.digest_size hash + min_pad + 2) * 8 + 1
314
+
(length (asn_of_hash hash) + Hash.digest_size hash + min_pad + 2) * 8 + 1
315
315
end
316
316
317
317
module MGF1 (H : Hash.S) = struct
···
329
329
go (h :: acc) Int32.(succ c) (pred n) in
330
330
go [] 0l (len // H.digest_size)
331
331
332
-
let mask ~seed cs = Cs.xor (mgf ~seed (Cstruct.len cs)) cs
332
+
let mask ~seed cs = Cs.xor (mgf ~seed (Cstruct.length cs)) cs
333
333
end
334
334
335
335
module OAEP (H : Hash.S) = struct
···
344
344
345
345
let eme_oaep_encode ?g ?(label = Cstruct.empty) k msg =
346
346
let seed = Mirage_crypto_rng.generate ?g hlen
347
-
and pad = Cstruct.create (max_msg_bytes k - len msg) in
347
+
and pad = Cstruct.create (max_msg_bytes k - length msg) in
348
348
let db = cat [ H.digest label ; pad ; bx01 ; msg ] in
349
349
let mdb = MGF.mask ~seed db in
350
350
let mseed = MGF.mask ~seed:mdb seed in
···
361
361
362
362
let encrypt ?g ?label ~key msg =
363
363
let k = pub_bits key // 8 in
364
-
if len msg > max_msg_bytes k then raise Insufficient_key
364
+
if length msg > max_msg_bytes k then raise Insufficient_key
365
365
else encrypt ~key @@ eme_oaep_encode ?g ?label k msg
366
366
367
367
let decrypt ?(crt_hardening = false) ?mask ?label ~key em =
368
368
let k = priv_bits key // 8 in
369
-
if len em <> k || max_msg_bytes k < 0 then None else
369
+
if length em <> k || max_msg_bytes k < 0 then None else
370
370
try eme_oaep_decode ?label @@ decrypt ~crt_hardening ?mask ~key em
371
371
with Insufficient_key -> None
372
372
···
407
407
let (mdb, h, bxx) = Cs.split3 em (em.len - hlen - 1) hlen in
408
408
let db = MGF.mask ~seed:h mdb in
409
409
set_uint8 db 0 (get_uint8 db 0 land b0mask emlen) ;
410
-
let salt = shift db (len db - slen) in
410
+
let salt = shift db (length db - slen) in
411
411
let h' = digest ~salt msg
412
412
and i = ct_find_uint8 ~default:0 ~f:((<>) 0x00) db in
413
413
let c1 = lnot (b0mask emlen) land get_uint8 mdb 0 = 0x00
···
429
429
430
430
let verify ?(slen = hlen) ~key ~signature msg =
431
431
let b = pub_bits key
432
-
and s = len signature in
432
+
and s = length signature in
433
433
s = b // 8 && sufficient_key ~slen b && try
434
434
let em = encrypt ~key signature in
435
435
emsa_pss_verify (imax 0 slen) (b - 1) (shift em (s - (b - 1) // 8)) msg
+3
-3
pk/z_extra.ml
+3
-3
pk/z_extra.ml
···
25
25
Z.(of_int x asr b' + acc lsl b)
26
26
| _ -> acc in
27
27
loop Z.zero 0 @@ match bits with
28
-
| None -> Cstruct.len cs * 8
29
-
| Some b -> imin b (Cstruct.len cs * 8)
28
+
| None -> Cstruct.length cs * 8
29
+
| Some b -> imin b (Cstruct.length cs * 8)
30
30
31
31
let byte1 = Z.of_int64 0xffL
32
32
and byte2 = Z.of_int64 0xffffL
···
49
49
| 0 -> set_uint8 cs 0 Z.(to_int (n land byte1)) ;
50
50
| _ -> ()
51
51
in
52
-
write n (len cs - 1)
52
+
write n (length cs - 1)
53
53
54
54
let to_cstruct_be ?size n =
55
55
let cs = Cstruct.create_unsafe @@ match size with
+1
-1
rng/entropy.ml
+1
-1
rng/entropy.ml
+2
-2
rng/fortuna.ml
+2
-2
rng/fortuna.ml
···
105
105
let add ~g (source, _) ~pool data =
106
106
let pool = pool land (pools - 1)
107
107
and source = source land 0xff in
108
-
let header = Cs.of_bytes [ source ; Cstruct.len data ] in
108
+
let header = Cs.of_bytes [ source ; Cstruct.length data ] in
109
109
g.pools.(pool) <- SHAd256.feedi g.pools.(pool) (iter2 header data);
110
-
if pool = 0 then g.pool0_size <- g.pool0_size + Cstruct.len data
110
+
if pool = 0 then g.pool0_size <- g.pool0_size + Cstruct.length data
111
111
112
112
(* XXX
113
113
* Schneier recommends against using generator-imposed pool-seeding schedule
+13
-13
src/ccm.ml
+13
-13
src/ccm.ml
···
27
27
(* assume t is valid mac size *)
28
28
(* n + q = 15 *)
29
29
(* a < 2 ^ 64 *)
30
-
let n = Cstruct.len nonce in
30
+
let n = Cstruct.length nonce in
31
31
let small_q = 15 - n in
32
32
(* first byte (flags): *)
33
33
(* reserved | adata | (t - 2) / 2 | q - 1 *)
34
-
let b6 = if Cstruct.len adata = 0 then 0 else 1 in
34
+
let b6 = if Cstruct.length adata = 0 then 0 else 1 in
35
35
let flag = flags b6 ((t - 2) / 2) (small_q - 1) in
36
36
(* first octet block:
37
37
0 : flags
···
41
41
flag <+> nonce <+> qblock
42
42
43
43
let pad_block b =
44
-
let size = Cstruct.len b in
44
+
let size = Cstruct.length b in
45
45
Cs.rpad b (size // block_size * block_size) 0
46
46
47
47
let gen_adata a =
48
48
let lbuf =
49
-
match Cstruct.len a with
49
+
match Cstruct.length a with
50
50
| x when x < (1 lsl 16 - 1 lsl 8) ->
51
51
let buf = Cstruct.create 2 in
52
52
Cstruct.BE.set_uint16 buf 0 x ;
···
63
63
pad_block (lbuf <+> a)
64
64
65
65
let gen_ctr_prefix nonce =
66
-
let n = Cstruct.len nonce in
66
+
let n = Cstruct.length nonce in
67
67
let small_q = 15 - n in
68
68
let flag = flags 0 0 (small_q - 1) in
69
69
(flag <+> nonce, succ n, small_q)
···
73
73
pre <+> encode_len q i
74
74
75
75
let prepare_header nonce adata plen tlen =
76
-
let ada = if Cstruct.len adata = 0 then Cstruct.empty else gen_adata adata in
76
+
let ada = if Cstruct.length adata = 0 then Cstruct.empty else gen_adata adata in
77
77
format nonce adata plen tlen <+> ada
78
78
79
79
type mode = Encrypt | Decrypt
80
80
81
81
let crypto_core ~cipher ~mode ~key ~nonce ~maclen ~adata data =
82
-
let datalen = Cstruct.len data in
82
+
let datalen = Cstruct.length data in
83
83
let cbcheader = prepare_header nonce adata datalen maclen in
84
84
let target = Cstruct.create datalen in
85
85
···
97
97
98
98
let cbcprep =
99
99
let rec doit iv block =
100
-
match Cstruct.len block with
100
+
match Cstruct.length block with
101
101
| 0 -> iv
102
102
| _ ->
103
103
cbc iv block ;
···
113
113
| Encrypt -> src
114
114
| Decrypt -> target
115
115
in
116
-
match Cstruct.len src with
116
+
match Cstruct.length src with
117
117
| 0 -> iv
118
118
| x when x < block_size ->
119
119
let ctrbl = pad_block target in
···
139
139
let crypto_t t nonce cipher key =
140
140
let ctr = gen_ctr nonce 0 in
141
141
cipher ~key ctr ctr ;
142
-
Cs.xor_into ctr t (Cstruct.len t)
142
+
Cs.xor_into ctr t (Cstruct.length t)
143
143
144
144
let valid_nonce nonce =
145
-
let nsize = Cstruct.len nonce in
145
+
let nsize = Cstruct.length nonce in
146
146
if nsize < 7 || nsize > 13 then
147
147
invalid_arg "CCM: nonce length not between 7 and 13: %d" nsize
148
148
···
154
154
155
155
let decryption_verification ~cipher ~key ~nonce ~maclen ~adata data =
156
156
valid_nonce nonce;
157
-
if Cstruct.len data < maclen then
157
+
if Cstruct.length data < maclen then
158
158
None
159
159
else
160
-
let pclen = Cstruct.len data - maclen in
160
+
let pclen = Cstruct.length data - maclen in
161
161
let cdata, t = crypto_core ~cipher ~mode:Decrypt ~key ~nonce ~maclen ~adata (Cstruct.sub data 0 pclen) in
162
162
let t' = Cs.clone (Cstruct.sub data pclen maclen) in
163
163
crypto_t t' nonce cipher key ;
+8
-8
src/chacha20.ml
+8
-8
src/chacha20.ml
···
20
20
and inc64 b = set_ctr64 b (Int64.add (Cstruct.LE.get_uint64 b ctr_off) 1L)
21
21
in
22
22
let s, key, init_ctr, nonce_off, inc =
23
-
match Cstruct.len key, Cstruct.len nonce, Int64.shift_right ctr 32 = 0L with
23
+
match Cstruct.length key, Cstruct.length nonce, Int64.shift_right ctr 32 = 0L with
24
24
| 32, 12, true ->
25
25
let ctr = Int64.to_int32 ctr in
26
26
"expand 32-byte k", key, (fun b -> set_ctr32 b ctr), 52, inc32
···
39
39
Cstruct.blit_from_string s 0 state 0 16 ;
40
40
Cstruct.blit key 0 state 16 32 ;
41
41
init_ctr state ;
42
-
Cstruct.blit nonce 0 state nonce_off (Cstruct.len nonce) ;
42
+
Cstruct.blit nonce 0 state nonce_off (Cstruct.length nonce) ;
43
43
state, inc
44
44
45
45
let crypt ~key ~nonce ?(ctr = 0L) data =
46
46
let state, inc = init ctr ~key ~nonce in
47
-
let l = Cstruct.len data in
47
+
let l = Cstruct.length data in
48
48
let block_count = l // block in
49
49
let len = block * block_count in
50
50
let last_len =
···
72
72
73
73
let mac ~key ~adata ciphertext =
74
74
let pad16 b =
75
-
let len = Cstruct.len b mod 16 in
75
+
let len = Cstruct.length b mod 16 in
76
76
if len = 0 then Cstruct.empty else Cstruct.create (16 - len)
77
77
and len =
78
78
let data = Cstruct.create 16 in
79
-
Cstruct.LE.set_uint64 data 0 (Int64.of_int (Cstruct.len adata));
80
-
Cstruct.LE.set_uint64 data 8 (Int64.of_int (Cstruct.len ciphertext));
79
+
Cstruct.LE.set_uint64 data 0 (Int64.of_int (Cstruct.length adata));
80
+
Cstruct.LE.set_uint64 data 8 (Int64.of_int (Cstruct.length ciphertext));
81
81
data
82
82
in
83
83
let ctx = P.empty ~key in
···
95
95
Cstruct.append ciphertext mac
96
96
97
97
let authenticate_decrypt ~key ~nonce ?(adata = Cstruct.empty) data =
98
-
if Cstruct.len data < P.mac_size then
98
+
if Cstruct.length data < P.mac_size then
99
99
None
100
100
else
101
-
let cipher, tag = Cstruct.split data (Cstruct.len data - P.mac_size) in
101
+
let cipher, tag = Cstruct.split data (Cstruct.length data - P.mac_size) in
102
102
let poly1305_key = generate_poly1305_key ~key ~nonce in
103
103
let ctag = mac ~key:poly1305_key ~adata cipher in
104
104
let plain = crypt ~key ~nonce ~ctr:1L cipher in
+4
-4
src/cipher_block.ml
+4
-4
src/cipher_block.ml
···
267
267
C.encrypt ~key ~blocks:1 z128.buffer z128.off h.buffer h.off;
268
268
{ key ; hkey = GHASH.derive h }
269
269
270
-
let bits64 cs = Int64.of_int (len cs * 8)
270
+
let bits64 cs = Int64.of_int (length cs * 8)
271
271
let pack64s = let _cs = create_unsafe 16 in fun a b ->
272
272
BE.set_uint64 _cs 0 a; BE.set_uint64 _cs 8 b; _cs
273
273
274
-
let counter ~hkey nonce = match len nonce with
274
+
let counter ~hkey nonce = match length nonce with
275
275
| 0 -> invalid_arg "GCM: invalid nonce of length 0"
276
276
| 12 -> let (w1, w2) = BE.get_uint64 nonce 0, BE.get_uint32 nonce 8 in
277
277
(w1, Int64.(shift_left (of_int32 w2) 32 |> add 1L))
···
291
291
292
292
let authenticate_decrypt ~key:{ key; hkey } ~nonce ?adata cdata =
293
293
let ctr = counter ~hkey nonce in
294
-
if Cstruct.len cdata < tag_size then
294
+
if Cstruct.length cdata < tag_size then
295
295
None
296
296
else
297
297
let cipher, tag_data =
298
-
Cstruct.split cdata (Cstruct.len cdata - tag_size)
298
+
Cstruct.split cdata (Cstruct.length cdata - tag_size)
299
299
in
300
300
let data = CTR.(encrypt ~key ~ctr:(add_ctr ctr 1L) cipher) in
301
301
let ctag = tag ~key ~hkey ~ctr ?adata cipher in
+2
-2
src/cipher_stream.ml
+2
-2
src/cipher_stream.ml
···
15
15
type result = { message : Cstruct.t ; key : key }
16
16
17
17
let of_secret cs =
18
-
let len = Cstruct.len cs in
18
+
let len = Cstruct.length cs in
19
19
if len < 1 || len > 256 then invalid_arg "ARC4.of_secret: key size %d" len;
20
20
let s = Array.init 256 (fun x -> x) in
21
21
let rec loop j = function
···
32
32
33
33
let encrypt ~key:(i, j, s') cs =
34
34
let s = Array.copy s'
35
-
and len = Cstruct.len cs in
35
+
and len = Cstruct.length cs in
36
36
let res = Cstruct.create len in
37
37
let rec mix i j = function
38
38
| n when n = len -> (i, j, s)
+1
-1
src/hash.ml
+1
-1
src/hash.ml
+6
-6
src/uncommon.ml
+6
-6
src/uncommon.ml
···
30
30
( blit cs 0 cs' 0 len ; cs' )
31
31
32
32
let xor_into src dst n =
33
-
if n > imin (len src) (len dst) then
33
+
if n > imin (length src) (length dst) then
34
34
invalid_arg "Uncommon.Cs.xor_into: buffers to small (need %d)" n
35
35
else Native.xor_into src.buffer src.off dst.buffer dst.off n
36
36
37
37
let xor cs1 cs2 =
38
-
let len = imin (len cs1) (len cs2) in
38
+
let len = imin (length cs1) (length cs2) in
39
39
let cs = clone ~len cs2 in
40
40
( xor_into cs1 cs len ; cs )
41
41
···
43
43
44
44
let set_msb bits cs =
45
45
if bits > 0 then
46
-
let n = len cs in
46
+
let n = length cs in
47
47
let rec go width = function
48
48
| i when i = n -> ()
49
49
| i when width < 8 ->
···
54
54
55
55
let split3 cs l1 l2 =
56
56
let l12 = l1 + l2 in
57
-
(sub cs 0 l1, sub cs l1 l2, sub cs l12 (len cs - l12))
57
+
(sub cs 0 l1, sub cs l1 l2, sub cs l12 (length cs - l12))
58
58
59
59
let rpad cs size x =
60
-
let l = len cs and cs' = Cstruct.create_unsafe size in
60
+
let l = length cs and cs' = Cstruct.create_unsafe size in
61
61
if size < l then invalid_arg "Uncommon.Cs.rpad: size < len";
62
62
blit cs 0 cs' 0 l ;
63
63
memset (sub cs' l (size - l)) x ;
64
64
cs'
65
65
66
66
let lpad cs size x =
67
-
let l = len cs and cs' = Cstruct.create_unsafe size in
67
+
let l = length cs and cs' = Cstruct.create_unsafe size in
68
68
if size < l then invalid_arg "Uncommon.Cs.lpad: size < len";
69
69
blit cs 0 cs' (size - l) l ;
70
70
memset (sub cs' 0 (size - l)) x ;
+1
-1
tests/test_cipher.ml
+1
-1
tests/test_cipher.ml
···
92
92
let dec = decrypt ~key ~ctr enc in
93
93
assert_cs_equal ~msg:"cipher" out enc;
94
94
assert_cs_equal ~msg:"plain" nist_sp_800_38a dec;
95
-
let blocks = Cstruct.len nist_sp_800_38a / block_size in
95
+
let blocks = Cstruct.length nist_sp_800_38a / block_size in
96
96
assert_equal ~msg:"counters" ctr1 (add_ctr ctr (Int64.of_int blocks))
97
97
in
98
98
[ case ~key: "2b7e1516 28aed2a6 abf71588 09cf4f3c"
+1
-1
tests/test_common.ml
+1
-1
tests/test_common.ml
+4
-4
tests/test_ec.ml
+4
-4
tests/test_ec.ml
···
6
6
end
7
7
8
8
let pp_hex_le fmt cs =
9
-
let n = Cstruct.len cs in
9
+
let n = Cstruct.length cs in
10
10
for i = n - 1 downto 0 do
11
11
let byte = Cstruct.get_uint8 cs i in
12
12
Format.fprintf fmt "%02x" byte
···
307
307
let case hash ~message ~k ~r ~s () =
308
308
let msg =
309
309
let h = Mirage_crypto.Hash.digest hash (Cstruct.of_string message) in
310
-
Cstruct.sub h 0 (min (Cstruct.len h) 28)
310
+
Cstruct.sub h 0 (min (Cstruct.length h) 28)
311
311
and k = Cstruct.of_hex k
312
312
in
313
313
let k' =
···
403
403
let case hash ~message ~k ~r ~s () =
404
404
let msg =
405
405
let h = Mirage_crypto.Hash.digest hash (Cstruct.of_string message) in
406
-
Cstruct.sub h 0 (min (Cstruct.len h) 32)
406
+
Cstruct.sub h 0 (min (Cstruct.length h) 32)
407
407
and k = Cstruct.of_hex k
408
408
in
409
409
let k' =
···
488
488
let case hash ~message ~k ~r ~s () =
489
489
let msg =
490
490
let h = Mirage_crypto.Hash.digest hash (Cstruct.of_string message) in
491
-
Cstruct.sub h 0 (min (Cstruct.len h) 48)
491
+
Cstruct.sub h 0 (min (Cstruct.length h) 48)
492
492
and k = Cstruct.of_hex k
493
493
in
494
494
let k' =
+4
-4
tests/test_ec_wycheproof.ml
+4
-4
tests/test_ec_wycheproof.ml
···
19
19
match Asn.decode (Asn.codec Asn.ber term) cs with
20
20
| Error _ -> Error "ASN1 parse error"
21
21
| Ok (((oid1, oid2), data), rest) ->
22
-
if Cstruct.len rest <> 0 then Error "ASN1 leftover"
22
+
if Cstruct.length rest <> 0 then Error "ASN1 leftover"
23
23
else if not (Asn.OID.equal oid1 ec_public_key) then
24
24
Error "ASN1: wrong oid 1"
25
25
else if not (Asn.OID.equal oid2 prime_oid) then Error "ASN1: wrong oid 2"
···
38
38
Error msg
39
39
40
40
let pad ~total_len cs =
41
-
match total_len - Cstruct.len cs with
41
+
match total_len - Cstruct.length cs with
42
42
| 0 -> Ok cs
43
43
| n when n < 0 ->
44
44
let is_zero = ref true in
···
152
152
match Asn.(decode (codec der asn) cs) with
153
153
| Error _ -> Error "ASN1 parse error"
154
154
| Ok ((r, s), rest) ->
155
-
if Cstruct.len rest <> 0 then Error "ASN1 leftover"
155
+
if Cstruct.length rest <> 0 then Error "ASN1 leftover"
156
156
else if Z.sign r < 0 || Z.sign s < 0 then
157
157
Error "r and s must be >= 0"
158
158
else
···
163
163
let size = len curve in
164
164
let msg =
165
165
let h = Mirage_crypto.Hash.digest hash (Cstruct.of_string tst.msg) in
166
-
Cstruct.sub h 0 (min size (Cstruct.len h))
166
+
Cstruct.sub h 0 (min size (Cstruct.length h))
167
167
in
168
168
let verified (r,s) =
169
169
match curve with
+3
-3
tests/test_hmac.ml
+3
-3
tests/test_hmac.ml
···
105
105
List.mapi (fun i x ->
106
106
if i == 3 || i == 5 || i == 6 then
107
107
x
108
-
else Cstruct.(sub x 0 (min (len x) 16)))
108
+
else Cstruct.(sub x 0 (min (length x) 16)))
109
109
k in
110
110
List.combine keys d
111
111
···
214
214
let test hash i ((key, data), result) _ =
215
215
let computed = Hash.mac hash ~key:key data in
216
216
if i == 4 (* truncated thingy *) then
217
-
assert_cs_equal result Cstruct.(sub computed 0 (len result))
217
+
assert_cs_equal result Cstruct.(sub computed 0 (length result))
218
218
else
219
219
assert_cs_equal result computed
220
220
···
226
226
let empty = H.hmac_empty ~key in
227
227
let computed = H.hmac_get (H.hmac_feed empty data) in
228
228
if i == 4 (* truncated thingy *) then
229
-
assert_cs_equal result Cstruct.(sub computed 0 (len result))
229
+
assert_cs_equal result Cstruct.(sub computed 0 (length result))
230
230
else
231
231
assert_cs_equal result computed
232
232
+1
-1
tests/test_random_runner.ml
+1
-1
tests/test_random_runner.ml
···
43
43
let dec = M.decrypt ~key ~ctr enc in
44
44
assert_cs_equal ~msg:"CTR e->d" data dec;
45
45
let (d1, d2) =
46
-
Cstruct.split data @@ bs * Randomconv.int ~bound:(Cstruct.len data / bs) Mirage_crypto_rng.generate in
46
+
Cstruct.split data @@ bs * Randomconv.int ~bound:(Cstruct.length data / bs) Mirage_crypto_rng.generate in
47
47
assert_cs_equal ~msg:"CTR chain" enc @@
48
48
Cstruct.append (M.encrypt ~key ~ctr d1)
49
49
(M.encrypt ~key ~ctr:(M.next_ctr ~ctr d1) d2)
+1
-1
tests/test_rng.ml
+1
-1
tests/test_rng.ml
+2
-2
tests/test_rsa.ml
+2
-2
tests/test_rsa.ml
···
24
24
25
25
let reseed ~g cs = g := Cs.(!g <+> cs)
26
26
27
-
let seeded ~g = Cstruct.len !g > 0
27
+
let seeded ~g = Cstruct.length !g > 0
28
28
29
29
let accumulate ~g _source = `Acc (reseed ~g)
30
30
···
231
231
let module Pss = Rsa.PSS (H) in
232
232
let msg = vx msg and sgn = vx sgn and salt = vx salt in
233
233
let key, public = key () in
234
-
let slen = Cstruct.len salt in
234
+
let slen = Cstruct.length salt in
235
235
Pss.sign ~g:(random_is salt) ~slen ~mask:`No ~key (`Message msg)
236
236
|> assert_cs_equal ~msg:"recomputing sig:" sgn ;
237
237
Pss.verify ~key:public ~slen ~signature:sgn (`Message msg)