xs/scalarmult.xs

filter: Statementstmt 79.0% 113 / 143 Branchbran 48.1% 26 / 54 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 70.5% 139 / 197 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xs/util.xs ↑ Summary xs/hkdf.xs »
1 MODULE = Crypt::Sodium::XS PACKAGE = Crypt::Sodium::XS::scalarmult
2  
3 void _define_constants()
4 PREINIT:
5 3 HV *stash = gv_stashpv("Crypt::Sodium::XS::scalarmult", 0);
6  
7 PPCODE:
8 3 newCONSTSUB(stash, "scalarmult_BYTES",
9 newSVuv(crypto_scalarmult_BYTES));
10 3 newCONSTSUB(stash, "scalarmult_SCALARBYTES",
11 newSVuv(crypto_scalarmult_SCALARBYTES));
12 3 newCONSTSUB(stash, "scalarmult_x25519_BYTES",
13 newSVuv(crypto_scalarmult_BYTES));
14 3 newCONSTSUB(stash, "scalarmult_x25519_SCALARBYTES",
15 newSVuv(crypto_scalarmult_SCALARBYTES));
16 3 newCONSTSUB(stash, "scalarmult_ed25519_BYTES",
17 newSVuv(crypto_scalarmult_ed25519_BYTES));
18 3 newCONSTSUB(stash, "scalarmult_ed25519_SCALARBYTES",
19 newSVuv(crypto_scalarmult_ed25519_SCALARBYTES));
20 #ifdef SODIUM_HAS_RISTRETTO255
21 3 newCONSTSUB(stash, "scalarmult_ristretto255_BYTES",
22 newSVuv(crypto_scalarmult_ristretto255_BYTES));
23 3 newCONSTSUB(stash, "scalarmult_ristretto255_SCALARBYTES",
24 newSVuv(crypto_scalarmult_ristretto255_SCALARBYTES));
25 3 newCONSTSUB(stash, "scalarmult_ristretto255_available", &PL_sv_yes);
26 #else
27 newCONSTSUB(stash, "scalarmult_ristretto255_available", &PL_sv_no);
28 #endif
29  
30 SV * scalarmult_keygen(SV * flags = &PL_sv_undef)
31  
32 ALIAS:
33 scalarmult_ed25519_keygen = 1
34 scalarmult_ristretto255_keygen = 2
35 scalarmult_x25519_keygen = 99
36  
37 PREINIT:
38 protmem *new_pm;
39 16 ▶ unsigned int new_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int new_flags = g_protmem_default_flags_key; 16 0 16
40  
41 CODE:
42 16 SvGETMAGIC(flags);
43 16 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 16 16
44 0 new_flags = SvUV_nomg(flags);
45  
46 16 switch(ix) {
47 4 case 1:
48 4 new_pm = protmem_init(aTHX_ crypto_core_ed25519_SCALARBYTES, new_flags);
49 4 ▶ if (new_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (new_pm == NULL) 0 4 4
50 0 croak("scalarmult_ed25519_keygen: Failed to allocate protmem");
51 4 crypto_core_ed25519_scalar_random(new_pm->pm_ptr);
52 4 ▶ if (protmem_release(aTHX_ new_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ new_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 4 4
53 0 croak("scalarmult_ed25519_keygen: Failed to release protmem RW");
54 }
55  
56 4 RETVAL = protmem_to_sv(aTHX_ new_pm, MEMVAULT_CLASS);
57 4 break;
58 4 case 2:
59 #ifdef SODIUM_HAS_RISTRETTO255
60 4 new_pm = protmem_init(aTHX_ crypto_core_ed25519_SCALARBYTES, new_flags);
61 4 ▶ if (new_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (new_pm == NULL) 0 4 4
62 0 croak("scalarmult_ed25519_keygen: Failed to allocate protmem");
63 4 crypto_core_ristretto255_scalar_random(new_pm->pm_ptr);
64 4 ▶ if (protmem_release(aTHX_ new_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ new_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 4 4
65 0 croak("scalarmult_ed25519_keygen: Failed to release protmem RW");
66 }
67  
68 4 RETVAL = protmem_to_sv(aTHX_ new_pm, MEMVAULT_CLASS);
69 #else
70 croak("ristretto255 not supported by this version of libsodium");
71 #endif
72 4 break;
73 8 default:
74 8 RETVAL = sv_keygen(aTHX_ crypto_scalarmult_SCALARBYTES, flags);
75 }
76  
77 OUTPUT:
78 RETVAL
79  
80 SV * scalarmult_base(SV * sk)
81  
82 ALIAS:
83 scalarmult_ed25519_base = 1
84 scalarmult_ed25519_base_noclamp = 2
85 scalarmult_ristretto255_base = 3
86 scalarmult_x25519_base = 99
87  
88 PREINIT:
89 38 protmem *sk_pm = NULL;
90 int ret;
91 unsigned char *sk_buf, *out_buf;
92 STRLEN out_len, sk_len, sk_req_len;
93  
94 CODE:
95 38 switch(ix) {
96 6 case 1:
97 /* fallthrough */
98 case 2:
99 6 out_len = crypto_scalarmult_ed25519_SCALARBYTES;
100 6 sk_req_len = crypto_scalarmult_ed25519_BYTES;
101 6 break;
102 6 case 3:
103 #ifdef SODIUM_HAS_RISTRETTO255
104 6 out_len = crypto_scalarmult_ristretto255_SCALARBYTES;
105 6 sk_req_len = crypto_scalarmult_ristretto255_BYTES;
106 #else
107 croak("ristretto255 not supported by this version of libsodium");
108 #endif
109 6 break;
110 26 default:
111 26 out_len = crypto_scalarmult_SCALARBYTES;
112 26 sk_req_len = crypto_scalarmult_BYTES;
113 }
114  
115 38 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 38 0 38
116 38 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
117 38 sk_buf = sk_pm->pm_ptr;
118 38 sk_len = sk_pm->size;
119 }
120 else
121 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
122 38 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 38 38
123 0 croak("scalarmult_base: Invalid key length %lu", sk_len);
124  
125 38 Newx(out_buf, out_len + 1, unsigned char);
126 38 ▶ if (out_buf == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (out_buf == NULL) 0 38 38
127 0 croak("scalarmult_base: Failed to allocate memory");
128 38 out_buf[out_len] = '\0';
129  
130 38 ▶ 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) 38 0 38
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) 0 38 38
131 0 croak("scalarmult_base: Failed to grant sk protmem RO");
132  
133 38 switch(ix) {
134 5 case 1:
135 5 ret = crypto_scalarmult_ed25519_base(out_buf, sk_buf);
136 5 break;
137 1 case 2:
138 1 ret = crypto_scalarmult_ed25519_base_noclamp(out_buf, sk_buf);
139 1 break;
140 6 case 3:
141 6 ret = crypto_scalarmult_ristretto255_base(out_buf, sk_buf);
142 6 break;
143 26 default:
144 26 ret = crypto_scalarmult_base(out_buf, sk_buf);
145 }
146  
147 38 ▶ 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) { 38 0 38
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 38 38
148 0 Safefree(out_buf);
149 0 croak("scalarmult_base: Failed to release sk protmem RO");
150 }
151  
152 38 ▶ if (ret != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (ret != 0) { 0 38 38
153 0 Safefree(out_buf);
154 0 croak("scalarmult_base: Invalid sk: is 0");
155 }
156  
157 38 RETVAL = newSV(0);
158 38 sv_usepvn_flags(RETVAL, (char *)out_buf, out_len, SV_HAS_TRAILING_NUL);
159  
160 OUTPUT:
161 RETVAL
162  
163 SV * scalarmult(SV * sk, SV * pk, SV * flags = &PL_sv_undef)
164  
165 ALIAS:
166 scalarmult_ed25519 = 1
167 scalarmult_ed25519_noclamp = 2
168 scalarmult_ristretto255 = 3
169 scalarmult_x25519 = 99
170  
171 PREINIT:
172 22 protmem *sk_pm = NULL, *ss_pm;
173 unsigned char *sk_buf, *pk_buf;
174 STRLEN sk_len, sk_req_len, pk_len, pk_req_len, ss_len;
175 22 ▶ unsigned int sk_flags = g_protmem_default_flags_key;
Branch: 1 branch
BranchTrueFalseTotal
unsigned int sk_flags = g_protmem_default_flags_key; 22 0 22
176 int ret;
177  
178 CODE:
179 22 switch(ix) {
180 7 case 1:
181 /* fallthrough */
182 case 2:
183 7 pk_req_len = crypto_scalarmult_ed25519_SCALARBYTES;
184 7 sk_req_len = crypto_scalarmult_ed25519_SCALARBYTES;
185 7 ss_len = crypto_scalarmult_ed25519_BYTES;
186 7 break;
187 7 case 3:
188 #ifdef SODIUM_HAS_RISTRETTO255
189 7 pk_req_len = crypto_scalarmult_ristretto255_SCALARBYTES;
190 7 sk_req_len = crypto_scalarmult_ristretto255_SCALARBYTES;
191 7 ss_len = crypto_scalarmult_ristretto255_BYTES;
192 #else
193 croak("ristretto255 not supported by this version of libsodium");
194 #endif
195 7 break;
196 8 default:
197 8 pk_req_len = crypto_scalarmult_SCALARBYTES;
198 8 sk_req_len = crypto_scalarmult_SCALARBYTES;
199 8 ss_len = crypto_scalarmult_BYTES;
200 }
201 22 SvGETMAGIC(flags);
202 22 ▶ if (SvOK(flags))
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(flags)) 0 22 22
203 0 sk_flags = SvUV_nomg(flags);
204  
205 22 ▶ if (sv_derived_from(sk, MEMVAULT_CLASS)) {
Branch: 1 branch
BranchTrueFalseTotal
if (sv_derived_from(sk, MEMVAULT_CLASS)) { 22 0 22
206 22 sk_pm = protmem_get(aTHX_ sk, MEMVAULT_CLASS);
207 22 sk_buf = sk_pm->pm_ptr;
208 22 sk_len = sk_pm->size;
209 }
210 else
211 0 sk_buf = (unsigned char *)SvPVbyte(sk, sk_len);
212 22 ▶ if (sk_len != sk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (sk_len != sk_req_len) 0 22 22
213 0 croak("scalarmult: Invalid secret key lenth %lu", sk_len);
214  
215 22 pk_buf = (unsigned char *)SvPVbyte(pk, pk_len);
216 22 ▶ if (pk_len != pk_req_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pk_len != pk_req_len) 0 22 22
217 0 croak("scalarmult: Invalid public key lenth %lu", pk_len);
218  
219 22 ss_pm = protmem_init(aTHX_ ss_len, sk_flags);
220 22 ▶ if (ss_pm == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (ss_pm == NULL) 0 22 22
221 0 croak("scalarmult: Failed to allocate protmem");
222  
223 22 ▶ 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) { 22 0 22
if (sk_pm && protmem_grant(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 22 22
224 0 protmem_free(aTHX_ ss_pm);
225 0 croak("scalarmult: Failed to grant sk protmem RO");
226 }
227  
228 22 switch(ix) {
229 6 case 1:
230 6 ret = crypto_scalarmult_ed25519(ss_pm->pm_ptr, sk_buf, pk_buf);
231 6 break;
232 1 case 2:
233 1 ret = crypto_scalarmult_ed25519_noclamp(ss_pm->pm_ptr, sk_buf, pk_buf);
234 1 break;
235 7 case 3:
236 7 ret = crypto_scalarmult_ristretto255(ss_pm->pm_ptr, sk_buf, pk_buf);
237 7 break;
238 8 default:
239 8 ret = crypto_scalarmult(ss_pm->pm_ptr, sk_buf, pk_buf);
240 }
241  
242 22 ▶ 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) { 22 0 22
if (sk_pm && protmem_release(aTHX_ sk_pm, PROTMEM_FLAG_MPROTECT_RO) != 0) { 0 22 22
243 0 protmem_free(aTHX_ ss_pm);
244 0 croak("scalarmult: Failed to release sk protmem RO");
245 }
246  
247 22 ▶ if (protmem_release(aTHX_ ss_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (protmem_release(aTHX_ ss_pm, PROTMEM_FLAG_MPROTECT_RW) != 0) { 0 22 22
248 0 protmem_free(aTHX_ ss_pm);
249 0 croak("scalarmult: Failed to protect memvault");
250 }
251  
252 22 ▶ if (ret != 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (ret != 0) { 0 22 22
253 0 protmem_free(aTHX_ ss_pm);
254 0 ▶ switch(ix) {
Branch: 1 branch
BranchTrueFalseTotal
switch(ix) { 0 0 0
255 0 case 1:
256 /* fallthrough */
257 case 2:
258 0 croak("scalarmult: sk is 0 or pk is not on the curve, not on the main subgroup, is a point of small order, or is not provided in canonical form");
259 break;
260 0 default:
261 0 croak("scalarmult: Unknown failure");
262 }
263 croak("scalarmult: Failed to scalarmult");
264 }
265  
266 22 RETVAL = protmem_to_sv(aTHX_ ss_pm, MEMVAULT_CLASS);
267  
268 OUTPUT:
269 RETVAL
« xs/util.xs ↑ Summary xs/hkdf.xs »