xs/hkdf.xs

filter: Statementstmt 76.1% 153 / 201 Branchbran 64.5% 71 / 110 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 72.0% 224 / 311 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/scalarmult.xs ↑ Summary xs/kdf.xs »
1 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::hkdf
2  
3 void _define_constants()
4 PREINIT:
5 1 HV *stash = gv_stashpv("Crypt::Sodium::XS::hkdf", 0);
6  
7 PPCODE:
8 #ifdef SODIUM_HAS_HKDF
9 1 newCONSTSUB(stash, "hkdf_sha256_BYTES_MAX",
10 newSVuv(crypto_kdf_hkdf_sha256_BYTES_MAX));
11 1 newCONSTSUB(stash, "hkdf_sha512_BYTES_MAX",
12 newSVuv(crypto_kdf_hkdf_sha512_BYTES_MAX));
13 1 newCONSTSUB(stash, "hkdf_sha256_BYTES_MIN",
14 newSVuv(crypto_kdf_hkdf_sha256_BYTES_MIN));
15 1 newCONSTSUB(stash, "hkdf_sha512_BYTES_MIN",
16 newSVuv(crypto_kdf_hkdf_sha512_BYTES_MIN));
17 1 newCONSTSUB(stash, "hkdf_sha256_KEYBYTES",
18 newSVuv(crypto_kdf_hkdf_sha256_KEYBYTES));
19 1 newCONSTSUB(stash, "hkdf_sha512_KEYBYTES",
20 newSVuv(crypto_kdf_hkdf_sha512_KEYBYTES));
21 1 newCONSTSUB(stash, "hkdf_available", &PL_sv_yes);
22 #else
23 newCONSTSUB(stash, "hkdf_available", &PL_sv_no);
24 #endif
25  
26 SV * hkdf_sha256_keygen(SV * flags = &PL_sv_undef)
27  
28 ALIAS:
29 hkdf_sha256_keygen = 1
30 hkdf_sha512_keygen = 2
31  
32 CODE:
33 #ifdef SODIUM_HAS_HKDF
34 6 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 3 3 6
35 3 case 1:
36 3 RETVAL = sv_keygen(aTHX_ crypto_kdf_hkdf_sha256_KEYBYTES, flags);
37 3 break;
38 3 default:
39 3 RETVAL = sv_keygen(aTHX_ crypto_kdf_hkdf_sha512_KEYBYTES, flags);
40 }
41 #else
42 croak("HKDF not supported by this version of libsodium");
43 #endif
44  
45 OUTPUT:
46 RETVAL
47  
48 SV * hkdf_sha256_extract( \
49 SV * ikm, \
50 SV * salt = &PL_sv_undef, \
51 SV * flags = &PL_sv_undef \
52 )
53  
54 ALIAS:
55 hkdf_sha512_extract = 1
56  
57 PREINIT:
58 22 protmem *ikm_pm = NULL, *prk_pm;
59 22 unsigned char *salt_buf = NULL, *ikm_buf;
60 22 STRLEN prk_len, salt_len = 0, ikm_len;
61 22 ▶ unsigned int prk_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int prk_flags = g_protmem_default_flags_key; 8 14 22
62 int (*func)(unsigned char *,
63 const unsigned char *, size_t, const unsigned char *, size_t);
64  
65 CODE:
66 #ifdef SODIUM_HAS_HKDF
67 22 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 22 22
68 0 prk_flags = SvUV_nomg(flags);
69  
70 22 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 11 11 22
71 11 case 1:
72 11 prk_len = crypto_kdf_hkdf_sha512_KEYBYTES;
73 11 func = crypto_kdf_hkdf_sha512_extract;
74 11 break;
75 11 default:
76 11 prk_len = crypto_kdf_hkdf_sha256_KEYBYTES;
77 11 func = crypto_kdf_hkdf_sha256_extract;
78 }
79  
80 22 SvGETMAGIC(salt);
81 22 ▶ if (SvOK(salt))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(salt)) 14 8 22
82 14 salt_buf = (unsigned char *)SvPVbyte_nomg(salt, salt_len);
83  
84 22 ▶ if (sv_derived_from(ikm, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(ikm, MEMVAULT_CLASS)) { 22 0 22
85 22 ikm_pm = protmem_get(aTHX_ ikm, MEMVAULT_CLASS);
86 22 ikm_buf = ikm_pm->pm_ptr;
87 22 ikm_len = ikm_pm->size;
88 }
89 else
90 0 ikm_buf = (unsigned char *)SvPVbyte(ikm, ikm_len);
91  
92 22 prk_pm = protmem_init(aTHX_ prk_len, prk_flags);
93 22 ▶ if (prk_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (prk_pm == NULL) 0 22 22
94 0 croak("hkdf_extract: Failed to allocate protmem");
95  
96 22 ▶ if (ikm_pm && protmem_grant(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (ikm_pm && protmem_grant(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 22 0 22
if (ikm_pm && protmem_grant(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 22 22
97 0 protmem_free(aTHX_ prk_pm);
98 0 croak("hkdf_extract: Failed to grant ikm protmem RO");
99 }
100  
101 22 func(prk_pm->pm_ptr, salt_buf, salt_len, ikm_buf, ikm_len);
102  
103 22 ▶ if (ikm_pm && protmem_release(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (ikm_pm && protmem_release(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 22 0 22
if (ikm_pm && protmem_release(aTHX_ ikm_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 22 22
104 0 protmem_free(aTHX_ prk_pm);
105 0 croak("hkdf_extract: Failed to release ikm protmem RO");
106 }
107  
108 22 ▶ if (protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 22 22
109 0 protmem_free(aTHX_ prk_pm);
110 0 croak("hkdf_extract: Failed to release prk protmem RW");
111 }
112  
113 22 RETVAL = protmem_to_sv(aTHX_ prk_pm, MEMVAULT_CLASS);
114 #else
115 croak("hkdf_extract: HKDF not supported by this version of libsodium");
116 #endif
117  
118 OUTPUT:
119 RETVAL
120  
121 SV * hkdf_sha256_expand( \
122 SV * prk, \
123 STRLEN out_len, \
124 SV * ctx = &PL_sv_undef, \
125 SV * flags = &PL_sv_undef \
126 )
127  
128 ALIAS:
129 hkdf_sha512_expand = 1
130  
131 PREINIT:
132 24 protmem *out_pm, *prk_pm = NULL;
133 24 unsigned char *ctx_buf = NULL, *prk_buf;
134 24 STRLEN out_max_len, ctx_len = 0, prk_len, prk_req_len;
135 unsigned int out_flags;
136 int (*func)(unsigned char *, size_t, const char *, size_t, const unsigned char *);
137  
138 CODE:
139 #ifdef SODIUM_HAS_HKDF
140 24 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 12 12 24
141 12 case 1:
142 12 out_max_len = crypto_kdf_hkdf_sha512_BYTES_MAX;
143 12 prk_req_len = crypto_kdf_hkdf_sha512_KEYBYTES;
144 12 func = crypto_kdf_hkdf_sha512_expand;
145 12 break;
146 12 default:
147 12 out_max_len = crypto_kdf_hkdf_sha256_BYTES_MAX;
148 12 prk_req_len = crypto_kdf_hkdf_sha256_KEYBYTES;
149 12 func = crypto_kdf_hkdf_sha256_expand;
150 }
151  
152 24 ▶ if (out_len > out_max_len)
Branch: 1 branch
BranchTrueFalseTotal
if (out_len > out_max_len) 0 24 24
153 0 croak("hkdf_expand: Invalid expand output length (too large)");
154  
155 24 SvGETMAGIC(ctx);
156 24 ▶ if (SvOK(ctx))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(ctx)) 12 12 24
157 12 ctx_buf = (unsigned char *)SvPVbyte_nomg(ctx, ctx_len);
158  
159 24 ▶ if (sv_derived_from(prk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(prk, MEMVAULT_CLASS)) { 24 0 24
160 24 prk_pm = protmem_get(aTHX_ prk, MEMVAULT_CLASS);
161 24 prk_buf = prk_pm->pm_ptr;
162 24 prk_len = prk_pm->size;
163 }
164 else
165 0 prk_buf = (unsigned char *)SvPVbyte(prk, prk_len);
166  
167 24 ▶ if (prk_len != prk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (prk_len != prk_req_len) 0 24 24
168 0 croak("hkdf_expand: Invalid key length");
169  
170 24 SvGETMAGIC(flags);
171 24 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 24 24
172 0 out_flags = SvUV_nomg(flags);
173 24 ▶ else if (prk_pm)
Branch: 1 branch
BranchTrueFalseTotal
else if (prk_pm) 24 0 24
174 24 out_flags = prk_pm->flags;
175 else
176 0 out_flags = g_protmem_default_flags_key;
177  
178 24 out_pm = protmem_init(aTHX_ out_len, out_flags);
179 24 ▶ if (out_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (out_pm == NULL) 0 24 24
180 0 croak("hkdf_expand: Failed to allocate protmem");
181  
182 24 ▶ if (prk_pm && protmem_grant(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (prk_pm && protmem_grant(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 24 0 24
if (prk_pm && protmem_grant(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 24 24
183 0 protmem_free(aTHX_ out_pm);
184 0 croak("hkdf_expand: Failed to grant prk protmem RO");
185 }
186  
187 24 func(out_pm->pm_ptr, out_len, (char *)ctx_buf, ctx_len, prk_buf);
188  
189 24 ▶ if (prk_pm && protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (prk_pm && protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 24 0 24
if (prk_pm && protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 24 24
190 0 protmem_free(aTHX_ out_pm);
191 0 croak("hkdf_expand: Failed to release prk protmem RO");
192 }
193  
194 24 ▶ if (protmem_release(aTHX_ out_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ out_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 24 24
195 0 protmem_free(aTHX_ out_pm);
196 0 croak("hkdf_expand: Failed to release protmem RW");
197 }
198  
199 24 RETVAL = protmem_to_sv(aTHX_ out_pm, MEMVAULT_CLASS);
200 #else
201 croak("hkdf_expand: HKDF not supported by this version of libsodium");
202 #endif
203  
204 OUTPUT:
205 RETVAL
206  
207 SV * hkdf_sha256_extract_init(SV * salt = &PL_sv_undef, SV * flags = &PL_sv_undef)
208  
209 ALIAS:
210 hkdf_sha512_extract_init = 1
211  
212 PREINIT:
213 protmem *state_pm;
214 10 unsigned char *salt_buf = NULL;
215 10 STRLEN salt_len = 0;
216 10 ▶ unsigned int state_flags = g_protmem_default_flags_state;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int state_flags = g_protmem_default_flags_state; 4 6 10
217  
218 CODE:
219 #ifdef SODIUM_HAS_HKDF
220 10 SvGETMAGIC(salt);
221 10 ▶ if (SvOK(salt))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(salt)) 6 4 10
222 6 salt_buf = (unsigned char *)SvPVbyte_nomg(salt, salt_len);
223  
224 10 SvGETMAGIC(flags);
225 10 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 10 10
226 0 state_flags = SvUV_nomg(flags);
227  
228 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
229 5 case 1:
230 5 state_pm = protmem_init(aTHX_ sizeof(crypto_kdf_hkdf_sha512_state), state_flags);
231 5 ▶ if (state_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (state_pm == NULL) 0 5 5
232 0 croak("hkdf_extract_init: Failed to allocate state protmem");
233 5 crypto_kdf_hkdf_sha512_extract_init(state_pm->pm_ptr, salt_buf, salt_len);
234 5 break;
235 5 default:
236 5 state_pm = protmem_init(aTHX_ sizeof(crypto_kdf_hkdf_sha256_state), state_flags);
237 5 ▶ if (state_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (state_pm == NULL) 0 5 5
238 0 croak("hkdf_extract_init: Failed to allocate state protmem");
239 5 crypto_kdf_hkdf_sha256_extract_init(state_pm->pm_ptr, salt_buf, salt_len);
240 }
241  
242 10 ▶ if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 10 10
243 0 protmem_free(aTHX_ state_pm);
244 0 croak("hkdf_extract_init: Failed to release state protmem RW");
245 }
246  
247 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
248 5 case 1:
249 5 RETVAL = protmem_to_sv(aTHX_ state_pm, "Crypt::Sodium::XS::hkdf::sha512_multi");
250 5 break;
251 5 default:
252 5 RETVAL = protmem_to_sv(aTHX_ state_pm, "Crypt::Sodium::XS::hkdf::sha256_multi");
253 }
254 #else
255 croak("HKDF not supported by this version of libsodium");
256 #endif
257  
258 OUTPUT:
259 RETVAL
260  
261 MODULE = Crypt::Sodium::XS::hkdf PACKAGE = Crypt::Sodium::XS::hkdf::sha256_multi
262  
263 #ifdef SODIUM_HAS_HKDF
264  
265 void DESTROY(SV * self)
266  
267 ALIAS:
268 Crypt::Sodium::XS::hkdf::sha512_multi::DESTROY = 1
269  
270 PREINIT:
271 protmem *state_pm;
272  
273 CODE:
274 10 ▶ switch (ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch (ix) { 5 5 10
275 5 case 1:
276 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha512_multi");
277 5 break;
278 5 default:
279 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha256_multi");
280 }
281 10 protmem_free(aTHX_ state_pm);
282  
283 SV * clone(SV * self)
284  
285 ALIAS: Crypt::Sodium::XS::hkdf::sha512_multi::clone = 1
286  
287 CODE:
288 0 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 0 0 0
289 0 case 1:
290 0 RETVAL = protmem_clone_sv(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha512_multi");
291 0 break;
292 0 default:
293 0 RETVAL = protmem_clone_sv(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha256_multi");
294 }
295  
296 OUTPUT:
297 RETVAL
298  
299 SV * final(SV * self, SV * flags = &PL_sv_undef)
300  
301 ALIAS:
302 Crypt::Sodium::XS::hkdf::sha512_multi::final = 1
303  
304 PREINIT:
305 protmem *state_pm, *prk_pm;
306 10 ▶ unsigned int prk_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int prk_flags = g_protmem_default_flags_key; 10 0 10
307  
308 CODE:
309  
310 10 SvGETMAGIC(flags);
311 10 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 10 10
312 0 prk_flags = SvUV_nomg(flags);
313  
314 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
315 5 case 1:
316 5 prk_pm = protmem_init(aTHX_ crypto_kdf_hkdf_sha512_KEYBYTES, prk_flags);
317 5 ▶ if (prk_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (prk_pm == NULL) 0 5 5
318 0 croak("final: Failed to allocate protmem");
319  
320 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha512_multi");
321 5 break;
322 5 default:
323 5 prk_pm = protmem_init(aTHX_ crypto_kdf_hkdf_sha256_KEYBYTES, prk_flags);
324 5 ▶ if (prk_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (prk_pm == NULL) 0 5 5
325 0 croak("final: Failed to allocate protmem");
326  
327 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha256_multi");
328 }
329 10 ▶ if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 10 10
330 0 protmem_free(aTHX_ prk_pm);
331 0 croak("final: Failed to grant state protmem RW");
332 }
333  
334 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
335 5 case 1:
336 5 crypto_kdf_hkdf_sha512_extract_final(state_pm->pm_ptr, prk_pm->pm_ptr);
337 5 break;
338 5 default:
339 5 crypto_kdf_hkdf_sha256_extract_final(state_pm->pm_ptr, prk_pm->pm_ptr);
340 }
341  
342 10 ▶ if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 10 10
343 0 protmem_free(aTHX_ prk_pm);
344 0 croak("final: Failed to release state protmem RW");
345 }
346  
347 10 ▶ if (protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ prk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 10 10
348 0 protmem_free(aTHX_ prk_pm);
349 0 croak("final: Failed to release prk protmem RW");
350 }
351  
352 10 RETVAL = protmem_to_sv(aTHX_ prk_pm, MEMVAULT_CLASS);
353  
354 OUTPUT:
355 RETVAL
356  
357 SV * update(SV * self, ...)
358  
359 ALIAS:
360 Crypt::Sodium::XS::hkdf::sha512_multi::update = 1
361  
362 PREINIT:
363 10 ▶ protmem *state_pm, *msg_pm = NULL;
Branch: 1 branch
BranchTrueFalseTotal
protmem *state_pm, *msg_pm = NULL; 5 5 10
364 unsigned char *msg_buf;
365 STRLEN msg_len;
366 I32 i;
367  
368 PPCODE:
369 PERL_UNUSED_VAR(RETVAL);
370 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
371 5 case 1:
372 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha512_multi");
373 5 break;
374 5 default:
375 5 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::hkdf::sha256_multi");
376 }
377 10 ▶ if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_grant(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) 0 10 10
378 0 croak("update: Failed to grant state protmem RW");
379  
380 20 ▶ for (i = 1; i < items; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 1; i < items; i++) { 10 10 20
381 10 ▶ if (sv_derived_from(ST(i), MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(ST(i), MEMVAULT_CLASS)) { 10 0 10
382 10 msg_pm = protmem_get(aTHX_ ST(i), MEMVAULT_CLASS);
383 10 msg_buf = msg_pm->pm_ptr;
384 10 msg_len = msg_pm->size;
385 }
386 else
387 0 msg_buf = (unsigned char *)SvPVbyte(ST(i), msg_len);
388  
389 10 ▶ if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 10 0 10
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 10 10
390 0 protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW);
391 0 croak("update: Failed to grant msg protmem RO");
392 }
393  
394 10 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 5 5 10
395 5 case 1:
396 5 crypto_kdf_hkdf_sha512_extract_update(state_pm->pm_ptr, msg_buf, msg_len);
397 5 break;
398 5 default:
399 5 crypto_kdf_hkdf_sha256_extract_update(state_pm->pm_ptr, msg_buf, msg_len);
400 }
401  
402 10 ▶ if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 10 0 10
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 10 10
403 0 protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW);
404 0 croak("update: Failed to release msg protmem RO");
405 }
406  
407 10 msg_pm = NULL;
408 }
409  
410 10 ▶ if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) 0 10 10
411 0 croak("update: Failed to release state protmem RW");
412  
413 10 XSRETURN(1);
414  
415 #endif
« xs/scalarmult.xs ↑ Summary xs/kdf.xs »