xs/auth.xs

filter: Statementstmt 71.6% 238 / 332 Branchbran 40.7% 62 / 152 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 61.9% 300 / 484 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/pwhash.xs ↑ Summary xs/secretbox.xs »
1 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::auth
2  
3 void _define_constants()
4  
5 PREINIT:
6 1 HV *stash = gv_stashpv("Crypt::Sodium::XS::auth", 0);
7  
8 PPCODE:
9 1 newCONSTSUB(stash, "auth_BYTES",
10 newSVuv(crypto_auth_BYTES));
11 1 newCONSTSUB(stash, "auth_hmacsha256_BYTES",
12 newSVuv(crypto_auth_hmacsha256_BYTES));
13 1 newCONSTSUB(stash, "auth_hmacsha512_BYTES",
14 newSVuv(crypto_auth_hmacsha512_BYTES));
15 1 newCONSTSUB(stash, "auth_hmacsha512256_BYTES",
16 newSVuv(crypto_auth_hmacsha512256_BYTES));
17 1 newCONSTSUB(stash, "auth_KEYBYTES",
18 newSVuv(crypto_auth_KEYBYTES));
19 1 newCONSTSUB(stash, "auth_hmacsha256_KEYBYTES",
20 newSVuv(crypto_auth_hmacsha256_KEYBYTES));
21 1 newCONSTSUB(stash, "auth_hmacsha512_KEYBYTES",
22 newSVuv(crypto_auth_hmacsha512_KEYBYTES));
23 1 newCONSTSUB(stash, "auth_hmacsha512256_KEYBYTES",
24 newSVuv(crypto_auth_hmacsha512256_KEYBYTES));
25 1 newCONSTSUB(stash, "auth_PRIMITIVE", newSVpvs(crypto_auth_PRIMITIVE));
26  
27 SV * auth_keygen(SV * flags = &PL_sv_undef)
28  
29 ALIAS:
30 auth_hmacsha256_keygen = 1
31 auth_hmacsha512_keygen = 2
32 auth_hmacsha512256_keygen = 3
33  
34 CODE:
35 8 switch(ix) {
36 2 case 1:
37 2 RETVAL = sv_keygen(aTHX_ crypto_auth_hmacsha256_KEYBYTES, flags);
38 2 break;
39 2 case 2:
40 2 RETVAL = sv_keygen(aTHX_ crypto_auth_hmacsha512_KEYBYTES, flags);
41 2 break;
42 2 case 3:
43 2 RETVAL = sv_keygen(aTHX_ crypto_auth_hmacsha512256_KEYBYTES, flags);
44 2 break;
45 2 default:
46 2 RETVAL = sv_keygen(aTHX_ crypto_auth_KEYBYTES, flags);
47 }
48  
49 OUTPUT:
50 RETVAL
51  
52 SV * auth(SV * msg, SV * key)
53  
54 ALIAS:
55 auth_hmacsha256 = 1
56 auth_hmacsha512 = 2
57 auth_hmacsha512256 = 3
58  
59 PREINIT:
60 8 protmem *msg_pm = NULL, *key_pm = NULL;
61 unsigned char *msg_buf, *key_buf, *mac_buf;
62 STRLEN msg_len, key_len, key_req_len, mac_len;
63 int (*func)(unsigned char *, const unsigned char *,
64 unsigned long long, const unsigned char *);
65  
66 CODE:
67 8 switch(ix) {
68 2 case 1:
69 2 key_req_len = crypto_auth_hmacsha256_KEYBYTES;
70 2 mac_len = crypto_auth_hmacsha256_BYTES;
71 2 func = crypto_auth_hmacsha256;
72 2 break;
73 2 case 2:
74 2 key_req_len = crypto_auth_hmacsha512_KEYBYTES;
75 2 mac_len = crypto_auth_hmacsha512_BYTES;
76 2 func = crypto_auth_hmacsha512;
77 2 break;
78 2 case 3:
79 2 key_req_len = crypto_auth_hmacsha512256_KEYBYTES;
80 2 mac_len = crypto_auth_hmacsha512256_BYTES;
81 2 func = crypto_auth_hmacsha512256;
82 2 break;
83 2 default:
84 2 key_req_len = crypto_auth_KEYBYTES;
85 2 mac_len = crypto_auth_BYTES;
86 2 func = crypto_auth;
87 }
88  
89 8 ▶ if (sv_derived_from(key, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(key, MEMVAULT_CLASS)) { 8 0 8
90 8 key_pm = protmem_get(aTHX_ key, MEMVAULT_CLASS);
91 8 key_buf = key_pm->pm_ptr;
92 8 key_len = key_pm->size;
93 }
94 else
95 0 key_buf = (unsigned char *)SvPVbyte(key, key_len);
96 8 ▶ if (key_len != key_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (key_len != key_req_len) 0 8 8
97 0 croak("auth: Invalid key length %lu", key_len);
98  
99 8 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 8 8
100 0 msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
101 0 msg_buf = msg_pm->pm_ptr;
102 0 msg_len = msg_pm->size;
103 }
104 else
105 8 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
106  
107 8 Newx(mac_buf, mac_len + 1, unsigned char);
108 8 ▶ if (mac_buf == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (mac_buf == NULL) 0 8 8
109 0 croak("auth: Failed to allocate memory");
110 8 mac_buf[mac_len] = '\0';
111  
112 8 ▶ 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 8 8
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
113 0 Safefree(mac_buf);
114 0 croak("auth: Failed to grant msg protmem RO");
115 }
116  
117 8 ▶ if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 8 0 8
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 8 8
118 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
119 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
120 0 Safefree(mac_buf);
121 0 croak("auth: Failed to grant key protmem RO");
122 }
123  
124 8 func(mac_buf, msg_buf, msg_len, key_buf);
125  
126 8 ▶ if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 8 0 8
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 8 8
127 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
128 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
129 0 Safefree(mac_buf);
130 0 croak("auth: Failed to release key protmem RO");
131 }
132  
133 8 ▶ 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 8 8
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
134 0 Safefree(mac_buf);
135 0 croak("auth: Failed to release msg protmem RO");
136 }
137  
138 8 RETVAL = newSV(0);
139 8 sv_usepvn_flags(RETVAL, (char *)mac_buf, mac_len, SV_HAS_TRAILING_NUL);
140  
141 OUTPUT:
142 RETVAL
143  
144 void auth_verify(SV * mac, SV * msg, SV * key)
145  
146 PREINIT:
147 3 protmem *msg_pm = NULL, *key_pm = NULL;
148 unsigned char *msg_buf, *key_buf, *mac_buf;
149 STRLEN msg_len, key_len, mac_len;
150 int ret;
151  
152 CODE:
153 3 ▶ if (sv_derived_from(key, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(key, MEMVAULT_CLASS)) { 2 1 3
154 2 key_pm = protmem_get(aTHX_ key, MEMVAULT_CLASS);
155 2 key_buf = key_pm->pm_ptr;
156 2 key_len = key_pm->size;
157 }
158 else
159 1 key_buf = (unsigned char *)SvPVbyte(key, key_len);
160 3 ▶ if (key_len != crypto_auth_KEYBYTES)
Branch: 1 branch
BranchTrueFalseTotal
if (key_len != crypto_auth_KEYBYTES) 0 3 3
161 0 croak("auth_verify: Invalid key length %lu", key_len);
162  
163 3 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 3 3
164 0 msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
165 0 msg_buf = msg_pm->pm_ptr;
166 0 msg_len = msg_pm->size;
167 }
168 else
169 3 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
170  
171 3 mac_buf = (unsigned char *)SvPVbyte(mac, mac_len);
172 3 ▶ if (mac_len != crypto_auth_BYTES)
Branch: 1 branch
BranchTrueFalseTotal
if (mac_len != crypto_auth_BYTES) 0 3 3
173 0 croak("auth_verify: Invalid mac length %lu", mac_len);
174  
175 3 ▶ 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 3 3
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
176 0 croak("auth_verify: Failed to grant msg protmem RO");
177  
178 3 ▶ if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 2 1 3
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 2 2
179 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
180 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
181 0 croak("auth_verify: Failed to grant key protmem RO");
182 }
183  
184 3 ret = crypto_auth(mac_buf, msg_buf, msg_len, key_buf);
185  
186 3 ▶ if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 2 1 3
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 2 2
187 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
188 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
189 0 croak("auth_verify: Failed to release key protmem RO");
190 }
191  
192 3 ▶ 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 3 3
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
193 0 croak("auth_verify: Failed to release msg protmem RO");
194  
195 3 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 3 0 3
196 3 XSRETURN_YES;
197  
198 0 XSRETURN_NO;
199  
200 =for documentation
201  
202 algorithm-specific verify is allowed to use arbitrary-length keys. this is a
203 holdover from compatibility to Crypt::NaCl::Sodium, which i'm assuming was
204 there for a good reason. if that is allowed here, it should likely be allowed
205 in the general auth_verify() function as well. maybe even in the generic auth()
206 ?
207  
208 it might be better to remove this altogether (from verify and from multi-part).
209 it seems to be a great footgun. there's less harm to be done leaving it just
210 for verify.
211  
212 =cut
213  
214 void auth_hmacsha256_verify(SV * mac, SV * msg, SV * key = &PL_sv_undef)
215  
216 ALIAS:
217 auth_hmacsha512_verify = 1
218 auth_hmacsha512256_verify = 2
219  
220 PREINIT:
221 153 protmem *msg_pm = NULL, *key_pm = NULL;
222 153 unsigned char *msg_buf, *key_buf = NULL, *mac_buf;
223 153 ▶ STRLEN msg_len, key_len = 0, key_req_len, mac_len, mac_req_len;
Branch: 1 branch
BranchTrueFalseTotal
STRLEN msg_len, key_len = 0, key_req_len, mac_len, mac_req_len; 0 153 153
224 int ret;
225 int (*func)(const unsigned char *, const unsigned char *,
226 unsigned long long, const unsigned char *);
227  
228 PPCODE:
229 153 switch(ix) {
230 51 case 1:
231 51 key_req_len = crypto_auth_hmacsha512_KEYBYTES;
232 51 mac_req_len = crypto_auth_hmacsha512_BYTES;
233 51 func = crypto_auth_hmacsha512_verify;
234 51 break;
235 51 case 2:
236 51 key_req_len = crypto_auth_hmacsha512256_KEYBYTES;
237 51 mac_req_len = crypto_auth_hmacsha512256_BYTES;
238 51 func = crypto_auth_hmacsha512256_verify;
239 51 break;
240 51 default:
241 51 key_req_len = crypto_auth_hmacsha256_KEYBYTES;
242 51 mac_req_len = crypto_auth_hmacsha256_BYTES;
243 51 func = crypto_auth_hmacsha256_verify;
244 }
245  
246 153 SvGETMAGIC(key);
247 153 ▶ if (SvOK(key)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(key)) { 153 0 153
248 153 ▶ if (sv_derived_from(key, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(key, MEMVAULT_CLASS)) { 6 147 153
249 6 key_pm = protmem_get(aTHX_ key, MEMVAULT_CLASS);
250 6 key_buf = key_pm->pm_ptr;
251 6 key_len = key_pm->size;
252 }
253 else
254 147 key_buf = (unsigned char *)SvPVbyte_nomg(key, key_len);
255 }
256  
257 153 ▶ if (sv_derived_from(msg, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(msg, MEMVAULT_CLASS)) { 0 153 153
258 0 msg_pm = protmem_get(aTHX_ msg, MEMVAULT_CLASS);
259 0 msg_buf = msg_pm->pm_ptr;
260 0 msg_len = msg_pm->size;
261 }
262 else
263 153 msg_buf = (unsigned char *)SvPVbyte(msg, msg_len);
264  
265 153 mac_buf = (unsigned char *)SvPVbyte(mac, mac_len);
266 153 ▶ if (mac_len != mac_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (mac_len != mac_req_len) 0 153 153
267 0 croak("auth_verify: Invalid mac length %lu", mac_len);
268  
269 153 ▶ 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 153 153
if (msg_pm && protmem_grant(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
270 0 croak("auth_verify: Failed to grant msg protmem RO");
271  
272 153 ▶ if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 147 153
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
273 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
274 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
275 0 croak("auth_verify: Failed to grant key protmem RO");
276 }
277  
278 153 ▶ if (key_len != key_req_len) {
Branch: 1 branch
BranchTrueFalseTotal
if (key_len != key_req_len) { 144 9 153
279 unsigned char *mac_expected;
280 144 Newx(mac_expected, mac_req_len + 1, unsigned char);
281 144 ▶ if (mac_expected == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (mac_expected == NULL) { 0 144 144
282 0 ▶ if (msg)
Branch: 1 branch
BranchTrueFalseTotal
if (msg) 0 0 0
283 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
284 0 ▶ if (key_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (key_pm) 0 0 0
285 0 protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO);
286 0 croak("auth_verify: Failed to allocate memory");
287 }
288  
289 144 switch(ix) {
290 48 case 1:
291 {
292 crypto_auth_hmacsha512_state state;
293 48 crypto_auth_hmacsha512_init(&state, key_buf, key_len);
294 48 crypto_auth_hmacsha512_update(&state, msg_buf, msg_len);
295 48 crypto_auth_hmacsha512_final(&state, mac_expected);
296 48 break;
297 }
298 48 case 2:
299 {
300 crypto_auth_hmacsha512256_state state;
301 48 crypto_auth_hmacsha512256_init(&state, key_buf, key_len);
302 48 crypto_auth_hmacsha512256_update(&state, msg_buf, msg_len);
303 48 crypto_auth_hmacsha512256_final(&state, mac_expected);
304 48 break;
305 }
306 48 default:
307 {
308 crypto_auth_hmacsha256_state state;
309 48 crypto_auth_hmacsha256_init(&state, key_buf, key_len);
310 48 crypto_auth_hmacsha256_update(&state, msg_buf, msg_len);
311 48 crypto_auth_hmacsha256_final(&state, mac_expected);
312 }
313 }
314  
315 144 ret = sodium_memcmp(mac_buf, mac_expected, mac_req_len);
316  
317 144 Safefree(mac_expected);
318 }
319 else
320 9 ret = func(mac_buf, msg_buf, msg_len, key_buf);
321  
322 153 ▶ if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 6 147 153
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 6 6
323 0 ▶ if (msg_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (msg_pm) 0 0 0
324 0 protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO);
325 0 croak("auth_verify: Failed to release key protmem RO");
326 }
327  
328 153 ▶ 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 153 153
if (msg_pm && protmem_release(aTHX_ msg_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
329 0 croak("auth_verify: Failed to release msg protmem RO");
330  
331 153 ▶ if (ret == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (ret == 0) 153 0 153
332 153 XSRETURN_YES;
333  
334 0 XSRETURN_NO;
335  
336 =for documentation
337  
338 providing a generic auth_init even though upstream doesn't, using its default
339 algorithm.
340  
341 =cut
342  
343 SV * auth_init(SV * key = &PL_sv_undef, SV * flags = &PL_sv_undef)
344  
345 ALIAS:
346 auth_hmacsha256_init = 1
347 auth_hmacsha512_init = 2
348 auth_hmacsha512256_init = 3
349  
350 PREINIT:
351 148 protmem *state_pm, *key_pm = NULL;
352 148 unsigned char *key_buf = NULL;
353 148 STRLEN key_len = 0;
354 148 ▶ unsigned int state_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int state_flags = g_protmem_default_flags_key; 0 148 148
355  
356 CODE:
357 148 SvGETMAGIC(key);
358 148 ▶ if (SvOK(key)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(key)) { 148 0 148
359 148 state_flags = g_protmem_default_flags_key;
360 148 ▶ if (sv_derived_from(key, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(key, MEMVAULT_CLASS)) { 0 148 148
361 0 key_pm = protmem_get(aTHX_ key, MEMVAULT_CLASS);
362 0 key_buf = key_pm->pm_ptr;
363 0 key_len = key_pm->size;
364 }
365 else {
366 148 key_buf = (unsigned char *)SvPVbyte_nomg(key, key_len);
367 }
368 }
369  
370 148 SvGETMAGIC(flags);
371 148 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 148 148
372 0 state_flags = SvUV_nomg(flags);
373  
374 148 ▶ if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0)
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 148 148
if (key_pm && protmem_grant(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 0 0
375 0 croak("auth_init: Failed to grant key protmem RO");
376  
377 148 switch(ix) {
378 49 case 1:
379 49 state_pm = protmem_init(aTHX_ sizeof(crypto_auth_hmacsha256_state), state_flags);
380 49 ▶ if (state_pm == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (state_pm == NULL) { 0 49 49
381 0 ▶ if (key_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (key_pm) 0 0 0
382 0 protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO);
383 0 croak("auth_init: Failed to allocate state protmem");
384 }
385 49 crypto_auth_hmacsha256_init(state_pm->pm_ptr, key_buf, key_len);
386 49 break;
387 49 case 2:
388 49 state_pm = protmem_init(aTHX_ sizeof(crypto_auth_hmacsha512_state), state_flags);
389 49 ▶ if (state_pm == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (state_pm == NULL) { 0 49 49
390 0 ▶ if (key_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (key_pm) 0 0 0
391 0 protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO);
392 0 croak("auth_init: Failed to allocate state protmem");
393 }
394 49 crypto_auth_hmacsha512_init(state_pm->pm_ptr, key_buf, key_len);
395 49 break;
396 50 default:
397 50 state_pm = protmem_init(aTHX_ sizeof(crypto_auth_hmacsha512256_state), state_flags);
398 50 ▶ if (state_pm == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (state_pm == NULL) { 0 50 50
399 0 ▶ if (key_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (key_pm) 0 0 0
400 0 protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO);
401 0 croak("auth_init: Failed to allocate state protmem");
402 }
403 50 crypto_auth_hmacsha512256_init(state_pm->pm_ptr, key_buf, key_len);
404 }
405  
406 148 ▶ 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 148 148
407 0 protmem_free(aTHX_ state_pm);
408 0 ▶ if (key_pm)
Branch: 1 branch
BranchTrueFalseTotal
if (key_pm) 0 0 0
409 0 protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO);
410 0 croak("auth_init: Failed to release state protmem RO");
411 }
412  
413 148 ▶ if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) {
Branch: 2 branches
BranchTrueFalseTotal
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 148 148
if (key_pm && protmem_release(aTHX_ key_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
414 0 protmem_free(aTHX_ state_pm);
415 0 croak("auth_init: Failed to release key protmem RO");
416 }
417  
418 148 switch(ix) {
419 49 case 1:
420 49 RETVAL = protmem_to_sv(aTHX_ state_pm, "Crypt::Sodium::XS::auth::hmacsha256_multi");
421 49 break;
422 49 case 2:
423 49 RETVAL = protmem_to_sv(aTHX_ state_pm, "Crypt::Sodium::XS::auth::hmacsha512_multi");
424 49 break;
425 50 default:
426 50 RETVAL = protmem_to_sv(aTHX_ state_pm, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
427 }
428  
429 OUTPUT:
430 RETVAL
431  
432 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::auth::hmacsha256_multi
433  
434 void DESTROY(SV * self)
435  
436 ALIAS:
437 Crypt::Sodium::XS::auth::hmacsha512_multi::DESTROY = 1
438 Crypt::Sodium::XS::auth::hmacsha512256_multi::DESTROY= 2
439  
440 PREINIT:
441 protmem *state_pm;
442  
443 PPCODE:
444 148 switch (ix) {
445 49 case 1:
446 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
447 49 break;
448 50 case 2:
449 50 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
450 50 break;
451 49 default:
452 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
453 }
454 148 protmem_free(aTHX_ state_pm);
455  
456 SV * clone(SV * self)
457  
458 ALIAS:
459 Crypt::Sodium::XS::auth::hmacsha512_multi::clone = 1
460 Crypt::Sodium::XS::auth::hmacsha512256_multi::clone = 2
461  
462 CODE:
463 0 switch(ix) {
464 0 case 1:
465 0 RETVAL = protmem_clone_sv(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
466 0 break;
467 0 case 2:
468 0 RETVAL = protmem_clone_sv(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
469 0 break;
470 0 default:
471 0 RETVAL = protmem_clone_sv(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
472 }
473  
474 OUTPUT:
475 RETVAL
476  
477 SV * final(SV * self)
478  
479 ALIAS:
480 Crypt::Sodium::XS::auth::hmacsha512_multi::final = 1
481 Crypt::Sodium::XS::auth::hmacsha512256_multi::final = 2
482  
483 PREINIT:
484 protmem *state_pm;
485 unsigned char *out_buf;
486 STRLEN bytes_len;
487  
488 CODE:
489 148 switch(ix) {
490 49 case 1:
491 49 bytes_len = crypto_auth_hmacsha512_BYTES;
492 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
493 49 break;
494 50 case 2:
495 50 bytes_len = crypto_auth_hmacsha512256_BYTES;
496 50 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
497 50 break;
498 49 default:
499 49 bytes_len = crypto_auth_hmacsha256_BYTES;
500 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
501 }
502  
503 148 Newx(out_buf, bytes_len + 1, unsigned char);
504 148 ▶ if (out_buf == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (out_buf == NULL) { 0 148 148
505 0 protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW);
506 0 croak("Failed to allocate memory");
507 }
508 148 out_buf[bytes_len] = '\0';
509  
510 148 ▶ 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 148 148
511 0 Safefree(out_buf);
512 0 croak("final: Failed to grant state protmem RW");
513 }
514  
515 148 switch(ix) {
516 49 case 1:
517 49 crypto_auth_hmacsha512_final(state_pm->pm_ptr, out_buf);
518 49 break;
519 50 case 2:
520 50 crypto_auth_hmacsha512256_final(state_pm->pm_ptr, out_buf);
521 50 break;
522 49 default:
523 49 crypto_auth_hmacsha256_final(state_pm->pm_ptr, out_buf);
524 }
525  
526 148 ▶ 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 148 148
527 0 Safefree(out_buf);
528 0 croak("final: Failed to release state protmem RW");
529 }
530  
531 148 RETVAL = newSV(0);
532 148 sv_usepvn_flags(RETVAL, (char *)out_buf, bytes_len, SV_HAS_TRAILING_NUL);
533  
534 OUTPUT:
535 RETVAL
536  
537 void update(SV * self, ...)
538  
539 ALIAS:
540 Crypt::Sodium::XS::auth::hmacsha512_multi::update = 1
541 Crypt::Sodium::XS::auth::hmacsha512256_multi::update = 2
542  
543 PREINIT:
544 148 protmem *state_pm, *msg_mv = NULL;
545 unsigned char *msg_buf;
546 STRLEN msg_len;
547 I32 i;
548  
549 PPCODE:
550 148 switch(ix) {
551 49 case 1:
552 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512_multi");
553 49 break;
554 50 case 2:
555 50 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha512256_multi");
556 50 break;
557 49 default:
558 49 state_pm = protmem_get(aTHX_ self, "Crypt::Sodium::XS::auth::hmacsha256_multi");
559 }
560 148 ▶ 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 148 148
561 0 croak("update: Failed to grant state protmem RW");
562  
563 296 ▶ for (i = 1; i < items; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 1; i < items; i++) { 148 148 296
564 148 ▶ if (sv_derived_from(ST(i), MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(ST(i), MEMVAULT_CLASS)) { 0 148 148
565 0 msg_mv = protmem_get(aTHX_ ST(i), MEMVAULT_CLASS);
566 0 msg_buf = msg_mv->pm_ptr;
567 0 msg_len = msg_mv->size;
568 }
569 else
570 296 msg_buf = (unsigned char *)SvPVbyte(ST(i), msg_len);
571  
572 148 ▶ 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 148 148
if (msg_mv && protmem_grant(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
573 0 protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW);
574 0 croak("update: Failed to grant msg protmem RO");
575 }
576  
577 148 switch(ix) {
578 49 case 1:
579 49 crypto_auth_hmacsha512_update(state_pm->pm_ptr, msg_buf, msg_len);
580 49 break;
581 50 case 2:
582 50 crypto_auth_hmacsha512256_update(state_pm->pm_ptr, msg_buf, msg_len);
583 50 break;
584 49 default:
585 49 crypto_auth_hmacsha256_update(state_pm->pm_ptr, msg_buf, msg_len);
586 }
587  
588 148 ▶ 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 148 148
if (msg_mv && protmem_release(aTHX_ msg_mv, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 0 0
589 0 protmem_release(aTHX_ state_pm, PROTMEM_FLAG_MPROTECT_RW);
590 0 croak("update: Failed to release msg protmem RO");
591 }
592  
593 148 msg_mv = NULL;
594 }
595  
596 148 ▶ 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 148 148
597 0 croak("update: Failed to release state protmem RW");
598  
599 148 XSRETURN(1);
« xs/pwhash.xs ↑ Summary xs/secretbox.xs »