ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/OpenSSL/OpenSSL.xs
(Generate patch)

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.7 by root, Sat Oct 27 02:57:53 2001 UTC vs.
Revision 1.8 by root, Sat Oct 27 03:09:09 2001 UTC

… …
32#define XD(...) 32#define XD(...)
33#endif 33#endif
34 34
35static const char *ssl_error(void); 35static const char *ssl_error(void);
36 36
37#define GEN_INPUT(type,class) \
38 static inline type * input_##type(SV *sv) { \
39 XD("GEN_INPUT " class " sv=%p\n", sv); \
40 if(sv_derived_from(sv, class)) \
41 return (type *) SvIV(SvRV(sv)); \
42 croak("Not a reference to a " class " object"); \
43 return (type *) 0; }
44
45
46#define GEN_OUTPUT(type,class) \
47 static inline SV* output_##type(type *foobar, SV *sv) { \
48 XD("GEN_OUTPUT " class " sv=%p\n", sv); \
49 return sv_setref_pv(sv, class, (void *) foobar); \
50 }
51
52
53#define GEN_IO(type,class) \
54 GEN_INPUT(type,class) \
55 GEN_OUTPUT(type,class)
56
57
58 GEN_IO(PKCS12, "OpenSSL::PKCS12")
59 GEN_IO(PKCS7, "OpenSSL::PKCS7")
60 GEN_IO(RSA, "OpenSSL::RSA")
61 GEN_IO(EVP_MD_CTX, "OpenSSL::Digest")
62 GEN_IO(EVP_CIPHER_CTX, "OpenSSL::Cipher")
63
64typedef X509 *OpenSSL__X509; 37typedef X509 *OpenSSL__X509;
65typedef X509_CRL *OpenSSL__CRL; 38typedef X509_CRL *OpenSSL__CRL;
66typedef X509_NAME *OpenSSL__Name; 39typedef X509_NAME *OpenSSL__Name;
40typedef PKCS7 *OpenSSL__PKCS7;
41typedef PKCS12 *OpenSSL__PKCS12;
42typedef RSA *OpenSSL__RSA;
43typedef EVP_MD_CTX *OpenSSL__Digest;
44typedef EVP_CIPHER_CTX *OpenSSL__Cipher;
67 45
68static inline SV* output_ASN1_INTEGER(ASN1_INTEGER *ai, SV *sv) 46static inline SV* output_ASN1_INTEGER(ASN1_INTEGER *ai, SV *sv)
69{ 47{
70 if(!ai) 48 if(!ai)
71 croak("got 0-ptr"); 49 croak("got 0-ptr");
… …
412} 390}
413 391
414 392
415MODULE = OpenSSL PACKAGE = OpenSSL::RSA 393MODULE = OpenSSL PACKAGE = OpenSSL::RSA
416 394
417void 395OpenSSL::RSA
418new_keygen(bits = 128, e = 35) 396new_keygen(bits = 128, e = 35)
419 IV bits 397 IV bits
420 IV e 398 IV e
421 PREINIT:
422 RSA *key;
423 PPCODE: 399 CODE:
424 if(!(key = RSA_generate_key(bits, e, NULL, NULL))) 400 if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
425 croak("RSA_generate_key"); 401 croak("RSA_generate_key");
426 EXTEND(sp, 1); 402 OUTPUT:
427 PUSHs(sv_newmortal()); 403 RETVAL
428 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
429 404
430void 405OpenSSL::RSA
431new_pubkey(n, e) 406new_pubkey(n, e)
432 char *n 407 char *n
433 char *e 408 char *e
434 PREINIT:
435 RSA *key;
436 PPCODE: 409 CODE:
437 EXTEND(sp, 1);
438 PUSHs(sv_newmortal());
439 key = RSA_new(); 410 RETVAL = RSA_new();
440 if (!key) 411 if (!RETVAL)
441 croak("can't allocate key"); 412 croak("can't allocate key");
442 if(!(key->n = BN_new()) || !BN_dec2bn(&key->n, n)) { 413 if(!(RETVAL->n = BN_new()) || !BN_dec2bn(&RETVAL->n, n)) {
443 RSA_free(key); croak("can't initialize n"); 414 RSA_free(RETVAL); croak("can't initialize n");
444 } 415 }
445 if(!(key->e = BN_new()) || !BN_dec2bn(&key->e, e)) { 416 if(!(RETVAL->e = BN_new()) || !BN_dec2bn(&RETVAL->e, e)) {
446 RSA_free(key); croak("can't initialize e"); 417 RSA_free(RETVAL); croak("can't initialize e");
447 } 418 }
448 //key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0; 419 //key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;
449 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key); 420 OUTPUT:
421 RETVAL
450 422
451 423
452void 424void
453new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d) 425new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
454 char *n 426 char *n
… …
498 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key); 470 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
499 471
500 472
501void 473void
502DESTROY(key) 474DESTROY(key)
503 RSA* key 475 OpenSSL::RSA key
504 CODE: 476 CODE:
505 if (key) { 477 if (key) {
506 XD("RSA_free(%p)\n", key); 478 XD("RSA_free(%p)\n", key);
507 RSA_free(key); 479 RSA_free(key);
508 } 480 }
509 481
510IV 482IV
511keysize(key) 483keysize(key)
512 RSA *key; 484 OpenSSL::RSA key;
513 CODE: 485 CODE:
514 if (!key || !key->n) 486 if (!key || !key->n)
515 croak("invalid key"); 487 croak("invalid key");
516 RETVAL = BN_num_bits(key->n); 488 RETVAL = BN_num_bits(key->n);
517OUTPUT: 489OUTPUT:
518 RETVAL 490 RETVAL
519 491
520bool 492bool
521check_key(key) 493check_key(key)
522 RSA *key; 494 OpenSSL::RSA key;
523PPCODE: 495PPCODE:
524 if(!key) 496 if(!key)
525 XSRETURN_NO; 497 XSRETURN_NO;
526 if(RSA_check_key(key) == 1) 498 if(RSA_check_key(key) == 1)
527 XSRETURN_YES; 499 XSRETURN_YES;
528 XSRETURN_NO; 500 XSRETURN_NO;
529 501
530 502
531BIGNUM * 503BIGNUM *
532n(key) 504n(key)
533 RSA *key; 505 OpenSSL::RSA key;
534 ALIAS: 506 ALIAS:
535 e = 1 507 e = 1
536 d = 2 508 d = 2
537 p = 3 509 p = 3
538 q = 4 510 q = 4
… …
563 RETVAL 535 RETVAL
564 536
565 537
566bool 538bool
567is_privkey(key) 539is_privkey(key)
568 RSA *key; 540 OpenSSL::RSA key;
569 CODE: 541 CODE:
570 RETVAL = is_privkey(key); 542 RETVAL = is_privkey(key);
571 OUTPUT: 543 OUTPUT:
572 RETVAL 544 RETVAL
573 545
… …
619 591
620 592
621 593
622void 594void
623STORABLE_freeze(key, cloning) 595STORABLE_freeze(key, cloning)
624 RSA *key 596 OpenSSL::RSA key
625 bool cloning 597 bool cloning
626PREINIT: 598PREINIT:
627 SV *sv; 599 SV *sv;
628 STRLEN totlen; 600 STRLEN totlen;
629PPCODE: 601PPCODE:
… …
676 } 648 }
677 649
678 650
679SV * 651SV *
680public_encrypt(key, sv) 652public_encrypt(key, sv)
681 RSA *key; 653 OpenSSL::RSA key;
682 SV *sv; 654 SV *sv;
683 ALIAS: 655 ALIAS:
684 encrypt = 4 656 encrypt = 4
685 public_decrypt = 1 657 public_decrypt = 1
686 verify = 5 658 verify = 5
… …
719 RETVAL 691 RETVAL
720 692
721 693
722void 694void
723fingerprint(key) 695fingerprint(key)
724 RSA *key 696 OpenSSL::RSA key
725 PREINIT: 697 PREINIT:
726 char *x; 698 char *x;
727 char dig[SHA_DIGEST_LENGTH]; 699 char dig[SHA_DIGEST_LENGTH];
728 int nlen, elen; 700 int nlen, elen;
729 PPCODE: 701 PPCODE:
… …
1124 cipher_boot(); 1096 cipher_boot();
1125} 1097}
1126 1098
1127void 1099void
1128DESTROY(ctx) 1100DESTROY(ctx)
1129 EVP_CIPHER_CTX *ctx 1101 OpenSSL::Cipher ctx
1130 CODE: 1102 CODE:
1131 if(ctx) { 1103 if(ctx) {
1132 EVP_CIPHER_CTX_cleanup(ctx); 1104 EVP_CIPHER_CTX_cleanup(ctx);
1133 free(ctx); 1105 free(ctx);
1134 } 1106 }
… …
1175 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx); 1147 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1176 1148
1177 1149
1178SV * 1150SV *
1179update(ctx,svin) 1151update(ctx,svin)
1180 EVP_CIPHER_CTX *ctx 1152 OpenSSL::Cipher ctx
1181 SV *svin 1153 SV *svin
1182 PREINIT: 1154 PREINIT:
1183 unsigned char *in, *out; 1155 unsigned char *in, *out;
1184 STRLEN il, ol; 1156 STRLEN il, ol;
1185 CODE: 1157 CODE:
… …
1199 OUTPUT: 1171 OUTPUT:
1200 RETVAL 1172 RETVAL
1201 1173
1202SV * 1174SV *
1203final(ctx) 1175final(ctx)
1204 EVP_CIPHER_CTX *ctx 1176 OpenSSL::Cipher ctx
1205 PREINIT: 1177 PREINIT:
1206 STRLEN ol; 1178 STRLEN ol;
1207 unsigned char *out; 1179 unsigned char *out;
1208 CODE: 1180 CODE:
1209 ol = 256; 1181 ol = 256;
… …
1323 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx); 1295 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1324 1296
1325 1297
1326void 1298void
1327DESTROY(ctx) 1299DESTROY(ctx)
1328 EVP_MD_CTX *ctx 1300 OpenSSL::Digest ctx
1329 CODE: 1301 CODE:
1330 if(ctx) 1302 if(ctx)
1331 free(ctx); 1303 free(ctx);
1332 1304
1333void 1305void
1334update(ctx, sv) 1306update(ctx, sv)
1335 EVP_MD_CTX *ctx 1307 OpenSSL::Digest ctx
1336 SV *sv 1308 SV *sv
1337 PREINIT: 1309 PREINIT:
1338 STRLEN l; 1310 STRLEN l;
1339 char *p; 1311 char *p;
1340 CODE: 1312 CODE:
… …
1342 EVP_DigestUpdate(ctx, p, l); 1314 EVP_DigestUpdate(ctx, p, l);
1343 1315
1344 1316
1345SV * 1317SV *
1346final(ctx) 1318final(ctx)
1347 EVP_MD_CTX *ctx 1319 OpenSSL::Digest ctx
1348 ALIAS: 1320 ALIAS:
1349 final_hex = 1 1321 final_hex = 1
1350 final_base64 = 2 1322 final_base64 = 2
1351 PREINIT: 1323 PREINIT:
1352 unsigned char md[EVP_MAX_MD_SIZE]; 1324 unsigned char md[EVP_MAX_MD_SIZE];
… …
1457 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx); 1429 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1458 1430
1459 1431
1460void 1432void
1461DESTROY(ctx) 1433DESTROY(ctx)
1462 EVP_MD_CTX *ctx 1434 OpenSSL::Digest ctx
1463 CODE: 1435 CODE:
1464 if(ctx) 1436 if(ctx)
1465 free(ctx); 1437 free(ctx);
1466 1438
1467void 1439void
1468update(ctx, sv) 1440update(ctx, sv)
1469 EVP_MD_CTX *ctx 1441 OpenSSL::Digest ctx
1470 SV *sv 1442 SV *sv
1471 PREINIT: 1443 PREINIT:
1472 STRLEN l; 1444 STRLEN l;
1473 char *p; 1445 char *p;
1474 CODE: 1446 CODE:
… …
1476 EVP_DigestUpdate(ctx, p, l); 1448 EVP_DigestUpdate(ctx, p, l);
1477 1449
1478 1450
1479SV * 1451SV *
1480final(ctx) 1452final(ctx)
1481 EVP_MD_CTX *ctx 1453 OpenSSL::Digest ctx
1482 ALIAS: 1454 ALIAS:
1483 final_hex = 1 1455 final_hex = 1
1484 final_base64 = 2 1456 final_base64 = 2
1485 PREINIT: 1457 PREINIT:
1486 unsigned char md[EVP_MAX_MD_SIZE]; 1458 unsigned char md[EVP_MAX_MD_SIZE];
… …
1502 RETVAL 1474 RETVAL
1503 1475
1504 1476
1505MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7 1477MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1506 1478
1507void 1479OpenSSL::PKCS7
1508new() 1480new()
1509 PREINIT:
1510 PKCS7 *p7;
1511 PPCODE: 1481 CODE:
1512 if(!(p7 = PKCS7_new())) { 1482 if(!(RETVAL = PKCS7_new())) {
1513 croak("PKCS7_new"); 1483 croak("PKCS7_new");
1514 } 1484 }
1515 EXTEND(sp, 1); 1485 OUTPUT:
1516 PUSHs(sv_newmortal()); 1486 RETVAL
1517 sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1518 1487
1519 1488
1520void 1489void
1521DESTROY(p7) 1490DESTROY(p7)
1522 PKCS7 *p7; 1491 OpenSSL::PKCS7 p7;
1523 CODE: 1492 CODE:
1524 if(p7) { 1493 if(p7) {
1525 XD("PKCS7_free(%p)\n", p7); 1494 XD("PKCS7_free(%p)\n", p7);
1526 PKCS7_free(p7); 1495 PKCS7_free(p7);
1527 } 1496 }
1528 1497
1529 1498
1530MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12 1499MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1531 1500
1532void 1501OpenSSL::PKCS12
1533new() 1502new(class)
1534 PREINIT: 1503 SV *class
1535 PKCS12 *p12;
1536 PPCODE: 1504 CODE:
1537 if(!(p12 = PKCS12_new())) { 1505 if(!(RETVAL = PKCS12_new())) {
1538 croak("PKCS12_new"); 1506 croak("PKCS12_new");
1539 } 1507 }
1540 EXTEND(sp, 1); 1508 OUTPUT:
1541 PUSHs(sv_newmortal()); 1509 RETVAL
1542 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1543 1510
1544void 1511void
1545new_from_string(sv) 1512new_from_string(class,sv)
1513 SV *class
1546 SV *sv 1514 SV *sv
1547 ALIAS: 1515 ALIAS:
1548 new_from_file = 1 1516 new_from_file = 1
1549 PREINIT: 1517 PREINIT:
1550 PKCS12 *p12; 1518 PKCS12 *p12;
… …
1570 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12); 1538 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1571 1539
1572 1540
1573SV* 1541SV*
1574mac_ok(p12, pwd) 1542mac_ok(p12, pwd)
1575 PKCS12 *p12 1543 OpenSSL::PKCS12 p12
1576 char *pwd 1544 char *pwd
1577 CODE: 1545 CODE:
1578 1546
1579 RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no; 1547 RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1580 OUTPUT: 1548 OUTPUT:
1581 RETVAL 1549 RETVAL
1582 1550
1583void 1551void
1584changepass(p12, oldpwd, newpwd) 1552changepass(p12, oldpwd, newpwd)
1585 PKCS12 *p12 1553 OpenSSL::PKCS12 p12
1586 SV *oldpwd 1554 SV *oldpwd
1587 SV *newpwd 1555 SV *newpwd
1588 PREINIT: 1556 PREINIT:
1589 char *op = 0; 1557 char *op = 0;
1590 char *np = 0; 1558 char *np = 0;
… …
1597 croak("PKCS12_newpass: %s", ssl_error()); 1565 croak("PKCS12_newpass: %s", ssl_error());
1598 } 1566 }
1599 1567
1600SV* 1568SV*
1601as_string(p12,...) 1569as_string(p12,...)
1602 PKCS12 *p12 1570 OpenSSL::PKCS12 p12
1603 ALIAS: 1571 ALIAS:
1604 as_file = 1 1572 as_file = 1
1605 PROTOTYPE: $;$ 1573 PROTOTYPE: $;$
1606 PREINIT: 1574 PREINIT:
1607 SV *sv; 1575 SV *sv;
… …
1624 OUTPUT: 1592 OUTPUT:
1625 RETVAL 1593 RETVAL
1626 1594
1627void 1595void
1628DESTROY(p12) 1596DESTROY(p12)
1629 PKCS12 *p12; 1597 OpenSSL::PKCS12 p12;
1630 CODE: 1598 CODE:
1631 if(p12) { 1599 if(p12) {
1632 XD("PKCS12_free(%p)\n", p12); 1600 XD("PKCS12_free(%p)\n", p12);
1633 PKCS12_free(p12); 1601 PKCS12_free(p12);
1634 } 1602 }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines