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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.8 by root, Sat Oct 27 03:09:09 2001 UTC vs.
Revision 1.9 by root, Sat Oct 27 03:17:42 2001 UTC

… …
419 //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;
420 OUTPUT: 420 OUTPUT:
421 RETVAL 421 RETVAL
422 422
423 423
424void 424OpenSSL::RSA
425new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d) 425new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
426 char *n 426 char *n
427 char *e 427 char *e
428 char *p 428 char *p
429 char *q 429 char *q
430 char *dmp1 430 char *dmp1
431 char *dmq1 431 char *dmq1
432 char *iqmp 432 char *iqmp
433 char *d 433 char *d
434 PREINIT: 434 CODE:
435 RSA *key;
436 int rc; 435 int rc;
437 PPCODE: 436
438 EXTEND(sp, 1);
439 PUSHs(sv_newmortal());
440 key = RSA_new(); 437 RETVAL = RSA_new();
441 if (!key) 438 if (!RETVAL)
442 croak("can't allocate key"); 439 croak("can't allocate key");
443 if(!(key->n = BN_new()) || !BN_dec2bn(&key->n, n)) { 440 if(!(RETVAL->n = BN_new()) || !BN_dec2bn(&RETVAL->n, n)) {
444 RSA_free(key); croak("can't initialize n"); 441 RSA_free(RETVAL); croak("can't initialize n");
445 } 442 }
446 if(!(key->e = BN_new()) || !BN_dec2bn(&key->e, e)) { 443 if(!(RETVAL->e = BN_new()) || !BN_dec2bn(&RETVAL->e, e)) {
447 RSA_free(key); croak("can't initialize e"); 444 RSA_free(RETVAL); croak("can't initialize e");
448 } 445 }
449 if(!(key->p = BN_new()) || !BN_dec2bn(&key->p, p)) { 446 if(!(RETVAL->p = BN_new()) || !BN_dec2bn(&RETVAL->p, p)) {
450 RSA_free(key); croak("can't initialize p"); 447 RSA_free(RETVAL); croak("can't initialize p");
451 } 448 }
452 if(!(key->q = BN_new()) || !BN_dec2bn(&key->q, q)) { 449 if(!(RETVAL->q = BN_new()) || !BN_dec2bn(&RETVAL->q, q)) {
453 RSA_free(key); croak("can't initialize q"); 450 RSA_free(RETVAL); croak("can't initialize q");
454 } 451 }
455 if(!(key->dmp1 = BN_new()) || !BN_dec2bn(&key->dmp1, dmp1)) { 452 if(!(RETVAL->dmp1 = BN_new()) || !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
456 RSA_free(key); croak("can't initialize dmp1"); 453 RSA_free(RETVAL); croak("can't initialize dmp1");
457 } 454 }
458 if(!(key->dmq1 = BN_new()) || !BN_dec2bn(&key->dmq1, dmq1)) { 455 if(!(RETVAL->dmq1 = BN_new()) || !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
459 RSA_free(key); croak("can't initialize dmq1"); 456 RSA_free(RETVAL); croak("can't initialize dmq1");
460 } 457 }
461 if(!(key->iqmp = BN_new()) || !BN_dec2bn(&key->iqmp, iqmp)) { 458 if(!(RETVAL->iqmp = BN_new()) || !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
462 RSA_free(key); croak("can't initialize iqmp"); 459 RSA_free(RETVAL); croak("can't initialize iqmp");
463 } 460 }
464 if(!(key->d = BN_new()) || !BN_dec2bn(&key->d, d)) { 461 if(!(RETVAL->d = BN_new()) || !BN_dec2bn(&RETVAL->d, d)) {
465 RSA_free(key); croak("can't initialize d"); 462 RSA_free(RETVAL); croak("can't initialize d");
466 } 463 }
467 if((rc = RSA_check_key(key)) != 1) { 464 if((rc = RSA_check_key(RETVAL)) != 1) {
468 RSA_free(key); croak("RSA_check_key failed (%d).", rc); 465 RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
469 } 466 }
470 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key); 467 OUTPUT:
468 RETVAL
471 469
472 470
473void 471void
474DESTROY(key) 472DESTROY(key)
475 OpenSSL::RSA key 473 OpenSSL::RSA key
… …
885 ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L); 883 ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
886 OUTPUT: 884 OUTPUT:
887 RETVAL 885 RETVAL
888 886
889 887
890void 888OpenSSL::X509
891new_from_string(class,thing) 889new_from_string(class,thing)
892 SV *class 890 SV *class
893 SV *thing 891 SV *thing
894 ALIAS: 892 ALIAS:
895 new_from_file = 1 893 new_from_file = 1
896 PREINIT: 894 PREINIT:
897 BIO *bio; 895 BIO *bio;
898 X509 *x509;
899 STRLEN l; 896 STRLEN l;
900 char *p, *q = 0; 897 char *p, *q = 0;
901 PPCODE: 898 CODE:
902 p = SvPV (thing, l); 899 p = SvPV (thing, l);
903 if(ix == 1) { 900 if(ix == 1) {
904 bio = BIO_new_file(p, "r"); 901 bio = BIO_new_file(p, "r");
905 } else { 902 } else {
906 bio = BIO_new_mem_buf (p, l); 903 bio = BIO_new_mem_buf (p, l);
907 } 904 }
908 if(!bio) 905 if(!bio)
909 croak(ssl_error()); 906 croak(ssl_error());
910 907
911 x509 = PEM_read_bio_X509 (bio, 0, 0, 0); 908 RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
912 BIO_free (bio); 909 BIO_free (bio);
913 if(!x509) 910 if(!RETVAL)
914 croak("PEM_read_bio_X509: %s", ssl_error()); 911 croak("PEM_read_bio_X509: %s", ssl_error());
915 912
916 EXTEND(sp, 1); 913 OUTPUT:
917 PUSHs(sv_newmortal()); 914 RETVAL
918 sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
919 915
920void 916void
921DESTROY(x509) 917DESTROY(x509)
922 OpenSSL::X509 x509 918 OpenSSL::X509 x509
923 CODE: 919 CODE:
… …
1103 if(ctx) { 1099 if(ctx) {
1104 EVP_CIPHER_CTX_cleanup(ctx); 1100 EVP_CIPHER_CTX_cleanup(ctx);
1105 free(ctx); 1101 free(ctx);
1106 } 1102 }
1107 1103
1108void 1104OpenSSL::Cipher
1109new_decrypt(...) 1105new_decrypt(...)
1110 ALIAS: 1106 ALIAS:
1111 new_encrypt = 1 1107 new_encrypt = 1
1112 PREINIT: 1108 PREINIT:
1113 char *name; 1109 char *name;
1114 SV *svkey; 1110 SV *svkey;
1115 EVP_CIPHER *ci; 1111 EVP_CIPHER *ci;
1116 EVP_CIPHER_CTX *ctx;
1117 char *key; 1112 char *key;
1118 char iv[EVP_MAX_IV_LENGTH]; 1113 char iv[EVP_MAX_IV_LENGTH];
1119 char k[EVP_MAX_KEY_LENGTH]; 1114 char k[EVP_MAX_KEY_LENGTH];
1120 int rc; 1115 int rc;
1121 STRLEN keylen; 1116 STRLEN keylen;
1122 PPCODE: 1117 CODE:
1123 if(items < 2 || items > 3) { 1118 if(items < 2 || items > 3) {
1124 croak("usage: new_[en|de]crypt(ciphname,key)"); 1119 croak("usage: new_[en|de]crypt(ciphname,key)");
1125 } 1120 }
1126 name = SvPV_nolen(ST(items -2)); 1121 name = SvPV_nolen(ST(items -2));
1127 svkey = ST(items - 1); 1122 svkey = ST(items - 1);
1128 memset(iv, 0, EVP_MAX_IV_LENGTH); 1123 memset(iv, 0, EVP_MAX_IV_LENGTH);
1129 memset(k, 0, EVP_MAX_KEY_LENGTH); 1124 memset(k, 0, EVP_MAX_KEY_LENGTH);
1130 1125
1131 if(!(ci = lookup_cipher(name))) 1126 if(!(ci = lookup_cipher(name)))
1132 croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name); 1127 croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1133 ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX)); 1128 RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1134 if(!ctx) 1129 if(!RETVAL)
1135 croak("malloc error"); 1130 croak("malloc error");
1136 key = SvPV(svkey, keylen); 1131 key = SvPV(svkey, keylen);
1137 memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len); 1132 memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1138 rc = EVP_CipherInit(ctx, ci, k, iv, ix); 1133 rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1139 memset(iv, 0, EVP_MAX_IV_LENGTH); 1134 memset(iv, 0, EVP_MAX_IV_LENGTH);
1140 memset(iv, 0, EVP_MAX_KEY_LENGTH); 1135 memset(iv, 0, EVP_MAX_KEY_LENGTH);
1141 if(!rc) { 1136 if(!rc) {
1142 free(ctx); 1137 free(RETVAL);
1143 croak("EVP_CipherInit"); 1138 croak("EVP_CipherInit");
1144 } 1139 }
1145 EXTEND(sp, 1); 1140 OUTPUT:
1146 PUSHs(sv_newmortal()); 1141 RETVAL
1147 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1148 1142
1149 1143
1150SV * 1144SV *
1151update(ctx,svin) 1145update(ctx,svin)
1152 OpenSSL::Cipher ctx 1146 OpenSSL::Cipher ctx
… …
1270 } 1264 }
1271 OUTPUT: 1265 OUTPUT:
1272 RETVAL 1266 RETVAL
1273 1267
1274 1268
1275void 1269OpenSSL::Digest
1276new_md2() 1270new_md2()
1277 ALIAS: 1271 ALIAS:
1278 new_md4 = 0x1 1272 new_md4 = 0x1
1279 new_md5 = 0x2 1273 new_md5 = 0x2
1280 mew_sha = 0x3 1274 mew_sha = 0x3
1281 new_sha1 = 0x4 1275 new_sha1 = 0x4
1282 new_dss = 0x5 1276 new_dss = 0x5
1283 new_dss1 = 0x6 1277 new_dss1 = 0x6
1284 new_mdc2 = 0x7 1278 new_mdc2 = 0x7
1285 new_ripemd160 = 0x8 1279 new_ripemd160 = 0x8
1286 PREINIT:
1287 EVP_MD_CTX *ctx;
1288 PPCODE: 1280 CODE:
1289 ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX)); 1281 RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1290 if(!ctx) 1282 if(!RETVAL)
1291 croak("out of memory."); 1283 croak("out of memory.");
1292 EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]); 1284 EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1293 EXTEND(sp, 1); 1285 OUTPUT:
1294 PUSHs(sv_newmortal()); 1286 RETVAL
1295 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1296
1297 1287
1298void 1288void
1299DESTROY(ctx) 1289DESTROY(ctx)
1300 OpenSSL::Digest ctx 1290 OpenSSL::Digest ctx
1301 CODE: 1291 CODE:
… …
1310 STRLEN l; 1300 STRLEN l;
1311 char *p; 1301 char *p;
1312 CODE: 1302 CODE:
1313 p = SvPV(sv, l); 1303 p = SvPV(sv, l);
1314 EVP_DigestUpdate(ctx, p, l); 1304 EVP_DigestUpdate(ctx, p, l);
1315
1316 1305
1317SV * 1306SV *
1318final(ctx) 1307final(ctx)
1319 OpenSSL::Digest ctx 1308 OpenSSL::Digest ctx
1320 ALIAS: 1309 ALIAS:
… …
1404 } 1393 }
1405 OUTPUT: 1394 OUTPUT:
1406 RETVAL 1395 RETVAL
1407 1396
1408 1397
1409void 1398OpenSSL::Digest
1410new_md2(void) 1399new_md2()
1411 ALIAS: 1400 ALIAS:
1412 new_md4 = 0x1 1401 new_md4 = 0x1
1413 new_md5 = 0x2 1402 new_md5 = 0x2
1414 mew_sha = 0x3 1403 mew_sha = 0x3
1415 new_sha1 = 0x4 1404 new_sha1 = 0x4
1416 new_dss = 0x5 1405 new_dss = 0x5
1417 new_dss1 = 0x6 1406 new_dss1 = 0x6
1418 new_mdc2 = 0x7 1407 new_mdc2 = 0x7
1419 new_ripemd160 = 0x8 1408 new_ripemd160 = 0x8
1420 PREINIT:
1421 EVP_MD_CTX *ctx;
1422 PPCODE: 1409 CODE:
1423 ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX)); 1410 RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1424 if(!ctx) 1411 if(!RETVAL)
1425 croak("out of memory."); 1412 croak("out of memory.");
1426 EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]); 1413 EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1427 EXTEND(sp, 1); 1414 OUTPUT:
1428 PUSHs(sv_newmortal()); 1415 RETVAL
1429 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1430
1431 1416
1432void 1417void
1433DESTROY(ctx) 1418DESTROY(ctx)
1434 OpenSSL::Digest ctx 1419 OpenSSL::Digest ctx
1435 CODE: 1420 CODE:
… …
1506 croak("PKCS12_new"); 1491 croak("PKCS12_new");
1507 } 1492 }
1508 OUTPUT: 1493 OUTPUT:
1509 RETVAL 1494 RETVAL
1510 1495
1511void 1496OpenSSL::PKCS12
1512new_from_string(class,sv) 1497new_from_string(class,sv)
1513 SV *class 1498 SV *class
1514 SV *sv 1499 SV *sv
1515 ALIAS: 1500 ALIAS:
1516 new_from_file = 1 1501 new_from_file = 1
1517 PREINIT: 1502 PREINIT:
1518 PKCS12 *p12;
1519 BIO *bio; 1503 BIO *bio;
1520 char *s; 1504 char *s;
1521 STRLEN len; 1505 STRLEN len;
1522 PPCODE: 1506 CODE:
1523 s = SvPV(sv, len); 1507 s = SvPV(sv, len);
1524 if(ix == 1) { 1508 if(ix == 1) {
1525 bio = BIO_new_file(s, "r"); 1509 bio = BIO_new_file(s, "r");
1526 } else { 1510 } else {
1527 bio = BIO_new_mem_buf (s, len); 1511 bio = BIO_new_mem_buf (s, len);
1528 } 1512 }
1529 if(!bio) 1513 if(!bio)
1530 croak("BIO_new_mem_buf"); 1514 croak("BIO_new_mem_buf");
1531 if(!(p12 = d2i_PKCS12_bio(bio, 0))) { 1515 if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1532 BIO_free(bio); 1516 BIO_free(bio);
1533 croak("d2i_PKCS12_BIO: %s", ssl_error()); 1517 croak("d2i_PKCS12_BIO: %s", ssl_error());
1534 } 1518 }
1535 BIO_free(bio); 1519 BIO_free(bio);
1536 EXTEND(sp, 1); 1520 OUTPUT:
1537 PUSHs(sv_newmortal()); 1521 RETVAL
1538 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1539 1522
1540 1523
1541SV* 1524SV*
1542mac_ok(p12, pwd) 1525mac_ok(p12, pwd)
1543 OpenSSL::PKCS12 p12 1526 OpenSSL::PKCS12 p12

Diff Legend

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