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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.10 by root, Sat Oct 27 03:27:06 2001 UTC vs.
Revision 1.17 by root, Sun Oct 28 03:29:11 2001 UTC

… …
91 } 91 }
92 sv_setpv(sv, buf); 92 sv_setpv(sv, buf);
93 return sv; 93 return sv;
94} 94}
95 95
96long fuck_cb(struct bio_st *bm, int m, const char *ptr, int l, long x, long y) 96long bio_write_cb(struct bio_st *bm, int m, const char *ptr, int l, long x, long y)
97{ 97{
98 if(m == BIO_CB_WRITE) { 98 if(m == BIO_CB_WRITE) {
99 SV *sv = (SV *) BIO_get_callback_arg(bm); 99 SV *sv = (SV *) BIO_get_callback_arg(bm);
100 sv_catpvn(sv, ptr, l); 100 sv_catpvn(sv, ptr, l);
101 } 101 }
… …
113 BIO *bio; 113 BIO *bio;
114 sv = newSVpvn("",0); 114 sv = newSVpvn("",0);
115 // mem is completely broken for write, so we use /dev/null 115 // mem is completely broken for write, so we use /dev/null
116 // and use callbacks-hooks 116 // and use callbacks-hooks
117 bio = BIO_new_file("/dev/null", "wb"); 117 bio = BIO_new_file("/dev/null", "wb");
118 BIO_set_callback(bio, fuck_cb); 118 BIO_set_callback(bio, bio_write_cb);
119 BIO_set_callback_arg(bio, (void *)sv); 119 BIO_set_callback_arg(bio, (void *)sv);
120 return bio; 120 return bio;
121} 121}
122 122
123static inline BIO *sv_bio_create_file(SV *filename) 123static inline BIO *sv_bio_create_file(SV *filename)
124{ 124{
125 char *fn;
126 STRLEN l; 125 STRLEN l;
127 126
128 return BIO_new_file(SvPV(filename, l), "wb"); 127 return BIO_new_file(SvPV(filename, l), "wb");
129} 128}
130 129
… …
292 sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':'); 291 sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');
293 } 292 }
294 return s; 293 return s;
295} 294}
296 295
297static inline char *ol(X509_NAME *x) 296static inline SV *ol(X509_NAME *x)
298{ 297{
299 static char buf[256]; 298 char *p;
300 X509_NAME_oneline(x, buf, 256); 299 SV *sv = newSVpvn("",0);
300 X509_NAME_oneline(x, (p=SvGROW(sv,8192)), 8192);
301 SvCUR_set(sv, strlen(p));
301 return buf; 302 return sv;
302} 303}
303 304
305#if 0
304static void run_sha1(char *digest, const char *msg, int msglen) 306static void run_sha1(char *digest, const char *msg, int msglen)
305{ 307{
306 SHA_CTX ctx; 308 SHA_CTX ctx;
307 309
308 if(!digest || !msg || msglen < 0) 310 if(!digest || !msg || msglen < 0)
309 croak("run_sha1: null pointer or illegal message len"); 311 croak("run_sha1: null pointer or illegal message len");
310 SHA1_Init(&ctx); 312 SHA1_Init(&ctx);
311 SHA1_Update(&ctx, msg, msglen); 313 SHA1_Update(&ctx, msg, msglen);
312 SHA1_Final(digest, &ctx); 314 SHA1_Final(digest, &ctx);
313} 315}
314 316#endif
315static bool is_privkey(RSA *key) 317static bool is_privkey(RSA *key)
316{ 318{
317 return (key->n && key->e && key->d && key->p && key->q 319 return (key->n && key->e && key->d && key->p && key->q
318 && key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0; 320 && key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
319} 321}
… …
592void 594void
593STORABLE_freeze(key, cloning) 595STORABLE_freeze(key, cloning)
594 OpenSSL::RSA key 596 OpenSSL::RSA key
595 bool cloning 597 bool cloning
596PREINIT: 598PREINIT:
597 SV *sv;
598 STRLEN totlen; 599 STRLEN totlen;
599PPCODE: 600PPCODE:
600 if(cloning) 601 if(cloning)
601 return; 602 return;
602 totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int); 603 totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);
… …
892 ALIAS: 893 ALIAS:
893 new_from_file = 1 894 new_from_file = 1
894 PREINIT: 895 PREINIT:
895 BIO *bio; 896 BIO *bio;
896 STRLEN l; 897 STRLEN l;
897 char *p, *q = 0; 898 char *p;
898 CODE: 899 CODE:
899 p = SvPV (thing, l); 900 p = SvPV (thing, l);
900 if(ix == 1) { 901 if(ix == 1) {
901 bio = BIO_new_file(p, "r"); 902 bio = BIO_new_file(p, "r");
902 } else { 903 } else {
… …
954 RETVAL = X509_NAME_dup (X509_get_issuer_name(x509)); 955 RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
955 OUTPUT: 956 OUTPUT:
956 RETVAL 957 RETVAL
957 958
958 959
959char * 960SV *
960subject_txt(x509) 961subject_txt(x509)
961 OpenSSL::X509 x509 962 OpenSSL::X509 x509
962 CODE: 963 CODE:
963 RETVAL = ol(X509_get_subject_name(x509)); 964 RETVAL = ol(X509_get_subject_name(x509));
964 OUTPUT: 965 OUTPUT:
965 RETVAL 966 RETVAL
966 967
967 968
968char * 969SV *
969issuer_txt(x509) 970issuer_txt(x509)
970 OpenSSL::X509 x509 971 OpenSSL::X509 x509
971 CODE: 972 CODE:
972 RETVAL = ol(X509_get_issuer_name(x509)); 973 RETVAL = ol(X509_get_issuer_name(x509));
973 OUTPUT: 974 OUTPUT:
… …
1142 1143
1143 1144
1144SV * 1145SV *
1145update(ctx,svin) 1146update(ctx,svin)
1146 OpenSSL::Cipher ctx 1147 OpenSSL::Cipher ctx
1147 SV *svin 1148 SV *svin
1148 PREINIT: 1149 PREINIT:
1149 unsigned char *in, *out; 1150 unsigned char *in, *out;
1150 STRLEN il, ol; 1151 STRLEN il, ol;
1151 CODE: 1152 CODE:
1152 in = SvPV(svin, il); 1153 in = SvPV(svin, il);
1153 ol = (il + 63) & ~63; 1154 ol = (il + 63) & ~63;
1154 RETVAL = NEWSV(0, ol); 1155 RETVAL = NEWSV(0, ol);
1155 SvPOK_only(RETVAL); 1156 SvPOK_only(RETVAL);
1156 SvCUR_set(RETVAL, ol); 1157 SvCUR_set(RETVAL, ol);
1157 out = SvPV_nolen(RETVAL); 1158 out = SvPV_nolen(RETVAL);
1158 if(!out)
1159 croak("memory");
1160 if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) { 1159 if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) {
1161 sv_free(RETVAL); 1160 sv_free(RETVAL);
1162 croak("EVP_CipherUpdate"); 1161 croak("EVP_CipherUpdate");
1163 } 1162 }
1164 SvCUR_set(RETVAL, ol); 1163 SvCUR_set(RETVAL, ol);
… …
1209{ 1208{
1210 mds_boot(); 1209 mds_boot();
1211} 1210}
1212 1211
1213SV * 1212SV *
1214md2(sv) 1213md2(...)
1215 SV *sv
1216 ALIAS: 1214 ALIAS:
1217 md4 = 0x1 1215 md4 = 0x1
1218 md5 = 0x2 1216 md5 = 0x2
1219 sha = 0x3 1217 sha = 0x3
1220 sha1 = 0x4 1218 sha1 = 0x4
… …
1238 sha1_base64 = 0x24 1236 sha1_base64 = 0x24
1239 dss_base64 = 0x25 1237 dss_base64 = 0x25
1240 dss1_base64 = 0x26 1238 dss1_base64 = 0x26
1241 mdc2_base64 = 0x27 1239 mdc2_base64 = 0x27
1242 ripemd160_base64 = 0x28 1240 ripemd160_base64 = 0x28
1243 PREINIT: 1241 CODE:
1244 EVP_MD_CTX ctx; 1242 EVP_MD_CTX ctx;
1245 STRLEN l; 1243 STRLEN l;
1246 char *p; 1244 char *p;
1247 unsigned char md[EVP_MAX_MD_SIZE]; 1245 unsigned char md[EVP_MAX_MD_SIZE];
1248 unsigned int md_len; 1246 unsigned int md_len;
1249 CODE: 1247 int i;
1248
1250 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]); 1249 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
1250
1251 for (i = 0; i < items; i++)
1252 {
1251 p = SvPV(sv, l); 1253 p = SvPV(ST(i), l);
1252 EVP_DigestUpdate(&ctx, p, l); 1254 EVP_DigestUpdate(&ctx, p, l);
1255 }
1256
1253 EVP_DigestFinal(&ctx, md, &md_len); 1257 EVP_DigestFinal(&ctx, md, &md_len);
1254 switch(ix & ~15) { 1258 switch(ix & ~15) {
1255 case 0: 1259 case 0:
1256 RETVAL = newSVpvn(md, md_len); 1260 RETVAL = newSVpvn(md, md_len);
1257 break; 1261 break;
… …
1291 CODE: 1295 CODE:
1292 if(ctx) 1296 if(ctx)
1293 free(ctx); 1297 free(ctx);
1294 1298
1295void 1299void
1296update(ctx, sv) 1300update(ctx, ...)
1297 OpenSSL::Digest ctx 1301 OpenSSL::Digest ctx
1298 SV *sv
1299 PREINIT: 1302 PREINIT:
1300 STRLEN l; 1303 STRLEN l;
1301 char *p; 1304 char *p;
1305 int i;
1302 CODE: 1306 CODE:
1303 p = SvPV(sv, l); 1307 for (i = 1; i < items; i++)
1308 {
1309 p = SvPV(ST(i), l);
1304 EVP_DigestUpdate(ctx, p, l); 1310 EVP_DigestUpdate(ctx, p, l);
1311 }
1305 1312
1306SV * 1313SV *
1307final(ctx) 1314final(ctx)
1308 OpenSSL::Digest ctx 1315 OpenSSL::Digest ctx
1309 ALIAS: 1316 ALIAS:
… …
1367 dss_base64 = 0x25 1374 dss_base64 = 0x25
1368 dss1_base64 = 0x26 1375 dss1_base64 = 0x26
1369 mdc2_base64 = 0x27 1376 mdc2_base64 = 0x27
1370 ripemd160_base64 = 0x28 1377 ripemd160_base64 = 0x28
1371 PREINIT: 1378 PREINIT:
1372 HMAC_CTX ctx;
1373 STRLEN l, keylen; 1379 STRLEN l, keylen;
1374 char *p; 1380 char *p;
1375 char *key; 1381 char *key;
1376 unsigned char md[EVP_MAX_MD_SIZE]; 1382 unsigned char md[EVP_MAX_MD_SIZE];
1377 unsigned int md_len; 1383 unsigned int md_len;
… …
1420 CODE: 1426 CODE:
1421 if(ctx) 1427 if(ctx)
1422 free(ctx); 1428 free(ctx);
1423 1429
1424void 1430void
1425update(ctx, sv) 1431update(ctx, ...)
1426 OpenSSL::Digest ctx 1432 OpenSSL::Digest ctx
1427 SV *sv
1428 PREINIT: 1433 PREINIT:
1429 STRLEN l; 1434 STRLEN l;
1430 char *p; 1435 char *p;
1436 int i;
1431 CODE: 1437 CODE:
1432 p = SvPV(sv, l); 1438 for (i = 1; i < items; i++)
1433 EVP_DigestUpdate(ctx, p, l);
1434 1439 {
1440 p = SvPV(ST(i), l);
1441 EVP_DigestUpdate(ctx, p, l);
1442 }
1435 1443
1436SV * 1444SV *
1437final(ctx) 1445final(ctx)
1438 OpenSSL::Digest ctx 1446 OpenSSL::Digest ctx
1439 ALIAS: 1447 ALIAS:
… …
1553 OpenSSL::PKCS12 p12 1561 OpenSSL::PKCS12 p12
1554 ALIAS: 1562 ALIAS:
1555 as_file = 1 1563 as_file = 1
1556 PROTOTYPE: $;$ 1564 PROTOTYPE: $;$
1557 PREINIT: 1565 PREINIT:
1558 SV *sv;
1559 BIO *bio; 1566 BIO *bio;
1560 CODE: 1567 CODE:
1561 if((ix != 1 && items > 1) || (ix == 1 && items != 2)) 1568 if((ix != 1 && items > 1) || (ix == 1 && items != 2))
1562 croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string"); 1569 croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");
1563 if(items > 1) { 1570 if(items > 1) {
… …
1586 1593
1587 1594
1588MODULE = OpenSSL PACKAGE = OpenSSL::CRL 1595MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1589 1596
1590OpenSSL::CRL 1597OpenSSL::CRL
1591new_from_string(thing) 1598new_from_string(class,thing)
1599 SV *class
1592 SV *thing 1600 SV *thing
1593 ALIAS: 1601 ALIAS:
1594 new_from_file = 1 1602 new_from_file = 1
1595 PREINIT: 1603 PREINIT:
1596 BIO *bio; 1604 BIO *bio;
1597 STRLEN l; 1605 STRLEN l;
1598 char *p, *q = 0; 1606 char *p;
1599 CODE: 1607 CODE:
1600 p = SvPV(thing, l); 1608 p = SvPV(thing, l);
1601 if(ix == 1) { 1609 if(ix == 1) {
1602 bio = BIO_new_file(p, "r"); 1610 bio = BIO_new_file(p, "r");
1603 } else { 1611 } else {

Diff Legend

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