SEC.xs

filter: Statementstmt 100% 85 / 85 Branchbran 100% 10 / 10 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 100% 95 / 95 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« blib/lib/Net/DNS/SEC/Digest.pm ↑ Summary blib/lib/Net/DNS/SEC/DSA.pm »
1  
2 #define XS_Id "$Id: SEC.xs 2063 2026-10-05 11:02:58Z willem $"
3  
4  
5 =head1 NAME
6  
7 Net::DNS::SEC::libcrypto - Perl bindings for OpenSSL libcrypto
8  
9 =head1 DESCRIPTION
10  
11 Perl XS extension providing bindings for the OpenSSL libcrypto library
12 upon which the Net::DNS::SEC cryptographic components are built.
13  
14 =head1 COPYRIGHT
15  
16 Copyright (c)2018-2026 Dick Franks
17  
18 All Rights Reserved
19  
20 =head1 LICENSE
21  
22 Permission to use, copy, modify, and distribute this software and its
23 documentation for any purpose and without fee is hereby granted, provided
24 that the original copyright notices appear in all copies and that both
25 copyright notice and this permission notice appear in supporting
26 documentation, and that the name of the author not be used in advertising
27 or publicity pertaining to distribution of the software without specific
28 prior written permission.
29  
30 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
31 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
32 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
33 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
34 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
35 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
36 DEALINGS IN THE SOFTWARE.
37  
38 =cut
39  
40  
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
44  
45 #define PERL_NO_GET_CONTEXT
46 #include <EXTERN.h>
47 #include <perl.h>
48 #include <XSUB.h>
49  
50 #include <openssl/opensslv.h>
51  
52 #ifndef OPENSSL_API_LEVEL
53 # if (OPENSSL_VERSION_NUMBER < 0x10101000)
54 # error deprecated OpenSSL version
55 # include OPENSSL_VERSION_TEXT /* in error log; by any means, however reprehensible! */
56 # endif
57 # define OPENSSL_API_LEVEL 10101
58 #endif
59  
60 /* OpenSSL support status */
61 #define OSSL_RELEASE (OPENSSL_VERSION_MAJOR * 100 + OPENSSL_VERSION_MINOR) * 100
62 #if (OSSL_RELEASE == 30500) /* LTS */
63 # define EOL 20300408
64 #elif (OSSL_RELEASE < 30600)
65 # define EOL 20260907
66 #elif (OSSL_RELEASE < 40000)
67 # define EOL 20261101
68 #elif (OSSL_RELEASE < 40100)
69 # define EOL 20270514
70 #elif (OSSL_RELEASE < 40200)
71 # define EOL 20271130
72 #endif
73  
74  
75 #if (OPENSSL_API_LEVEL < 30000)
76 # define API_1_1_1
77 # include <openssl/dsa.h>
78 # include <openssl/ecdsa.h>
79 # include <openssl/rsa.h>
80 #else
81 # include <openssl/core_names.h>
82 # include <openssl/param_build.h>
83 static OSSL_LIB_CTX *libctx = NULL;
84 #endif
85  
86 #include <openssl/bn.h>
87 #include <openssl/err.h>
88 #include <openssl/evp.h>
89  
90 #ifdef __cplusplus
91 }
92 #endif
93  
94  
95 #if (OPENSSL_API_LEVEL < 30500)
96 # define NO_MLDSA
97 #endif
98  
99 #ifdef OPENSSL_IS_BORINGSSL
100 # undef EOL
101 #endif
102  
103 #ifdef LIBRESSL_VERSION_NUMBER
104 # undef EOL
105 #endif
106  
107  
108 #define SV2BN(sv) BN_bin2bn( (unsigned char*) SvPVX(sv), SvCUR(sv), NULL )
109 #define UNDEF newSVpvn("",0)
110 #define UNUSED(sv) sv=sv;
111  
112 #define checkerr(arg) checkret( (arg), __LINE__ )
113 385 void checkret(const int ret, int line)
114 {
115 385 ▶ if ( ret <= 0 ) croak( "libcrypto error (%s line %d)", __FILE__, line );
Branch: 1 branch
BranchTrueFalseTotal
if ( ret <= 0 ) croak( "libcrypto error (%s line %d)", __FILE__, line ); 1 384 385
116 384 }
117  
118  
119 #ifdef EVP_PKEY_PUBLIC_KEY
120 59 int EVP_PKEY_fromparams(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection, OSSL_PARAM_BLD *bld)
121 {
122 int retval;
123 59 OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(bld);
124 59 checkerr( EVP_PKEY_fromdata_init(ctx) );
125 59 retval = EVP_PKEY_fromdata( ctx, ppkey, selection, params );
126 59 OSSL_PARAM_free(params);
127 59 return retval;
128 }
129 #endif
130  
131  
132 #ifdef EOL
133 6 char* selecttxt(int d1, int d2, char *txt)
134 { /* select text based on ISO date comparison */
135 6 ▶ return ( d1 > d2 ) ? txt : "";
Branch: 1 branch
BranchTrueFalseTotal
return ( d1 > d2 ) ? txt : ""; 3 3 6
136 }
137 #endif
138  
139  
140 MODULE = Net::DNS::SEC PACKAGE = Net::DNS::SEC::libcrypto
141  
142 PROTOTYPES: ENABLE
143  
144 SV*
145 VERSION(void)
146 INIT:
147 3 char *v = SvEND( newSVpv(XS_Id, 17) );
148 #ifdef EOL
149 3 time_t today = time( NULL );
150 char buf[10];
151 char *txt;
152 #endif
153 CODE:
154 #ifdef EOL
155 3 strftime( buf, sizeof buf, "%Y%m%d", gmtime(&today) );
156 3 txt = selecttxt( EOL, atoi(buf), "" ); /* get 100% coverage by calling this twice */
157 3 txt = selecttxt( atoi(buf), EOL, " [UNSUPPORTED]" );
158 3 RETVAL = newSVpvf( "%s %s%s", v-5, OPENSSL_VERSION_TEXT, txt );
159 #else
160 RETVAL = newSVpvf( "%s %s", v-5, OPENSSL_VERSION_TEXT );
161 #endif
162 OUTPUT:
163 RETVAL
164  
165  
166 #### EVP ####
167  
168 EVP_PKEY*
169 EVP_PKEY_new()
170  
171 SV*
172 EVP_sign(SV *message, EVP_PKEY *pkey, const EVP_MD *md=NULL)
173 INIT:
174 #define msgbuf (unsigned char*) SvPVX(message)
175 #define msglen SvCUR(message)
176 13 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
177 unsigned char sigbuf[2420]; /* ML-DSA-44 */
178 13 STRLEN buflen = sizeof(sigbuf);
179 int error;
180 CODE:
181 13 checkerr( EVP_DigestSignInit( ctx, NULL, md, NULL, pkey ) );
182 13 error = EVP_DigestSign( ctx, sigbuf, &buflen, msgbuf, msglen );
183 13 EVP_MD_CTX_free(ctx);
184 13 EVP_PKEY_free(pkey);
185 13 checkerr(error);
186 13 RETVAL = newSVpvn( (char*)sigbuf, buflen );
187 OUTPUT:
188 RETVAL
189  
190 int
191 EVP_verify(SV *message, SV *signature, EVP_PKEY *pkey, const EVP_MD *md=NULL)
192 INIT:
193 #define sigbuf (unsigned char*) SvPVX(signature)
194 #define siglen SvCUR(signature)
195 36 EVP_MD_CTX *ctx = EVP_MD_CTX_new();
196 CODE:
197 36 checkerr( EVP_DigestVerifyInit( ctx, NULL, md, NULL, pkey ) );
198 36 RETVAL = EVP_DigestVerify( ctx, sigbuf, siglen, msgbuf, msglen );
199 36 EVP_MD_CTX_free(ctx);
200 36 EVP_PKEY_free(pkey);
201 OUTPUT:
202 RETVAL
203  
204  
205 EVP_MD_CTX*
206 EVP_MD_CTX_new()
207  
208 void
209 EVP_MD_CTX_free(EVP_MD_CTX *ctx)
210  
211 void
212 EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
213 CODE:
214 18 checkerr( EVP_DigestInit( ctx, type ) );
215  
216 void
217 EVP_DigestUpdate(EVP_MD_CTX *ctx, SV *message)
218 CODE:
219 18 checkerr( EVP_DigestUpdate( ctx, msgbuf, msglen ) );
220  
221 SV*
222 EVP_DigestFinal(EVP_MD_CTX *ctx)
223 INIT:
224 unsigned char digest[EVP_MAX_MD_SIZE];
225 12 unsigned int size = sizeof(digest);
226 CODE:
227 12 checkerr( EVP_DigestFinal( ctx, digest, &size ) );
228 12 RETVAL = newSVpvn( (char*)digest, size );
229 OUTPUT:
230 RETVAL
231  
232  
233 const EVP_MD*
234 EVP_md5()
235  
236 const EVP_MD*
237 EVP_sha1()
238  
239 const EVP_MD*
240 EVP_sha224()
241  
242 const EVP_MD*
243 EVP_sha256()
244  
245 const EVP_MD*
246 EVP_sha384()
247  
248 const EVP_MD*
249 EVP_sha512()
250  
251  
252 #### DSA ####
253  
254 #ifndef NO_DSA
255  
256 EVP_PKEY*
257 EVP_PKEY_new_DSA(SV *p_SV, SV *q_SV, SV *g_SV, SV *y_SV, SV *x_SV=UNDEF )
258 INIT:
259 #ifdef API_1_1_1
260 DSA *dsa = DSA_new();
261 #else
262 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name( libctx, "DSA", NULL );
263 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
264 BIGNUM *p, *q, *g, *x, *y;
265 #endif
266 CODE:
267 #ifdef API_1_1_1
268 RETVAL = EVP_PKEY_new();
269 checkerr( DSA_set0_pqg( dsa, SV2BN(p_SV), SV2BN(q_SV), SV2BN(g_SV) ) );
270 checkerr( DSA_set0_key( dsa, SV2BN(y_SV), SV2BN(x_SV) ) );
271 checkerr( EVP_PKEY_assign( RETVAL, EVP_PKEY_DSA, (char*)dsa ) );
272 #else
273 RETVAL = NULL;
274 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_FFC_P, p=SV2BN(p_SV) ) );
275 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_FFC_Q, q=SV2BN(q_SV) ) );
276 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_FFC_G, g=SV2BN(g_SV) ) );
277 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_PUB_KEY, y=SV2BN(y_SV) ) );
278 if ( SvCUR(x_SV) > 0 ) {
279 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_PRIV_KEY, x=SV2BN(x_SV) ) );
280 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_KEYPAIR, bld ) );
281 BN_free(x);
282 } else {
283 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_PUBLIC_KEY, bld ) );
284 }
285 OSSL_PARAM_BLD_free(bld);
286 EVP_PKEY_CTX_free(ctx);
287 BN_free(p);
288 BN_free(q);
289 BN_free(g);
290 BN_free(y);
291 #endif
292 OUTPUT:
293 RETVAL
294  
295 #endif
296  
297  
298 #### RSA ####
299  
300 #ifndef NO_RSA
301  
302 EVP_PKEY*
303 EVP_PKEY_new_RSA(SV *n_SV, SV *e_SV, SV *d_SV=UNDEF, SV *p1_SV=UNDEF, SV *p2_SV=UNDEF, SV *e1_SV=UNDEF, SV *e2_SV=UNDEF, SV *c_SV=UNDEF )
304 INIT:
305 #ifdef API_1_1_1
306 RSA *rsa = RSA_new();
307 #else
308 37 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name( libctx, "RSA", NULL );
309 37 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
310 BIGNUM *n, *e, *d, *p1, *p2, *e1, *e2, *c;
311 #endif
312 CODE:
313 #ifdef API_1_1_1
314 RETVAL = EVP_PKEY_new();
315 checkerr( RSA_set0_factors( rsa, SV2BN(p1_SV), SV2BN(p2_SV) ) );
316 checkerr( RSA_set0_key( rsa, SV2BN(n_SV), SV2BN(e_SV), SV2BN(d_SV) ) );
317 checkerr( EVP_PKEY_assign( RETVAL, EVP_PKEY_RSA, (char*)rsa ) );
318 UNUSED(e1_SV); UNUSED(e2_SV); UNUSED(c_SV); /* suppress unused variable warnings */
319 #else
320 37 RETVAL = NULL;
321 37 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_N, n=SV2BN(n_SV) ) );
322 37 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_E, e=SV2BN(e_SV) ) );
323 37 ▶ if ( SvCUR(d_SV) > 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( SvCUR(d_SV) > 0 ) { 9 28 37
324 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_D, d=SV2BN(d_SV) ) );
325 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_FACTOR1, p1=SV2BN(p1_SV) ) );
326 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_FACTOR2, p2=SV2BN(p2_SV) ) );
327 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_EXPONENT1, e1=SV2BN(e1_SV) ) );
328 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_EXPONENT2, e2=SV2BN(e2_SV) ) );
329 9 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_RSA_COEFFICIENT1, c=SV2BN(c_SV) ) );
330 9 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_KEYPAIR, bld ) );
331 9 BN_free(d);
332 9 BN_free(p1);
333 9 BN_free(p2);
334 9 BN_free(e1);
335 9 BN_free(e2);
336 9 BN_free(c);
337 } else {
338 28 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_PUBLIC_KEY, bld ) );
339 }
340 37 OSSL_PARAM_BLD_free(bld);
341 37 EVP_PKEY_CTX_free(ctx);
342 37 BN_free(n);
343 37 BN_free(e);
344 #endif
345 OUTPUT:
346 RETVAL
347  
348 #endif
349  
350  
351 #### ECDSA ####
352  
353 #ifndef NO_ECDSA
354  
355 EVP_PKEY*
356 EVP_PKEY_new_ECDSA(SV *curve, SV *qx_SV, SV *qy_SV=UNDEF )
357 INIT:
358 #ifdef API_1_1_1
359 EC_KEY *eckey = NULL;
360 BIGNUM *qx, *qy;
361 #else
362 6 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name( libctx, "EC", NULL );
363 6 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
364 6 SV *ksv = newSVpvn("\4",1);
365 BIGNUM *qx;
366 #endif
367 6 char *name = SvPVX(curve);
368 CODE:
369 #ifdef API_1_1_1
370 RETVAL = EVP_PKEY_new();
371 if ( strcmp(name,"P-256") == 0 ) eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
372 if ( strcmp(name,"P-384") == 0 ) eckey = EC_KEY_new_by_curve_name(NID_secp384r1);
373 if ( SvCUR(qy_SV) > 0 ) {
374 checkerr( EC_KEY_set_public_key_affine_coordinates( eckey, qx=SV2BN(qx_SV), qy=SV2BN(qy_SV) ) );
375 BN_free(qx);
376 BN_free(qy);
377 } else {
378 checkerr( EC_KEY_set_private_key( eckey, qx=SV2BN(qx_SV) ) );
379 BN_clear_free(qx);
380 }
381 checkerr( EVP_PKEY_assign( RETVAL, EVP_PKEY_EC, (char*)eckey ) );
382 #else
383 6 RETVAL = NULL;
384 6 checkerr( OSSL_PARAM_BLD_push_utf8_string( bld, OSSL_PKEY_PARAM_GROUP_NAME, name, 0 ) );
385 6 ▶ if ( SvCUR(qy_SV) > 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( SvCUR(qy_SV) > 0 ) { 4 2 6
386 4 sv_catpvn_nomg(ksv, SvPVX(qx_SV), SvCUR(qx_SV));
387 4 sv_catpvn_nomg(ksv, SvPVX(qy_SV), SvCUR(qy_SV));
388 4 checkerr( OSSL_PARAM_BLD_push_octet_string( bld, OSSL_PKEY_PARAM_PUB_KEY, SvPVX(ksv), SvCUR(ksv) ) );
389 4 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_PUBLIC_KEY, bld ) );
390 } else {
391 2 checkerr( OSSL_PARAM_BLD_push_BN( bld, OSSL_PKEY_PARAM_PRIV_KEY, qx=SV2BN(qx_SV) ) );
392 2 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_KEYPAIR, bld ) );
393 2 BN_clear_free(qx);
394 }
395 6 OSSL_PARAM_BLD_free(bld);
396 6 EVP_PKEY_CTX_free(ctx);
397 #endif
398 OUTPUT:
399 RETVAL
400  
401 #endif
402  
403  
404 #### EdDSA ####
405  
406 #ifndef NO_EdDSA
407  
408 EVP_PKEY*
409 EVP_PKEY_new_EdDSA(SV *curve, SV *public, SV *private=NULL)
410 INIT:
411 #ifdef API_1_1_1
412 char *name = SvPVX(curve);
413 int nid = 0;
414 #else
415 16 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
416 16 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name( libctx, SvPVX(curve), NULL );
417 #endif
418 CODE:
419 16 RETVAL = NULL;
420 #ifdef API_1_1_1
421 if ( strcmp(name,"ED25519") == 0 ) nid = NID_ED25519;
422 #ifdef NID_ED448 /* not implemented in BoringSSL & LibreSSL */
423 if ( strcmp(name,"ED448") == 0 ) nid = NID_ED448;
424 #endif
425 if ( private == NULL ) {
426 RETVAL = EVP_PKEY_new_raw_public_key( nid, NULL, (unsigned char*) SvPVX(public), SvCUR(public) );
427 } else {
428 RETVAL = EVP_PKEY_new_raw_private_key( nid, NULL, (unsigned char*) SvPVX(private), SvCUR(private) );
429 }
430 #else
431 16 ▶ if ( private == NULL ) {
Branch: 1 branch
BranchTrueFalseTotal
if ( private == NULL ) { 14 2 16
432 14 checkerr( OSSL_PARAM_BLD_push_octet_string( bld, OSSL_PKEY_PARAM_PUB_KEY, SvPVX(public), SvCUR(public) ) );
433 14 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_PUBLIC_KEY, bld ) );
434 } else {
435 2 checkerr( OSSL_PARAM_BLD_push_octet_string( bld, OSSL_PKEY_PARAM_PRIV_KEY, SvPVX(private), SvCUR(private) ) );
436 2 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_KEYPAIR, bld ) );
437 }
438 16 OSSL_PARAM_BLD_free(bld);
439 16 EVP_PKEY_CTX_free(ctx);
440 #endif
441 OUTPUT:
442 RETVAL
443  
444 #endif
445  
446  
447 #### MLDSA ####
448  
449 #ifndef NO_MLDSA
450  
451 EVP_PKEY*
452 EVP_PKEY_new_MLDSA(SV *flavour, SV *rawkey)
453 INIT:
454 OSSL_PARAM_BLD *bld = OSSL_PARAM_BLD_new();
455 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name( libctx, SvPVX(flavour), NULL );
456 CODE:
457 RETVAL = NULL;
458 if ( SvCUR(rawkey) > 32 ) {
459 checkerr( OSSL_PARAM_BLD_push_octet_string( bld, OSSL_PKEY_PARAM_PUB_KEY, SvPVX(rawkey), SvCUR(rawkey) ) );
460 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_PUBLIC_KEY, bld ) );
461 } else {
462 checkerr( OSSL_PARAM_BLD_push_octet_string( bld, OSSL_PKEY_PARAM_ML_DSA_SEED, SvPVX(rawkey), SvCUR(rawkey) ) );
463 checkerr( EVP_PKEY_fromparams( ctx, &RETVAL, EVP_PKEY_KEYPAIR, bld ) );
464 }
465 OSSL_PARAM_BLD_free(bld);
466 EVP_PKEY_CTX_free(ctx);
467 OUTPUT:
468 RETVAL
469  
470 #endif
471  
472  
473 ####################
474  
475 void
476 checkerr(int ret)
477  
478  
479 #ifdef croak_memory_wrap
480 void
481 croak_memory_wrap()
482  
483 #endif
484  
485  
486 #ifdef DEBUG
487 void
488 ERR_print_errors(SV *filename)
489 CODE:
490 BIO *bio = BIO_new_file( SvPVX(filename), "w" );
491 ERR_print_errors(bio);
492 BIO_flush(bio);
493 BIO_free(bio);
494  
495 #endif
496  
497 ####################
498  
« blib/lib/Net/DNS/SEC/Digest.pm ↑ Summary blib/lib/Net/DNS/SEC/DSA.pm »