xs/kdf.xs

filter: Statementstmt 79.4% 58 / 73 Branchbran 61.7% 21 / 34 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 73.8% 79 / 107 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/hkdf.xs ↑ Summary xs/base64.xs »
1 #define csxs_kdf_DERIVE_ID_CEILING 0x1p+53
2  
3 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::kdf
4  
5 void _define_constants()
6 PREINIT:
7 1 HV *stash = gv_stashpv("Crypt::Sodium::XS::kdf", 0);
8  
9 PPCODE:
10 1 newCONSTSUB(stash, "kdf_BYTES_MAX", newSVuv(crypto_kdf_BYTES_MAX));
11 1 newCONSTSUB(stash, "kdf_blake2b_BYTES_MAX",
12 newSVuv(crypto_kdf_blake2b_BYTES_MAX));
13 1 newCONSTSUB(stash, "kdf_BYTES_MIN", newSVuv(crypto_kdf_BYTES_MIN));
14 1 newCONSTSUB(stash, "kdf_blake2b_BYTES_MIN",
15 newSVuv(crypto_kdf_blake2b_BYTES_MIN));
16 1 newCONSTSUB(stash, "kdf_CONTEXTBYTES", newSVuv(crypto_kdf_CONTEXTBYTES));
17 1 newCONSTSUB(stash, "kdf_blake2b_CONTEXTBYTES",
18 newSVuv(crypto_kdf_blake2b_CONTEXTBYTES));
19 1 newCONSTSUB(stash, "kdf_KEYBYTES", newSVuv(crypto_kdf_KEYBYTES));
20 1 newCONSTSUB(stash, "kdf_blake2b_KEYBYTES",
21 newSVuv(crypto_kdf_blake2b_KEYBYTES));
22 1 newCONSTSUB(stash, "kdf_PRIMITIVE", newSVpvs(crypto_kdf_PRIMITIVE));
23 1 newCONSTSUB(stash, "kdf_DERIVE_CEILING", newSVnv(csxs_kdf_DERIVE_ID_CEILING));
24  
25 SV * kdf_derive( \
26 SV * key, \
27 SV * id_sv, \
28 STRLEN new_key_len, \
29 SV * ctx = &PL_sv_undef, \
30 SV * flags = &PL_sv_undef \
31 )
32  
33 ALIAS:
34 kdf_blake2b_derive = 1
35  
36 PREINIT:
37 74 protmem *key_mv = NULL, *new_key_mv;
38 unsigned char *key_buf;
39 74 char *ctx_buf = NULL;
40 STRLEN key_len, ctx_len, key_req_len, ctx_req_len, new_key_req_min, new_key_req_max;
41 unsigned int new_key_flags;
42 uint64_t id;
43 int (*func)(unsigned char *, size_t, uint64_t,
44 const char *, const unsigned char *);
45  
46 CODE:
47 #ifdef LESSTHAN64BITINT
48 id = SvNV(id_sv);
49 #else
50 74 id = SvUV(id_sv);
51 #endif
52 74 ▶ if (id >= csxs_kdf_DERIVE_ID_CEILING)
Branch: 1 branch
BranchTrueFalseTotal
if (id >= csxs_kdf_DERIVE_ID_CEILING) 2 72 74
53 2 croak("derive: id cannot be larger than (%a - 1)", csxs_kdf_DERIVE_ID_CEILING);
54 72 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 36 36 72
55 36 case 1:
56 36 key_req_len = crypto_kdf_blake2b_KEYBYTES;
57 36 ctx_req_len = crypto_kdf_blake2b_CONTEXTBYTES;
58 36 new_key_req_min = crypto_kdf_blake2b_BYTES_MIN;
59 36 new_key_req_max = crypto_kdf_blake2b_BYTES_MAX;
60 36 func = crypto_kdf_blake2b_derive_from_key;
61 36 break;
62 36 default:
63 36 key_req_len = crypto_kdf_KEYBYTES;
64 36 ctx_req_len = crypto_kdf_CONTEXTBYTES;
65 36 new_key_req_min = crypto_kdf_BYTES_MIN;
66 36 new_key_req_max = crypto_kdf_BYTES_MAX;
67 36 func = crypto_kdf_derive_from_key;
68 }
69  
70 72 ▶ if (new_key_len < new_key_req_min)
Branch: 1 branch
BranchTrueFalseTotal
if (new_key_len < new_key_req_min) 0 72 72
71 0 croak("derive: Invalid derived key length (too short)");
72 72 ▶ if (new_key_len > new_key_req_max)
Branch: 1 branch
BranchTrueFalseTotal
if (new_key_len > new_key_req_max) 0 72 72
73 0 croak("derive: Invalid derived key length (too long)");
74  
75 72 SvGETMAGIC(ctx);
76 72 ▶ if (SvOK(ctx)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(ctx)) { 16 56 72
77 16 ctx_buf = SvPVbyte_nomg(ctx, ctx_len);
78 16 ▶ if (ctx_len < ctx_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (ctx_len < ctx_req_len) 2 14 16
79 2 croak("derive: Invalid context length (too short)");
80 }
81 else
82 /* some default 8 bytes of junk. should really be ensuring this is
83 * always CONTEXTBYTES long (in case it ever changes). */
84 56 ctx_buf = "00000000";
85  
86 70 ▶ if (sv_derived_from(key, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(key, MEMVAULT_CLASS)) { 70 0 70
87 70 key_mv = protmem_get(aTHX_ key, MEMVAULT_CLASS);
88 70 key_buf = key_mv->pm_ptr;
89 70 key_len = key_mv->size;
90 }
91 else
92 0 key_buf = (unsigned char *)SvPVbyte(key, key_len);
93 70 ▶ if (key_len != key_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (key_len != key_req_len) 0 70 70
94 0 croak("derive: Invalid key length");
95  
96 70 ▶ if (key_mv)
Branch: 1 branch
BranchTrueFalseTotal
if (key_mv) 70 0 70
97 70 new_key_flags = key_mv->flags;
98 else {
99 0 SvGETMAGIC(flags);
100 0 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 0 0
101 0 new_key_flags = SvUV_nomg(flags);
102 else
103 0 new_key_flags = g_protmem_default_flags_key;
104 }
105  
106 70 new_key_mv = protmem_init(aTHX_ new_key_len, new_key_flags);
107 70 ▶ if (new_key_mv == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (new_key_mv == NULL) 0 70 70
108 0 croak("derive: Failed to allocate protmem");
109  
110 70 ▶ if (key_mv && protmem_grant(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_mv && protmem_grant(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 70 0 70
if (key_mv && protmem_grant(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 70 70
111 0 protmem_free(aTHX_ new_key_mv);
112 0 croak("derive: Failed to grant key protmem RO");
113 }
114  
115 70 func(new_key_mv->pm_ptr, new_key_len, id, ctx_buf, key_buf);
116  
117 70 ▶ if (key_mv && protmem_release(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_mv && protmem_release(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 70 0 70
if (key_mv && protmem_release(aTHX_ key_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 70 70
118 0 protmem_free(aTHX_ new_key_mv);
119 0 croak("derive: Failed to release key protmem RO");
120 }
121  
122 70 ▶ if (protmem_release(aTHX_ new_key_mv, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ new_key_mv, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 70 70
123 0 protmem_free(aTHX_ new_key_mv);
124 0 croak("derive: Failed to release protmem RO");
125 }
126  
127 70 RETVAL = protmem_to_sv(aTHX_ new_key_mv, MEMVAULT_CLASS);
128  
129 OUTPUT:
130 RETVAL
131  
132 SV * kdf_keygen(SV * flags = &PL_sv_undef)
133  
134 ALIAS:
135 kdf_blake2b_keygen = 1
136  
137 CODE:
138 2 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 1 1 2
139 1 case 1:
140 1 RETVAL = sv_keygen(aTHX_ crypto_kdf_blake2b_KEYBYTES, flags);
141 1 break;
142 1 default:
143 1 RETVAL = sv_keygen(aTHX_ crypto_kdf_KEYBYTES, flags);
144 }
145  
146 OUTPUT:
147 RETVAL
« xs/hkdf.xs ↑ Summary xs/base64.xs »