xs/box.xs

filter: Statementstmt 74.8% 481 / 643 Branchbran 46.1% 133 / 288 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 65.9% 614 / 931 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/xof.xs ↑ Summary XS.xs »
1 =for documentation
2  
3 same as with secretbox, box does not have separate functions for
4 curve25519xsalsa20poly1305 _easy, _detached, _open_easy, _open_detached, nor
5 the associated afternm functions. it is the default algorithm for them.
6 aliases are still provided, and just fall through to the defaults.
7  
8 also of note, no curve25519xsalsa20poly1305 seal interfaces. same deal.
9  
10 =cut
11  
12 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::box
13  
14 void _define_constants()
15 PREINIT:
16 1 HV *stash = gv_stashpv("Crypt::Sodium::XS::box", 0);
17  
18 PPCODE:
19 1 newCONSTSUB(stash, "box_BEFORENMBYTES",
20 newSVuv(crypto_box_BEFORENMBYTES));
21 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_BEFORENMBYTES",
22 newSVuv(crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES));
23 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_BEFORENMBYTES",
24 newSVuv(crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES));
25 1 newCONSTSUB(stash, "box_MACBYTES",
26 newSVuv(crypto_box_MACBYTES));
27 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_MACBYTES",
28 newSVuv(crypto_box_curve25519xchacha20poly1305_MACBYTES));
29 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_MACBYTES",
30 newSVuv(crypto_box_curve25519xsalsa20poly1305_MACBYTES));
31 1 newCONSTSUB(stash, "box_MESSAGEBYTES_MAX",
32 newSVuv(crypto_box_MESSAGEBYTES_MAX));
33 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX",
34 newSVuv(crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX));
35 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX",
36 newSVuv(crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX));
37 1 newCONSTSUB(stash, "box_NONCEBYTES",
38 newSVuv(crypto_box_NONCEBYTES));
39 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_NONCEBYTES",
40 newSVuv(crypto_box_curve25519xchacha20poly1305_NONCEBYTES));
41 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_NONCEBYTES",
42 newSVuv(crypto_box_curve25519xsalsa20poly1305_NONCEBYTES));
43 1 newCONSTSUB(stash, "box_PUBLICKEYBYTES",
44 newSVuv(crypto_box_PUBLICKEYBYTES));
45 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_PUBLICKEYBYTES",
46 newSVuv(crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES));
47 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_PUBLICKEYBYTES",
48 newSVuv(crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES));
49 1 newCONSTSUB(stash, "box_SEALBYTES",
50 newSVuv(crypto_box_SEALBYTES));
51 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_SEALBYTES",
52 newSVuv(crypto_box_curve25519xchacha20poly1305_SEALBYTES));
53 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_SEALBYTES",
54 newSVuv(crypto_box_SEALBYTES));
55 1 newCONSTSUB(stash, "box_SECRETKEYBYTES",
56 newSVuv(crypto_box_SECRETKEYBYTES));
57 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_SECRETKEYBYTES",
58 newSVuv(crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES));
59 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_SECRETKEYBYTES",
60 newSVuv(crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES));
61 1 newCONSTSUB(stash, "box_SEEDBYTES",
62 newSVuv(crypto_box_SEEDBYTES));
63 1 newCONSTSUB(stash, "box_curve25519xchacha20poly1305_SEEDBYTES",
64 newSVuv(crypto_box_curve25519xchacha20poly1305_SEEDBYTES));
65 1 newCONSTSUB(stash, "box_curve25519xsalsa20poly1305_SEEDBYTES",
66 newSVuv(crypto_box_curve25519xsalsa20poly1305_SEEDBYTES));
67 1 newCONSTSUB(stash, "box_PRIMITIVE", newSVpvs(crypto_box_PRIMITIVE));
68  
69 SV * box_beforenm(SV * pk, SV * sk, SV * flags = &PL_sv_undef)
70  
71 ALIAS:
72 box_curve25519xchacha20poly1305_beforenm = 1
73 box_curve25519xsalsa20poly1305_beforenm = 2
74  
75 PREINIT:
76 12 protmem *sk_pm = NULL, *precalc_pm;
77 unsigned char *pk_buf, *sk_buf;
78 STRLEN pk_len, sk_len, precalc_len, pk_req_len, sk_req_len;
79 12 ▶ unsigned int precalc_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int precalc_flags = g_protmem_default_flags_key; 12 0 12
80 int ret;
81 int (*func)(unsigned char *, const unsigned char *, const unsigned char *);
82  
83 CODE:
84 12 switch(ix) {
85 4 case 1:
86 4 precalc_len = crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES;
87 4 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
88 4 sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
89 4 func = crypto_box_curve25519xchacha20poly1305_beforenm;
90 4 break;
91 4 case 2:
92 4 precalc_len = crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES;
93 4 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
94 4 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
95 4 func = crypto_box_curve25519xsalsa20poly1305_beforenm;
96 4 break;
97 4 default:
98 4 precalc_len = crypto_box_BEFORENMBYTES;
99 4 pk_req_len = crypto_box_PUBLICKEYBYTES;
100 4 sk_req_len = crypto_box_SECRETKEYBYTES;
101 4 func = crypto_box_beforenm;
102 }
103  
104 12 SvGETMAGIC(flags);
105 12 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 12 12
106 0 precalc_flags = SvUV_nomg(flags);
107  
108 12 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
109 12 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 12 12
110 0 croak("box_before_nm: Invalid public key length %lu", pk_len);
111  
112 12 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 12 0 12
113 12 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
114 12 sk_buf = sk_pm->pm_ptr;
115 12 sk_len = sk_pm->size;
116 }
117 else
118 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
119 12 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 12 12
120 0 croak("box_before_nm: Invalid secret key length %lu", sk_len);
121  
122 12 precalc_pm = protmem_init(aTHX_ precalc_len, precalc_flags);
123 12 ▶ if (precalc_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (precalc_pm == NULL) 0 12 12
124 0 croak("box_before_nm: Failed to allocate precalc protmem");
125  
126 12 ▶ if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 12 0 12
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
127 0 protmem_free(aTHX_ precalc_pm);
128 0 croak("box_before_nm: Failed to grant sk protmem RO");
129 }
130  
131 12 ret = func(precalc_pm->pm_ptr, pk_buf, sk_buf);
132  
133 12 ▶ if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 12 0 12
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
134 0 protmem_free(aTHX_ precalc_pm);
135 0 croak("box_before_nm: Failed to release sk protmem RO");
136 }
137  
138 12 ▶ if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 12 12
139 0 protmem_free(aTHX_ precalc_pm);
140 0 croak("box_before_nm: Failed to release precalc protmem RW");
141 }
142  
143 12 ▶ if (ret != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (ret != 0) { 0 12 12
144 0 protmem_free(aTHX_ precalc_pm);
145 0 croak("box_before_nm: Failed to create key (invalid public key?)");
146 }
147  
148 12 switch(ix) {
149 4 case 1:
150 4 RETVAL = protmem_to_sv(aTHX_ precalc_pm, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
151 4 break;
152 4 case 2:
153 4 RETVAL = protmem_to_sv(aTHX_ precalc_pm, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
154 4 break;
155 4 default:
156 4 RETVAL = protmem_to_sv(aTHX_ precalc_pm, "Crypt::Sodium::XS::box::precalc");
157 }
158  
159 OUTPUT:
160 RETVAL
161  
162 SV * box_decrypt( \
163 SV * ciphertext, \
164 SV * nonce, \
165 SV * pk, \
166 SV * sk, \
167 SV * flags = &PL_sv_undef \
168 )
169  
170 ALIAS:
171 box_curve25519xchacha20poly1305_decrypt = 1
172 box_curve25519xsalsa20poly1305_decrypt = 2
173  
174 PREINIT:
175 6 protmem *msg_pm, *sk_pm = NULL;
176 unsigned char *ct_buf, *nonce_buf, *sk_buf, *pk_buf;
177 STRLEN ct_len, nonce_len, sk_len, pk_len;
178 STRLEN nonce_req_len, sk_req_len, pk_req_len, mac_len;
179 6 ▶ unsigned int msg_flags = g_protmem_default_flags_decrypt;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int msg_flags = g_protmem_default_flags_decrypt; 6 0 6
180 int ret;
181 int (*func)(unsigned char *, const unsigned char *,
182 unsigned long long, const unsigned char *,
183 const unsigned char *, const unsigned char *);
184  
185 CODE:
186 6 switch(ix) {
187 2 case 1:
188 2 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
189 2 sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
190 2 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
191 2 mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
192 2 func = crypto_box_curve25519xchacha20poly1305_open_easy;
193 2 break;
194 2 case 2:
195 /* no separate NONCEBYTES MACBYTES or function */
196 2 nonce_req_len = crypto_box_NONCEBYTES;
197 2 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
198 2 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
199 2 mac_len = crypto_box_MACBYTES;
200 2 func = crypto_box_open_easy;
201 2 break;
202 2 default:
203 2 nonce_req_len = crypto_box_NONCEBYTES;
204 2 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
205 2 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
206 2 mac_len = crypto_box_MACBYTES;
207 2 func = crypto_box_open_easy;
208 }
209  
210 6 SvGETMAGIC(flags);
211 6 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 6 6
212 0 msg_flags = SvUV_nomg(flags);
213  
214 6 ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len);
215 6 ▶ if (ct_len < mac_len)
Branch: 1 branch
BranchTrueFalseTotal
if (ct_len < mac_len) 0 6 6
216 0 croak("box_decrypt: Invalid ciphertext length (too short)");
217  
218 6 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
219 6 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 6 6
220 0 croak("box_decrypt: Invalid nonce length %lu", nonce_len);
221  
222 6 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
223 6 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 6 6
224 0 croak("box_decrypt: Invalid public key length %lu", pk_len);
225  
226 6 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 6 0 6
227 6 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
228 6 sk_buf = sk_pm->pm_ptr;
229 6 sk_len = sk_pm->size;
230 }
231 else
232 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
233 6 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 6 6
234 0 croak("box_decrypt: Invalid key length %lu", sk_len);
235  
236 6 msg_pm = protmem_init(aTHX_ ct_len - mac_len, msg_flags);
237 6 ▶ if (msg_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm == NULL) 0 6 6
238 0 croak("box_decrypt: Failed to allocate protmem");
239  
240 6 ▶ if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
241 0 protmem_free(aTHX_ msg_pm);
242 0 croak("box_decrypt: Failed to grant sk protmem RO");
243 }
244  
245 6 ret = func(msg_pm->pm_ptr, ct_buf, ct_len, nonce_buf, pk_buf, sk_buf);
246  
247 6 ▶ if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
248 0 protmem_free(aTHX_ msg_pm);
249 0 croak("box_decrypt: Failed to release sk protmem RO");
250 }
251  
252 6 ▶ if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 6 6
253 0 protmem_free(aTHX_ msg_pm);
254 0 croak("box_decrypt: Failed to release msg protmem RW");
255 }
256  
257 6 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 6 0 6
258 6 RETVAL = protmem_to_sv(aTHX_ msg_pm, MEMVAULT_CLASS);
259 else {
260 0 protmem_free(aTHX_ msg_pm);
261 0 croak("box_decrypt: Message forged");
262 }
263  
264 OUTPUT:
265 RETVAL
266  
267 SV * box_decrypt_detached( \
268 SV * ciphertext, \
269 SV * mac, \
270 SV * nonce, \
271 SV * pk, \
272 SV * sk, \
273 SV * flags = &PL_sv_undef \
274 )
275  
276 ALIAS:
277 box_curve25519xchacha20poly1305_decrypt_detached = 1
278 box_curve25519xsalsa20poly1305_decrypt_detached = 2
279  
280 PREINIT:
281 6 protmem *msg_pm, *sk_pm = NULL;
282 unsigned char *ct_buf, *mac_buf, *nonce_buf, *sk_buf, *pk_buf;
283 STRLEN ct_len, mac_len, nonce_len, sk_len, pk_len;
284 STRLEN mac_req_len, nonce_req_len, sk_req_len, pk_req_len;
285 6 ▶ unsigned int msg_flags = g_protmem_default_flags_decrypt;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int msg_flags = g_protmem_default_flags_decrypt; 6 0 6
286 int ret;
287 int (*func)(unsigned char *, const unsigned char *,
288 const unsigned char *, unsigned long long,
289 const unsigned char *,
290 const unsigned char *, const unsigned char *);
291  
292 CODE:
293 6 switch(ix) {
294 2 case 1:
295 2 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
296 2 sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
297 2 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
298 2 mac_req_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
299 2 func = crypto_box_curve25519xchacha20poly1305_open_detached;
300 2 break;
301 2 case 2:
302 /* no separate NONCEBYTES MACBYTES or function */
303 2 nonce_req_len = crypto_box_NONCEBYTES;
304 2 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
305 2 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
306 2 mac_req_len = crypto_box_MACBYTES;
307 2 func = crypto_box_open_detached;
308 2 break;
309 2 default:
310 2 nonce_req_len = crypto_box_NONCEBYTES;
311 2 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
312 2 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
313 2 mac_req_len = crypto_box_MACBYTES;
314 2 func = crypto_box_open_detached;
315 }
316  
317 6 SvGETMAGIC(flags);
318 6 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 6 6
319 0 msg_flags = SvUV_nomg(flags);
320  
321 6 ▶ ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len);
Branch: 1 branch
BranchTrueFalseTotal
ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len); 6 0 6
322  
323 6 mac_buf = (unsigned char *)SvPVbyte(mac, mac_len);
324 6 ▶ if (mac_len != mac_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (mac_len != mac_req_len) 0 6 6
325 0 croak("box_decrypt_detached: Invalid mac length: %lu", mac_len);
326  
327 6 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
328 6 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 6 6
329 0 croak("box_decrypt_detached: Invalid nonce");
330  
331 6 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
332 6 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 6 6
333 0 croak("box_decrypt_detached: Invalid public key length %lu", pk_len);
334  
335 6 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 6 0 6
336 6 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
337 6 sk_buf = sk_pm->pm_ptr;
338 6 sk_len = sk_pm->size;
339 }
340 else
341 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
342 6 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 6 6
343 0 croak("box_decrypt_detached: Invalid secret key length %lu", sk_len);
344  
345 6 msg_pm = protmem_init(aTHX_ ct_len, msg_flags);
346 6 ▶ if (msg_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm == NULL) 0 6 6
347 0 croak("box_decrypt_detached: Failed to allocate protmem");
348  
349 6 ▶ if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
350 0 protmem_free(aTHX_ msg_pm);
351 0 croak("box_decrypt_detached: Failed to grant sk protmem RO");
352 }
353  
354 6 ret = func(msg_pm->pm_ptr, ct_buf, mac_buf, ct_len, nonce_buf, pk_buf, sk_buf);
355  
356 6 ▶ if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
357 0 protmem_free(aTHX_ msg_pm);
358 0 croak("box_decrypt_detached: Failed to release sk protmem RO");
359 }
360  
361 6 ▶ if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 6 6
362 0 protmem_free(aTHX_ msg_pm);
363 0 croak("box_decrypt_detached: Failed to release msg protmem RW");
364 }
365  
366 6 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 6 0 6
367 6 RETVAL = protmem_to_sv(aTHX_ msg_pm, MEMVAULT_CLASS);
368 else {
369 0 protmem_free(aTHX_ msg_pm);
370 0 croak("box_decrypt_detached: Message forged");
371 }
372  
373 OUTPUT:
374 RETVAL
375  
376 void box_encrypt(SV * msg, SV * nonce, SV * pk, SV * sk)
377  
378 ALIAS:
379 box_encrypt_detached = 1
380 box_curve25519xchacha20poly1305_encrypt = 2
381 box_curve25519xchacha20poly1305_encrypt_detached = 3
382 box_curve25519xsalsa20poly1305_encrypt = 4
383 box_curve25519xsalsa20poly1305_encrypt_detached = 5
384  
385 PREINIT:
386 12 protmem *msg_pm = NULL, *sk_pm = NULL;
387 12 SV *ct, *mac = NULL;
388 unsigned char *msg_buf, *nonce_buf, *pk_buf, *sk_buf, *ct_buf, *mac_buf;
389 STRLEN msg_len, nonce_len, pk_len, sk_len, mac_len;
390 STRLEN nonce_req_len, pk_req_len, sk_req_len;
391 int (*detached_func)(unsigned char *, unsigned char *,
392 const unsigned char *, unsigned long long,
393 const unsigned char *, const unsigned char *,
394 const unsigned char *);
395 int (*easy_func)(unsigned char *, const unsigned char *,
396 unsigned long long, const unsigned char *,
397 const unsigned char *, const unsigned char *);
398  
399 PPCODE:
400 12 switch(ix) {
401 4 case 2: /* fallthrough */
402 case 3:
403 4 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
404 4 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
405 4 sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
406 4 mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
407 4 detached_func = crypto_box_curve25519xchacha20poly1305_detached;
408 4 easy_func = crypto_box_curve25519xchacha20poly1305_easy;
409 4 break;
410 4 case 4: /* fallthrough */
411 case 5:
412 4 nonce_req_len = crypto_box_curve25519xsalsa20poly1305_NONCEBYTES;
413 4 pk_req_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
414 4 sk_req_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
415 4 mac_len = crypto_box_curve25519xsalsa20poly1305_MACBYTES;
416 /* no separate functions */
417 4 detached_func = crypto_box_detached;
418 4 easy_func = crypto_box_easy;
419 4 break;
420 4 case 1: /* fallthrough */
421 default:
422 4 nonce_req_len = crypto_box_NONCEBYTES;
423 4 pk_req_len = crypto_box_PUBLICKEYBYTES;
424 4 sk_req_len = crypto_box_SECRETKEYBYTES;
425 4 mac_len = crypto_box_MACBYTES;
426 4 detached_func = crypto_box_detached;
427 4 easy_func = crypto_box_easy;
428 }
429  
430 12 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 12 12
431 0 msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
432 0 msg_buf = msg_pm->pm_ptr;
433 0 msg_len = msg_pm->size;
434 }
435 else
436 12 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
437  
438 12 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
439 12 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 12 12
440 0 croak("box_encrypt: Invalid nonce length %lu", nonce_len);
441  
442 12 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 12 0 12
443 12 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
444 12 sk_buf = sk_pm->pm_ptr;
445 12 sk_len = sk_pm->size;
446 }
447 else
448 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
449 12 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 12 12
450 0 croak("box_encrypt: Invalid secret key length %lu", sk_len);
451  
452 12 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
453 12 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 12 12
454 0 croak("box_encrypt: Invalid public key length %lu", pk_len);
455  
456 12 ▶ if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 12 0 12
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 12 12
457 0 croak("box_encrypt: Failed to grant sk protmem RO");
458 12 ▶ 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) { 0 12 12
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
459 0 ▶ if (sk_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm) 0 0 0
460 0 protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO);
461 0 croak("box_encrypt: Failed to grant msg protmem RO");
462 }
463  
464 /* NB: odd aliases are _detached, even are combined */
465 12 ▶ if (ix & 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (ix & 1) { 6 6 12
466 6 Newx(mac_buf, mac_len + 1, unsigned char);
467 6 ▶ if (mac_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (mac_buf == NULL) { 0 6 6
468 0 ▶ if (sk_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm) 0 0 0
469 0 protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO);
470 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
471 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
472 0 croak("box_encrypt: Failed to allocate memory");
473 }
474 6 mac_buf[mac_len] = '\0';
475 6 Newx(ct_buf, msg_len + 1, unsigned char);
476 6 ▶ if (ct_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (ct_buf == NULL) { 0 6 6
477 0 ▶ if (sk_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm) 0 0 0
478 0 protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO);
479 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
480 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
481 0 Safefree(mac_buf);
482 0 croak("box_encrypt: Failed to allocate memory");
483 }
484 6 ct_buf[msg_len] = '\0';
485  
486 6 detached_func(ct_buf, mac_buf, msg_buf, msg_len, nonce_buf, pk_buf, sk_buf);
487  
488 6 mac = newSV(0);
489 6 sv_usepvn_flags(mac, (char *)mac_buf, mac_len, SV_HAS_TRAILING_NUL);
490 6 ct = newSV(0);
491 6 sv_usepvn_flags(ct, (char *)ct_buf, msg_len, SV_HAS_TRAILING_NUL);
492 }
493 else {
494 6 STRLEN ct_len = mac_len + msg_len;
495  
496 6 Newx(ct_buf, ct_len + 1, unsigned char);
497 6 ▶ if (ct_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (ct_buf == NULL) { 0 6 6
498 0 ▶ if (sk_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm) 0 0 0
499 0 protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO);
500 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
501 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
502 0 croak("box_encrypt: Failed to allocate memory");
503 }
504 6 ct_buf[mac_len + msg_len] = '\0';
505  
506 6 easy_func(ct_buf, msg_buf, msg_len, nonce_buf, pk_buf, sk_buf);
507  
508 6 ct = newSV(0);
509 6 sv_usepvn_flags(ct, (char *)ct_buf, mac_len + msg_len, SV_HAS_TRAILING_NUL);
510 }
511  
512 12 ▶ if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 12 0 12
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
513 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
514 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
515 0 croak("box_encrypt: Failed to release sk protmem RO");
516 }
517 12 ▶ 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)) 0 12 12
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO != 0)) 0 0 0
518 0 croak("box_encrypt: Failed to release msg protmem RO");
519  
520 12 ▶ mXPUSHs(ct);
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(ct); 0 12 12
521  
522 12 ▶ if (ix & 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (ix & 1) { 6 6 12
523 6 ▶ mXPUSHs(mac);
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(mac); 0 6 6
524 6 XSRETURN(2);
525 }
526  
527 6 XSRETURN(1);
528  
529 void box_keypair(SV * seed = &PL_sv_undef, SV * flags = &PL_sv_undef)
530  
531 ALIAS:
532 box_curve25519xchacha20poly1305_keypair = 1
533 box_curve25519xsalsa20poly1305_keypair = 2
534  
535 PREINIT:
536 24 protmem *seed_pm = NULL, *sk_pm;
537 SV *pk_sv;
538 unsigned char *pk_buf, *seed_buf;
539 STRLEN seed_len, seed_req_len, pk_len, sk_len;
540 24 ▶ unsigned int sk_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int sk_flags = g_protmem_default_flags_key; 12 12 24
541  
542 PPCODE:
543 24 SvGETMAGIC(flags);
544 24 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 24 24
545 0 sk_flags = SvUV_nomg(flags);
546  
547 24 switch(ix) {
548 8 case 1:
549 8 seed_req_len = crypto_box_curve25519xchacha20poly1305_SEEDBYTES;
550 8 pk_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
551 8 sk_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
552 8 break;
553 8 case 2:
554 8 seed_req_len = crypto_box_curve25519xsalsa20poly1305_SEEDBYTES;
555 8 pk_len = crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES;
556 8 sk_len = crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES;
557 8 break;
558 8 default:
559 8 seed_req_len = crypto_box_SEEDBYTES;
560 8 pk_len = crypto_box_PUBLICKEYBYTES;
561 8 sk_len = crypto_box_SECRETKEYBYTES;
562 }
563  
564 24 Newx(pk_buf, pk_len + 1, unsigned char);
565 24 ▶ if (pk_buf == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_buf == NULL) 0 24 24
566 0 croak("box_keypair: Failed to allocate memory");
567 24 pk_buf[pk_len] = '\0';
568  
569 24 SvGETMAGIC(seed);
570 24 ▶ if (!SvOK(seed)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(seed)) { 12 12 24
571 12 sk_pm = protmem_init(aTHX_ sk_len, sk_flags);
572 12 ▶ if (sk_pm == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm == NULL) { 0 12 12
573 0 Safefree(pk_buf);
574 0 croak("box_keypair: Failed to allocate protmem");
575 }
576 12 switch(ix) {
577 4 case 1:
578 4 crypto_box_curve25519xchacha20poly1305_keypair(pk_buf, sk_pm->pm_ptr);
579 4 break;
580 4 case 2:
581 4 crypto_box_curve25519xsalsa20poly1305_keypair(pk_buf, sk_pm->pm_ptr);
582 4 break;
583 4 default:
584 4 crypto_box_keypair(pk_buf, sk_pm->pm_ptr);
585 }
586 }
587 else {
588 /* from seed */
589 12 ▶ if (sv_derived_from(seed, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(seed, MEMVAULT_CLASS)) { 0 12 12
590 0 seed_pm = protmem_get(aTHX_ seed, MEMVAULT_CLASS);
591 0 seed_buf = seed_pm->pm_ptr;
592 0 seed_len = seed_pm->size;
593 }
594 else
595 12 seed_buf = (unsigned char *)SvPVbyte_nomg(seed, seed_len);
596 12 ▶ if (seed_len != seed_req_len) {
Branch: 1 branch
BranchTrueFalseTotal
if (seed_len != seed_req_len) { 0 12 12
597 0 Safefree(pk_buf);
598 0 croak("box_keypair: Invalid seed length: %lu", seed_len);
599 }
600 12 sk_pm = protmem_init(aTHX_ sk_len, sk_flags);
601 12 ▶ if (sk_pm == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (sk_pm == NULL) { 0 12 12
602 0 Safefree(pk_buf);
603 0 croak("box_keypair: Failed to allocate protmem");
604 }
605  
606 12 ▶ if (seed_pm && protmem_grant(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (seed_pm && protmem_grant(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
if (seed_pm && protmem_grant(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
607 0 protmem_free(aTHX_ sk_pm);
608 0 Safefree(pk_buf);
609 0 croak("box_keypair: Failed to grant seed protmem RO");
610 }
611  
612 12 switch(ix) {
613 4 case 1:
614 4 crypto_box_curve25519xchacha20poly1305_seed_keypair(
615 4 pk_buf, sk_pm->pm_ptr, seed_buf);
616 4 break;
617 4 case 2:
618 4 crypto_box_curve25519xsalsa20poly1305_seed_keypair(
619 4 pk_buf, sk_pm->pm_ptr, seed_buf);
620 4 break;
621 4 default:
622 4 crypto_box_seed_keypair(pk_buf, sk_pm->pm_ptr, seed_buf);
623 }
624  
625 12 ▶ if (seed_pm && protmem_release(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (seed_pm && protmem_release(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
if (seed_pm && protmem_release(aTHX_ seed_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
626 0 protmem_free(aTHX_ sk_pm);
627 0 Safefree(pk_buf);
628 0 croak("box_keypair: Failed to release seed protmem RO");
629 }
630 }
631  
632 24 ▶ if (protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 24 24
633 0 protmem_free(aTHX_ sk_pm);
634 0 croak("box_keypair: Failed to release sk protmem RW");
635 }
636  
637 24 pk_sv = newSV(0);
638 24 sv_usepvn_flags(pk_sv, (char *)pk_buf, pk_len, SV_HAS_TRAILING_NUL);
639 24 ▶ mXPUSHs(pk_sv);
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(pk_sv); 0 24 24
640 24 ▶ mXPUSHs(protmem_to_sv(aTHX_ sk_pm, MEMVAULT_CLASS));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(protmem_to_sv(aTHX_ sk_pm, MEMVAULT_CLASS)); 0 24 24
641 24 XSRETURN(2);
642  
643 SV * box_nonce(SV * base = &PL_sv_undef)
644  
645 ALIAS:
646 box_curve25519xchacha20poly1305_nonce = 1
647 box_curve25519xsalsa20poly1305_nonce = 2
648  
649 CODE:
650 6 switch(ix) {
651 2 case 1:
652 2 RETVAL = nonce_generate(aTHX_ crypto_box_curve25519xchacha20poly1305_NONCEBYTES, base);
653 2 break;
654 2 case 2:
655 2 RETVAL = nonce_generate(aTHX_ crypto_box_curve25519xsalsa20poly1305_NONCEBYTES, base);
656 2 break;
657 2 default:
658 2 RETVAL = nonce_generate(aTHX_ crypto_box_NONCEBYTES, base);
659 }
660  
661 OUTPUT:
662 RETVAL
663  
664 SV * box_seal_encrypt(SV * msg, SV * pk)
665  
666 ALIAS:
667 box_curve25519xchacha20poly1305_seal_encrypt = 1
668 box_curve25519xsalsa20poly1305_seal_encrypt = 2
669  
670 PREINIT:
671 6 ▶ protmem *msg_pm = NULL;
Branch: 1 branch
BranchTrueFalseTotal
protmem *msg_pm = NULL; 2 4 6
672 unsigned char *msg_buf, *pk_buf, *ct_buf;
673 STRLEN msg_len, pk_len, pk_req_len, seal_len, ct_len;
674 int (*func)(unsigned char *, const unsigned char *,
675 unsigned long long, const unsigned char *);
676  
677 CODE:
678 6 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 2 4 6
679 2 case 1:
680 2 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
681 2 seal_len = crypto_box_curve25519xchacha20poly1305_SEALBYTES;
682 2 func = crypto_box_curve25519xchacha20poly1305_seal;
683 2 break;
684 4 case 2: /* fallthrough */
685 default:
686 4 pk_req_len = crypto_box_PUBLICKEYBYTES;
687 4 seal_len = crypto_box_SEALBYTES;
688 4 func = crypto_box_seal;
689 }
690  
691 6 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
692 6 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 6 6
693 0 croak("box_seal_encrypt: Invalid public key length %lu", pk_len);
694  
695 6 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 6 6
696 0 msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
697 0 msg_buf = msg_pm->pm_ptr;
698 0 msg_len = msg_pm->size;
699 }
700 else
701 6 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
702 6 ct_len = seal_len + msg_len;
703  
704 6 Newx(ct_buf, ct_len + 1, unsigned char);
705 6 ▶ if (ct_buf == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (ct_buf == NULL) 0 6 6
706 0 croak("box_seal_encrypt: Failed to allocate memory");
707 6 ct_buf[ct_len] = '\0';
708  
709 6 ▶ 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) { 0 6 6
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
710 0 Safefree(ct_buf);
711 0 croak("box_seal_encrypt: Failed to grant msg protmem RO");
712 }
713  
714 6 func(ct_buf, msg_buf, msg_len, pk_buf);
715  
716 6 ▶ 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) { 0 6 6
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
717 0 Safefree(ct_buf);
718 0 croak("box_seal_encrypt: Failed to release msg protmem RO");
719 }
720  
721 6 RETVAL = newSV(0);
722 6 sv_usepvn_flags(RETVAL, (char *)ct_buf, ct_len, SV_HAS_TRAILING_NUL);
723  
724 OUTPUT:
725 RETVAL
726  
727 SV * box_seal_decrypt(SV * ciphertext, SV * pk, SV * sk, SV * flags = &PL_sv_undef)
728  
729 ALIAS:
730 box_curve25519xchacha20poly1305_seal_decrypt = 1
731 box_curve25519xsalsa20poly1305_seal_decrypt = 2
732  
733 PREINIT:
734 6 protmem *sk_pm = NULL, *msg_pm;
735 unsigned char *ct_buf, *pk_buf, *sk_buf;
736 STRLEN ct_len, pk_len, sk_len, pk_req_len, sk_req_len, seal_len;
737 6 ▶ unsigned int msg_flags = g_protmem_default_flags_decrypt;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int msg_flags = g_protmem_default_flags_decrypt; 6 0 6
738 int ret;
739 int (*func)(unsigned char *, const unsigned char *,
740 unsigned long long, const unsigned char *,
741 const unsigned char *);
742  
743 CODE:
744 6 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 2 4 6
745 2 case 1:
746 2 pk_req_len = crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
747 2 sk_req_len = crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
748 2 seal_len = crypto_box_curve25519xchacha20poly1305_SEALBYTES;
749 2 func = crypto_box_curve25519xchacha20poly1305_seal_open;
750 2 break;
751 4 case 2: /* fallthrough */
752 default:
753 4 pk_req_len = crypto_box_PUBLICKEYBYTES;
754 4 sk_req_len = crypto_box_SECRETKEYBYTES;
755 4 seal_len = crypto_box_SEALBYTES;
756 4 func = crypto_box_seal_open;
757 }
758  
759 6 SvGETMAGIC(flags);
760 6 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 6 6
761 0 msg_flags = SvUV_nomg(flags);
762  
763 6 ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len);
764 6 ▶ if (ct_len < seal_len)
Branch: 1 branch
BranchTrueFalseTotal
if (ct_len < seal_len) 0 6 6
765 0 croak("box_seal_decrypt: Invalid ciphertext length (too short)");
766  
767 6 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
768 6 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 6 6
769 0 croak("box_seal_decrypt: Invalid public key length %lu", pk_len);
770  
771 6 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 6 0 6
772 6 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
773 6 sk_buf = sk_pm->pm_ptr;
774 6 sk_len = sk_pm->size;
775 }
776 else
777 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
778 6 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 6 6
779 0 croak("box_seal_decrypt: Invalid secret key length %lu", sk_len);
780  
781 6 msg_pm = protmem_init(aTHX_ ct_len - seal_len, msg_flags);
782 6 ▶ if (msg_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm == NULL) 0 6 6
783 0 croak("box_seal_decrypt: Failed to allocate protmem");
784  
785 6 ▶ if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
786 0 protmem_free(aTHX_ msg_pm);
787 0 croak("box_seal_decrypt: Failed to grant sk protmem RO");
788 }
789  
790 6 ret = func(msg_pm->pm_ptr, ct_buf, ct_len, pk_buf, sk_buf);
791  
792 6 ▶ if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 0 6
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
793 0 protmem_free(aTHX_ msg_pm);
794 0 croak("box_seal_decrypt: Failed to release sk protmem RO");
795 }
796  
797 6 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 6 0 6
798 6 RETVAL = protmem_to_sv(aTHX_ msg_pm, MEMVAULT_CLASS);
799 else {
800 0 protmem_free(aTHX_ msg_pm);
801 0 croak("box_seal_decrypt: Message forged");
802 }
803  
804 OUTPUT:
805 RETVAL
806  
807 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::box::precalc
808  
809 void DESTROY(SV * self)
810  
811 ALIAS:
812 Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::DESTROY = 1
813 Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::DESTROY = 2
814  
815 PREINIT:
816 protmem *precalc_pm;
817  
818 PPCODE:
819 12 switch(ix) {
820 4 case 1:
821 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
822 4 break;
823 4 case 2:
824 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
825 4 break;
826 4 default:
827 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc");
828 }
829 12 protmem_free(aTHX_ precalc_pm);
830  
831 SV * decrypt(SV * self, SV * ciphertext, SV * nonce, SV * flags = &PL_sv_undef)
832  
833 ALIAS:
834 Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::decrypt = 1
835 Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::decrypt = 2
836  
837 PREINIT:
838 protmem *msg_pm, *precalc_pm;
839 unsigned char *ct_buf, *nonce_buf;
840 STRLEN ct_len, nonce_len, nonce_req_len, mac_len;
841 12 ▶ unsigned int msg_flags = g_protmem_default_flags_decrypt;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int msg_flags = g_protmem_default_flags_decrypt; 12 0 12
842 int ret;
843 int (*func)(unsigned char *, const unsigned char *,
844 unsigned long long, const unsigned char *,
845 const unsigned char *);
846  
847 CODE:
848 12 switch(ix) {
849 4 case 1:
850 4 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
851 4 mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
852 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
853 4 func = crypto_box_curve25519xchacha20poly1305_open_easy_afternm;
854 4 break;
855 4 case 2:
856 /* no separate NONCEBYTES MACBYTES or function */
857 4 nonce_req_len = crypto_box_NONCEBYTES;
858 4 mac_len = crypto_box_MACBYTES;
859 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
860 4 func = crypto_box_open_easy_afternm;
861 4 break;
862 4 default:
863 4 nonce_req_len = crypto_box_NONCEBYTES;
864 4 mac_len = crypto_box_MACBYTES;
865 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc");
866 4 func = crypto_box_open_easy_afternm;
867 }
868  
869 12 SvGETMAGIC(flags);
870 12 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 12 12
871 0 msg_flags = SvUV_nomg(flags);
872  
873 12 ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len);
874 12 ▶ if (ct_len < mac_len)
Branch: 1 branch
BranchTrueFalseTotal
if (ct_len < mac_len) 0 12 12
875 0 croak("decrypt: Invalid ciphertext length (too short)");
876  
877 12 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
878 12 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 12 12
879 0 croak("decrypt: Invalid nonce length %lu", nonce_len);
880  
881 12 msg_pm = protmem_init(aTHX_ ct_len - mac_len, msg_flags);
882 12 ▶ if (msg_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm == NULL) 0 12 12
883 0 croak("decrypt: Failed to allocate protmem");
884  
885 12 ▶ if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
886 0 protmem_free(aTHX_ msg_pm);
887 0 croak("decrypt: Failed to grant precalc protmem RO");
888 }
889  
890 12 ret = func(msg_pm->pm_ptr, ct_buf, ct_len, nonce_buf, precalc_pm->pm_ptr);
891  
892 12 ▶ if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
893 0 protmem_free(aTHX_ msg_pm);
894 0 croak("decrypt: Failed to release precalc protmem RO");
895 }
896  
897 12 ▶ if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 12 12
898 0 protmem_free(aTHX_ msg_pm);
899 0 croak("decrypt: Failed to release msg protmem RW");
900 }
901  
902 12 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 12 0 12
903 12 RETVAL = protmem_to_sv(aTHX_ msg_pm, MEMVAULT_CLASS);
904 else {
905 0 protmem_free(aTHX_ msg_pm);
906 0 croak("decrypt: Message forged");
907 }
908  
909 OUTPUT:
910 RETVAL
911  
912 SV * decrypt_detached(SV * self, SV * ciphertext, SV * mac, SV * nonce, SV * flags = &PL_sv_undef)
913  
914 ALIAS:
915 Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::decrypt_detached = 1
916 Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::decrypt_detached = 2
917  
918 PREINIT:
919 protmem *msg_pm, *precalc_pm;
920 unsigned char *ct_buf, *mac_buf, *nonce_buf;
921 STRLEN ct_len, mac_len, nonce_len, mac_req_len, nonce_req_len;
922 12 ▶ unsigned int msg_flags = g_protmem_default_flags_decrypt;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int msg_flags = g_protmem_default_flags_decrypt; 12 0 12
923 int ret;
924 int (*func)(unsigned char *, const unsigned char *,
925 const unsigned char *, unsigned long long,
926 const unsigned char *, const unsigned char *);
927  
928 CODE:
929 12 switch(ix) {
930 4 case 1:
931 4 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
932 4 mac_req_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
933 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
934 4 func = crypto_box_curve25519xchacha20poly1305_open_detached_afternm;
935 4 break;
936 4 case 2:
937 /* no separate NONCEBYTES MACBYTES or function */
938 4 nonce_req_len = crypto_box_NONCEBYTES;
939 4 mac_req_len = crypto_box_MACBYTES;
940 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
941 4 func = crypto_box_open_detached_afternm;
942 4 break;
943 4 default:
944 4 nonce_req_len = crypto_box_NONCEBYTES;
945 4 mac_req_len = crypto_box_MACBYTES;
946 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc");
947 4 func = crypto_box_open_detached_afternm;
948 }
949  
950 12 SvGETMAGIC(flags);
951 12 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 12 12
952 0 msg_flags = SvUV_nomg(flags);
953  
954 12 ▶ ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len);
Branch: 1 branch
BranchTrueFalseTotal
ct_buf = (unsigned char *)SvPVbyte(ciphertext, ct_len); 12 0 12
955  
956 12 mac_buf = (unsigned char *)SvPVbyte(mac, mac_len);
957 12 ▶ if (mac_len != mac_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (mac_len != mac_req_len) 0 12 12
958 0 croak("decrypt_detached: Invalid mac length: %lu", mac_len);
959  
960 12 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
961 12 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 12 12
962 0 croak("decrypt_detached: Invalid nonce length: %lu", nonce_len);
963  
964 12 msg_pm = protmem_init(aTHX_ ct_len, msg_flags);
965 12 ▶ if (msg_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm == NULL) 0 12 12
966 0 croak("decrypt_detached: Failed to allocate protmem");
967  
968 12 ▶ if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
969 0 protmem_free(aTHX_ msg_pm);
970 0 croak("decrypt_detached: Failed to grant precalc protmem RO");
971 }
972  
973 12 ret = func(msg_pm->pm_ptr, ct_buf, mac_buf, ct_len, nonce_buf, precalc_pm->pm_ptr);
974  
975 12 ▶ if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
976 0 protmem_free(aTHX_ msg_pm);
977 0 croak("decrypt_detached: Failed to release precalc protmem RO");
978 }
979  
980 12 ▶ if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 12 12
981 0 protmem_free(aTHX_ msg_pm);
982 0 croak("decrypt_detached: Failed to release msg protmem RW");
983 }
984  
985 12 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 12 0 12
986 12 RETVAL = protmem_to_sv(aTHX_ msg_pm, MEMVAULT_CLASS);
987 else {
988 0 protmem_free(aTHX_ msg_pm);
989 0 croak("decrypt_detached: Message forged");
990 }
991  
992 OUTPUT:
993 RETVAL
994  
995 void encrypt(SV * self, SV * msg, SV * nonce)
996  
997 ALIAS:
998 Crypt::Sodium::XS::box::precalc::encrypt_detached = 1
999 Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::encrypt = 2
1000 Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305::encrypt_detached = 3
1001 Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::encrypt = 4
1002 Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305::encrypt_detached = 5
1003  
1004 PREINIT:
1005 12 protmem *msg_mv = NULL, *precalc_pm;
1006 12 SV *ct, *mac = NULL;
1007 unsigned char *msg_buf, *nonce_buf, *ct_buf, *mac_buf;
1008 STRLEN msg_len, nonce_len, nonce_req_len, mac_len;
1009 int (*detached_func)(unsigned char *, unsigned char *,
1010 const unsigned char *, unsigned long long,
1011 const unsigned char *, const unsigned char *);
1012 int (*easy_func)(unsigned char *, const unsigned char *,
1013 unsigned long long, const unsigned char *,
1014 const unsigned char *);
1015  
1016 PPCODE:
1017 12 switch(ix) {
1018 4 case 2: /* fallthrough */
1019 case 3:
1020 4 nonce_req_len = crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
1021 4 mac_len = crypto_box_curve25519xchacha20poly1305_MACBYTES;
1022 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xchacha20poly1305");
1023 4 detached_func = crypto_box_curve25519xchacha20poly1305_detached_afternm;
1024 4 easy_func = crypto_box_curve25519xchacha20poly1305_easy_afternm;
1025 4 break;
1026 4 case 4: /* fallthrough */
1027 case 5:
1028 4 nonce_req_len = crypto_box_curve25519xsalsa20poly1305_NONCEBYTES;
1029 4 mac_len = crypto_box_curve25519xsalsa20poly1305_MACBYTES;
1030 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc::curve25519xsalsa20poly1305");
1031 /* no separate functions */
1032 4 detached_func = crypto_box_detached_afternm;
1033 4 easy_func = crypto_box_easy_afternm;
1034 4 break;
1035 4 case 1: /* fallthrough */
1036 default:
1037 4 nonce_req_len = crypto_box_NONCEBYTES;
1038 4 mac_len = crypto_box_MACBYTES;
1039 4 precalc_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::box::precalc");
1040 4 detached_func = crypto_box_detached_afternm;
1041 4 easy_func = crypto_box_easy_afternm;
1042 }
1043  
1044 12 nonce_buf = (unsigned char *)SvPVbyte(nonce, nonce_len);
1045 12 ▶ if (nonce_len != nonce_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (nonce_len != nonce_req_len) 0 12 12
1046 0 croak("encrypt: Invalid nonce length %lu", nonce_len);
1047  
1048 12 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 12 12
1049 0 msg_mv = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
1050 0 msg_buf = msg_mv->pm_ptr;
1051 0 msg_len = msg_mv->size;
1052 }
1053 else
1054 12 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
1055  
1056 12 ▶ if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_grant(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 12 12
1057 0 croak("encrypt: Failed to grant precalc protmem RO");
1058 12 ▶ if (msg_mv && protmem_grant(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (msg_mv && protmem_grant(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
if (msg_mv && protmem_grant(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
1059 0 protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO);
1060 0 croak("encrypt: Failed to grant msg protmem RO");
1061 }
1062  
1063 /* NB: odd aliases are _detached, even are combined */
1064 12 ▶ if (ix & 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (ix & 1) { 6 6 12
1065 6 Newx(mac_buf, mac_len + 1, unsigned char);
1066 6 ▶ if (mac_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (mac_buf == NULL) { 0 6 6
1067 0 ▶ if (msg_mv)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_mv) 0 0 0
1068 0 protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO);
1069 0 protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO);
1070 0 croak("encrypt: Failed to allocate memory");
1071 }
1072 6 mac_buf[mac_len] = '\0';
1073 6 Newx(ct_buf, msg_len + 1, unsigned char);
1074 6 ▶ if (ct_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (ct_buf == NULL) { 0 6 6
1075 0 ▶ if (msg_mv)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_mv) 0 0 0
1076 0 protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO);
1077 0 protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO);
1078 0 Safefree(mac_buf);
1079 0 croak("encrypt: Failed to allocate memory");
1080 }
1081 6 ct_buf[msg_len] = '\0';
1082  
1083 6 detached_func(ct_buf, mac_buf, msg_buf, msg_len, nonce_buf, precalc_pm->pm_ptr);
1084  
1085 6 mac = newSV(0);
1086 6 sv_usepvn_flags(mac, (char *)mac_buf, mac_len, SV_HAS_TRAILING_NUL);
1087 6 ct = newSV(0);
1088 6 sv_usepvn_flags(ct, (char *)ct_buf, msg_len, SV_HAS_TRAILING_NUL);
1089 }
1090 else {
1091 6 STRLEN ct_len = mac_len + msg_len;
1092  
1093 6 Newx(ct_buf, ct_len + 1, unsigned char);
1094 6 ▶ if (ct_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (ct_buf == NULL) { 0 6 6
1095 0 ▶ if (msg_mv)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_mv) 0 0 0
1096 0 protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO);
1097 0 protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO);
1098 0 croak("encrypt: Failed to allocate memory");
1099 }
1100 6 ct_buf[ct_len] = '\0';
1101  
1102 6 easy_func(ct_buf, msg_buf, msg_len, nonce_buf, precalc_pm->pm_ptr);
1103  
1104 6 ct = newSV(0);
1105 6 sv_usepvn_flags(ct, (char *)ct_buf, ct_len, SV_HAS_TRAILING_NUL);
1106 }
1107  
1108 12 ▶ if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ precalc_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 12 12
1109 0 ▶ if (msg_mv)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_mv) 0 0 0
1110 0 protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO);
1111 0 croak("encrypt: Failed to release precalc protmem RO");
1112 }
1113 12 ▶ if (msg_mv && protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0)
Branch: 2 branches
BranchTrueFalseTotal
if (msg_mv && protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 12 12
if (msg_mv && protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
1114 0 croak("encrypt: Failed to release msg protmem RO");
1115  
1116 12 ▶ mXPUSHs(ct);
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(ct); 0 12 12
1117  
1118 12 ▶ if (ix & 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (ix & 1) { 6 6 12
1119 6 ▶ mXPUSHs(mac);
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(mac); 0 6 6
1120 6 XSRETURN(2);
1121 }
1122  
1123 6 XSRETURN(1);
« xs/xof.xs ↑ Summary XS.xs »