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.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}
… …
419 //key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0; 421 //key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;
420 OUTPUT: 422 OUTPUT:
421 RETVAL 423 RETVAL
422 424
423 425
424void 426OpenSSL::RSA
425new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d) 427new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
426 char *n 428 char *n
427 char *e 429 char *e
428 char *p 430 char *p
429 char *q 431 char *q
430 char *dmp1 432 char *dmp1
431 char *dmq1 433 char *dmq1
432 char *iqmp 434 char *iqmp
433 char *d 435 char *d
434 PREINIT: 436 CODE:
435 RSA *key;
436 int rc; 437 int rc;
437 PPCODE: 438
438 EXTEND(sp, 1);
439 PUSHs(sv_newmortal());
440 key = RSA_new(); 439 RETVAL = RSA_new();
441 if (!key) 440 if (!RETVAL)
442 croak("can't allocate key"); 441 croak("can't allocate key");
443 if(!(key->n = BN_new()) || !BN_dec2bn(&key->n, n)) { 442 if(!(RETVAL->n = BN_new()) || !BN_dec2bn(&RETVAL->n, n)) {
444 RSA_free(key); croak("can't initialize n"); 443 RSA_free(RETVAL); croak("can't initialize n");
445 } 444 }
446 if(!(key->e = BN_new()) || !BN_dec2bn(&key->e, e)) { 445 if(!(RETVAL->e = BN_new()) || !BN_dec2bn(&RETVAL->e, e)) {
447 RSA_free(key); croak("can't initialize e"); 446 RSA_free(RETVAL); croak("can't initialize e");
448 } 447 }
449 if(!(key->p = BN_new()) || !BN_dec2bn(&key->p, p)) { 448 if(!(RETVAL->p = BN_new()) || !BN_dec2bn(&RETVAL->p, p)) {
450 RSA_free(key); croak("can't initialize p"); 449 RSA_free(RETVAL); croak("can't initialize p");
451 } 450 }
452 if(!(key->q = BN_new()) || !BN_dec2bn(&key->q, q)) { 451 if(!(RETVAL->q = BN_new()) || !BN_dec2bn(&RETVAL->q, q)) {
453 RSA_free(key); croak("can't initialize q"); 452 RSA_free(RETVAL); croak("can't initialize q");
454 } 453 }
455 if(!(key->dmp1 = BN_new()) || !BN_dec2bn(&key->dmp1, dmp1)) { 454 if(!(RETVAL->dmp1 = BN_new()) || !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
456 RSA_free(key); croak("can't initialize dmp1"); 455 RSA_free(RETVAL); croak("can't initialize dmp1");
457 } 456 }
458 if(!(key->dmq1 = BN_new()) || !BN_dec2bn(&key->dmq1, dmq1)) { 457 if(!(RETVAL->dmq1 = BN_new()) || !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
459 RSA_free(key); croak("can't initialize dmq1"); 458 RSA_free(RETVAL); croak("can't initialize dmq1");
460 } 459 }
461 if(!(key->iqmp = BN_new()) || !BN_dec2bn(&key->iqmp, iqmp)) { 460 if(!(RETVAL->iqmp = BN_new()) || !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
462 RSA_free(key); croak("can't initialize iqmp"); 461 RSA_free(RETVAL); croak("can't initialize iqmp");
463 } 462 }
464 if(!(key->d = BN_new()) || !BN_dec2bn(&key->d, d)) { 463 if(!(RETVAL->d = BN_new()) || !BN_dec2bn(&RETVAL->d, d)) {
465 RSA_free(key); croak("can't initialize d"); 464 RSA_free(RETVAL); croak("can't initialize d");
466 } 465 }
467 if((rc = RSA_check_key(key)) != 1) { 466 if((rc = RSA_check_key(RETVAL)) != 1) {
468 RSA_free(key); croak("RSA_check_key failed (%d).", rc); 467 RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
469 } 468 }
470 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key); 469 OUTPUT:
470 RETVAL
471 471
472 472
473void 473void
474DESTROY(key) 474DESTROY(key)
475 OpenSSL::RSA key 475 OpenSSL::RSA key
… …
594void 594void
595STORABLE_freeze(key, cloning) 595STORABLE_freeze(key, cloning)
596 OpenSSL::RSA key 596 OpenSSL::RSA key
597 bool cloning 597 bool cloning
598PREINIT: 598PREINIT:
599 SV *sv;
600 STRLEN totlen; 599 STRLEN totlen;
601PPCODE: 600PPCODE:
602 if(cloning) 601 if(cloning)
603 return; 602 return;
604 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);
… …
885 ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L); 884 ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
886 OUTPUT: 885 OUTPUT:
887 RETVAL 886 RETVAL
888 887
889 888
890void 889OpenSSL::X509
891new_from_string(class,thing) 890new_from_string(class,thing)
892 SV *class 891 SV *class
893 SV *thing 892 SV *thing
894 ALIAS: 893 ALIAS:
895 new_from_file = 1 894 new_from_file = 1
896 PREINIT: 895 PREINIT:
897 BIO *bio; 896 BIO *bio;
898 X509 *x509;
899 STRLEN l; 897 STRLEN l;
900 char *p, *q = 0; 898 char *p;
901 PPCODE: 899 CODE:
902 p = SvPV (thing, l); 900 p = SvPV (thing, l);
903 if(ix == 1) { 901 if(ix == 1) {
904 bio = BIO_new_file(p, "r"); 902 bio = BIO_new_file(p, "r");
905 } else { 903 } else {
906 bio = BIO_new_mem_buf (p, l); 904 bio = BIO_new_mem_buf (p, l);
907 } 905 }
908 if(!bio) 906 if(!bio)
909 croak(ssl_error()); 907 croak(ssl_error());
910 908
911 x509 = PEM_read_bio_X509 (bio, 0, 0, 0); 909 RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
912 BIO_free (bio); 910 BIO_free (bio);
913 if(!x509) 911 if(!RETVAL)
914 croak("PEM_read_bio_X509: %s", ssl_error()); 912 croak("PEM_read_bio_X509: %s", ssl_error());
915 913
916 EXTEND(sp, 1); 914 OUTPUT:
917 PUSHs(sv_newmortal()); 915 RETVAL
918 sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
919 916
920void 917void
921DESTROY(x509) 918DESTROY(x509)
922 OpenSSL::X509 x509 919 OpenSSL::X509 x509
923 CODE: 920 CODE:
… …
945 942
946OpenSSL::Name 943OpenSSL::Name
947subject(x509) 944subject(x509)
948 OpenSSL::X509 x509 945 OpenSSL::X509 x509
949 CODE: 946 CODE:
950 RETVAL = X509_get_subject_name(x509); 947 RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
951 OUTPUT: 948 OUTPUT:
952 RETVAL 949 RETVAL
953 950
954OpenSSL::Name 951OpenSSL::Name
955issuer(x509) 952issuer(x509)
956 OpenSSL::X509 x509 953 OpenSSL::X509 x509
957 CODE: 954 CODE:
958 RETVAL = X509_get_issuer_name(x509); 955 RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
959 OUTPUT: 956 OUTPUT:
960 RETVAL 957 RETVAL
961 958
962 959
963char * 960SV *
964subject_txt(x509) 961subject_txt(x509)
965 OpenSSL::X509 x509 962 OpenSSL::X509 x509
966 CODE: 963 CODE:
967 RETVAL = ol(X509_get_subject_name(x509)); 964 RETVAL = ol(X509_get_subject_name(x509));
968 OUTPUT: 965 OUTPUT:
969 RETVAL 966 RETVAL
970 967
971 968
972char * 969SV *
973issuer_txt(x509) 970issuer_txt(x509)
974 OpenSSL::X509 x509 971 OpenSSL::X509 x509
975 CODE: 972 CODE:
976 RETVAL = ol(X509_get_issuer_name(x509)); 973 RETVAL = ol(X509_get_issuer_name(x509));
977 OUTPUT: 974 OUTPUT:
… …
1103 if(ctx) { 1100 if(ctx) {
1104 EVP_CIPHER_CTX_cleanup(ctx); 1101 EVP_CIPHER_CTX_cleanup(ctx);
1105 free(ctx); 1102 free(ctx);
1106 } 1103 }
1107 1104
1108void 1105OpenSSL::Cipher
1109new_decrypt(...) 1106new_decrypt(...)
1110 ALIAS: 1107 ALIAS:
1111 new_encrypt = 1 1108 new_encrypt = 1
1112 PREINIT: 1109 PREINIT:
1113 char *name; 1110 char *name;
1114 SV *svkey; 1111 SV *svkey;
1115 EVP_CIPHER *ci; 1112 EVP_CIPHER *ci;
1116 EVP_CIPHER_CTX *ctx;
1117 char *key; 1113 char *key;
1118 char iv[EVP_MAX_IV_LENGTH]; 1114 char iv[EVP_MAX_IV_LENGTH];
1119 char k[EVP_MAX_KEY_LENGTH]; 1115 char k[EVP_MAX_KEY_LENGTH];
1120 int rc; 1116 int rc;
1121 STRLEN keylen; 1117 STRLEN keylen;
1122 PPCODE: 1118 CODE:
1123 if(items < 2 || items > 3) { 1119 if(items < 2 || items > 3) {
1124 croak("usage: new_[en|de]crypt(ciphname,key)"); 1120 croak("usage: new_[en|de]crypt(ciphname,key)");
1125 } 1121 }
1126 name = SvPV_nolen(ST(items -2)); 1122 name = SvPV_nolen(ST(items -2));
1127 svkey = ST(items - 1); 1123 svkey = ST(items - 1);
1128 memset(iv, 0, EVP_MAX_IV_LENGTH); 1124 memset(iv, 0, EVP_MAX_IV_LENGTH);
1129 memset(k, 0, EVP_MAX_KEY_LENGTH); 1125 memset(k, 0, EVP_MAX_KEY_LENGTH);
1130 1126
1131 if(!(ci = lookup_cipher(name))) 1127 if(!(ci = lookup_cipher(name)))
1132 croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name); 1128 croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1133 ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX)); 1129 RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1134 if(!ctx) 1130 if(!RETVAL)
1135 croak("malloc error"); 1131 croak("malloc error");
1136 key = SvPV(svkey, keylen); 1132 key = SvPV(svkey, keylen);
1137 memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len); 1133 memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1138 rc = EVP_CipherInit(ctx, ci, k, iv, ix); 1134 rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1139 memset(iv, 0, EVP_MAX_IV_LENGTH); 1135 memset(iv, 0, EVP_MAX_IV_LENGTH);
1140 memset(iv, 0, EVP_MAX_KEY_LENGTH); 1136 memset(iv, 0, EVP_MAX_KEY_LENGTH);
1141 if(!rc) { 1137 if(!rc) {
1142 free(ctx); 1138 free(RETVAL);
1143 croak("EVP_CipherInit"); 1139 croak("EVP_CipherInit");
1144 } 1140 }
1145 EXTEND(sp, 1); 1141 OUTPUT:
1146 PUSHs(sv_newmortal()); 1142 RETVAL
1147 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1148 1143
1149 1144
1150SV * 1145SV *
1151update(ctx,svin) 1146update(ctx,svin)
1152 OpenSSL::Cipher ctx 1147 OpenSSL::Cipher ctx
1153 SV *svin 1148 SV *svin
1154 PREINIT: 1149 PREINIT:
1155 unsigned char *in, *out; 1150 unsigned char *in, *out;
1156 STRLEN il, ol; 1151 STRLEN il, ol;
1157 CODE: 1152 CODE:
1158 in = SvPV(svin, il); 1153 in = SvPV(svin, il);
1159 ol = (il + 63) & ~63; 1154 ol = (il + 63) & ~63;
1160 RETVAL = NEWSV(0, ol); 1155 RETVAL = NEWSV(0, ol);
1161 SvPOK_only(RETVAL); 1156 SvPOK_only(RETVAL);
1162 SvCUR_set(RETVAL, ol); 1157 SvCUR_set(RETVAL, ol);
1163 out = SvPV_nolen(RETVAL); 1158 out = SvPV_nolen(RETVAL);
1164 if(!out)
1165 croak("memory");
1166 if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) { 1159 if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) {
1167 sv_free(RETVAL); 1160 sv_free(RETVAL);
1168 croak("EVP_CipherUpdate"); 1161 croak("EVP_CipherUpdate");
1169 } 1162 }
1170 SvCUR_set(RETVAL, ol); 1163 SvCUR_set(RETVAL, ol);
… …
1215{ 1208{
1216 mds_boot(); 1209 mds_boot();
1217} 1210}
1218 1211
1219SV * 1212SV *
1220md2(sv) 1213md2(...)
1221 SV *sv
1222 ALIAS: 1214 ALIAS:
1223 md4 = 0x1 1215 md4 = 0x1
1224 md5 = 0x2 1216 md5 = 0x2
1225 sha = 0x3 1217 sha = 0x3
1226 sha1 = 0x4 1218 sha1 = 0x4
… …
1244 sha1_base64 = 0x24 1236 sha1_base64 = 0x24
1245 dss_base64 = 0x25 1237 dss_base64 = 0x25
1246 dss1_base64 = 0x26 1238 dss1_base64 = 0x26
1247 mdc2_base64 = 0x27 1239 mdc2_base64 = 0x27
1248 ripemd160_base64 = 0x28 1240 ripemd160_base64 = 0x28
1249 PREINIT: 1241 CODE:
1250 EVP_MD_CTX ctx; 1242 EVP_MD_CTX ctx;
1251 STRLEN l; 1243 STRLEN l;
1252 char *p; 1244 char *p;
1253 unsigned char md[EVP_MAX_MD_SIZE]; 1245 unsigned char md[EVP_MAX_MD_SIZE];
1254 unsigned int md_len; 1246 unsigned int md_len;
1255 CODE: 1247 int i;
1248
1256 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]); 1249 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
1250
1251 for (i = 0; i < items; i++)
1252 {
1257 p = SvPV(sv, l); 1253 p = SvPV(ST(i), l);
1258 EVP_DigestUpdate(&ctx, p, l); 1254 EVP_DigestUpdate(&ctx, p, l);
1255 }
1256
1259 EVP_DigestFinal(&ctx, md, &md_len); 1257 EVP_DigestFinal(&ctx, md, &md_len);
1260 switch(ix & ~15) { 1258 switch(ix & ~15) {
1261 case 0: 1259 case 0:
1262 RETVAL = newSVpvn(md, md_len); 1260 RETVAL = newSVpvn(md, md_len);
1263 break; 1261 break;
… …
1270 } 1268 }
1271 OUTPUT: 1269 OUTPUT:
1272 RETVAL 1270 RETVAL
1273 1271
1274 1272
1275void 1273OpenSSL::Digest
1276new_md2() 1274new_md2()
1277 ALIAS: 1275 ALIAS:
1278 new_md4 = 0x1 1276 new_md4 = 0x1
1279 new_md5 = 0x2 1277 new_md5 = 0x2
1280 mew_sha = 0x3 1278 mew_sha = 0x3
1281 new_sha1 = 0x4 1279 new_sha1 = 0x4
1282 new_dss = 0x5 1280 new_dss = 0x5
1283 new_dss1 = 0x6 1281 new_dss1 = 0x6
1284 new_mdc2 = 0x7 1282 new_mdc2 = 0x7
1285 new_ripemd160 = 0x8 1283 new_ripemd160 = 0x8
1286 PREINIT:
1287 EVP_MD_CTX *ctx;
1288 PPCODE: 1284 CODE:
1289 ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX)); 1285 RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1290 if(!ctx) 1286 if(!RETVAL)
1291 croak("out of memory."); 1287 croak("out of memory.");
1292 EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]); 1288 EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1293 EXTEND(sp, 1); 1289 OUTPUT:
1294 PUSHs(sv_newmortal()); 1290 RETVAL
1295 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1296
1297 1291
1298void 1292void
1299DESTROY(ctx) 1293DESTROY(ctx)
1300 OpenSSL::Digest ctx 1294 OpenSSL::Digest ctx
1301 CODE: 1295 CODE:
1302 if(ctx) 1296 if(ctx)
1303 free(ctx); 1297 free(ctx);
1304 1298
1305void 1299void
1306update(ctx, sv) 1300update(ctx, ...)
1307 OpenSSL::Digest ctx 1301 OpenSSL::Digest ctx
1308 SV *sv
1309 PREINIT: 1302 PREINIT:
1310 STRLEN l; 1303 STRLEN l;
1311 char *p; 1304 char *p;
1305 int i;
1312 CODE: 1306 CODE:
1313 p = SvPV(sv, l); 1307 for (i = 1; i < items; i++)
1314 EVP_DigestUpdate(ctx, p, l);
1315 1308 {
1309 p = SvPV(ST(i), l);
1310 EVP_DigestUpdate(ctx, p, l);
1311 }
1316 1312
1317SV * 1313SV *
1318final(ctx) 1314final(ctx)
1319 OpenSSL::Digest ctx 1315 OpenSSL::Digest ctx
1320 ALIAS: 1316 ALIAS:
… …
1378 dss_base64 = 0x25 1374 dss_base64 = 0x25
1379 dss1_base64 = 0x26 1375 dss1_base64 = 0x26
1380 mdc2_base64 = 0x27 1376 mdc2_base64 = 0x27
1381 ripemd160_base64 = 0x28 1377 ripemd160_base64 = 0x28
1382 PREINIT: 1378 PREINIT:
1383 HMAC_CTX ctx;
1384 STRLEN l, keylen; 1379 STRLEN l, keylen;
1385 char *p; 1380 char *p;
1386 char *key; 1381 char *key;
1387 unsigned char md[EVP_MAX_MD_SIZE]; 1382 unsigned char md[EVP_MAX_MD_SIZE];
1388 unsigned int md_len; 1383 unsigned int md_len;
… …
1404 } 1399 }
1405 OUTPUT: 1400 OUTPUT:
1406 RETVAL 1401 RETVAL
1407 1402
1408 1403
1409void 1404OpenSSL::Digest
1410new_md2(void) 1405new_md2()
1411 ALIAS: 1406 ALIAS:
1412 new_md4 = 0x1 1407 new_md4 = 0x1
1413 new_md5 = 0x2 1408 new_md5 = 0x2
1414 mew_sha = 0x3 1409 mew_sha = 0x3
1415 new_sha1 = 0x4 1410 new_sha1 = 0x4
1416 new_dss = 0x5 1411 new_dss = 0x5
1417 new_dss1 = 0x6 1412 new_dss1 = 0x6
1418 new_mdc2 = 0x7 1413 new_mdc2 = 0x7
1419 new_ripemd160 = 0x8 1414 new_ripemd160 = 0x8
1420 PREINIT:
1421 EVP_MD_CTX *ctx;
1422 PPCODE: 1415 CODE:
1423 ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX)); 1416 RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1424 if(!ctx) 1417 if(!RETVAL)
1425 croak("out of memory."); 1418 croak("out of memory.");
1426 EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]); 1419 EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1427 EXTEND(sp, 1); 1420 OUTPUT:
1428 PUSHs(sv_newmortal()); 1421 RETVAL
1429 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1430
1431 1422
1432void 1423void
1433DESTROY(ctx) 1424DESTROY(ctx)
1434 OpenSSL::Digest ctx 1425 OpenSSL::Digest ctx
1435 CODE: 1426 CODE:
1436 if(ctx) 1427 if(ctx)
1437 free(ctx); 1428 free(ctx);
1438 1429
1439void 1430void
1440update(ctx, sv) 1431update(ctx, ...)
1441 OpenSSL::Digest ctx 1432 OpenSSL::Digest ctx
1442 SV *sv
1443 PREINIT: 1433 PREINIT:
1444 STRLEN l; 1434 STRLEN l;
1445 char *p; 1435 char *p;
1436 int i;
1446 CODE: 1437 CODE:
1447 p = SvPV(sv, l); 1438 for (i = 1; i < items; i++)
1448 EVP_DigestUpdate(ctx, p, l);
1449 1439 {
1440 p = SvPV(ST(i), l);
1441 EVP_DigestUpdate(ctx, p, l);
1442 }
1450 1443
1451SV * 1444SV *
1452final(ctx) 1445final(ctx)
1453 OpenSSL::Digest ctx 1446 OpenSSL::Digest ctx
1454 ALIAS: 1447 ALIAS:
… …
1506 croak("PKCS12_new"); 1499 croak("PKCS12_new");
1507 } 1500 }
1508 OUTPUT: 1501 OUTPUT:
1509 RETVAL 1502 RETVAL
1510 1503
1511void 1504OpenSSL::PKCS12
1512new_from_string(class,sv) 1505new_from_string(class,sv)
1513 SV *class 1506 SV *class
1514 SV *sv 1507 SV *sv
1515 ALIAS: 1508 ALIAS:
1516 new_from_file = 1 1509 new_from_file = 1
1517 PREINIT: 1510 PREINIT:
1518 PKCS12 *p12;
1519 BIO *bio; 1511 BIO *bio;
1520 char *s; 1512 char *s;
1521 STRLEN len; 1513 STRLEN len;
1522 PPCODE: 1514 CODE:
1523 s = SvPV(sv, len); 1515 s = SvPV(sv, len);
1524 if(ix == 1) { 1516 if(ix == 1) {
1525 bio = BIO_new_file(s, "r"); 1517 bio = BIO_new_file(s, "r");
1526 } else { 1518 } else {
1527 bio = BIO_new_mem_buf (s, len); 1519 bio = BIO_new_mem_buf (s, len);
1528 } 1520 }
1529 if(!bio) 1521 if(!bio)
1530 croak("BIO_new_mem_buf"); 1522 croak("BIO_new_mem_buf");
1531 if(!(p12 = d2i_PKCS12_bio(bio, 0))) { 1523 if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1532 BIO_free(bio); 1524 BIO_free(bio);
1533 croak("d2i_PKCS12_BIO: %s", ssl_error()); 1525 croak("d2i_PKCS12_BIO: %s", ssl_error());
1534 } 1526 }
1535 BIO_free(bio); 1527 BIO_free(bio);
1536 EXTEND(sp, 1); 1528 OUTPUT:
1537 PUSHs(sv_newmortal()); 1529 RETVAL
1538 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1539 1530
1540 1531
1541SV* 1532SV*
1542mac_ok(p12, pwd) 1533mac_ok(p12, pwd)
1543 OpenSSL::PKCS12 p12 1534 OpenSSL::PKCS12 p12
… …
1570 OpenSSL::PKCS12 p12 1561 OpenSSL::PKCS12 p12
1571 ALIAS: 1562 ALIAS:
1572 as_file = 1 1563 as_file = 1
1573 PROTOTYPE: $;$ 1564 PROTOTYPE: $;$
1574 PREINIT: 1565 PREINIT:
1575 SV *sv;
1576 BIO *bio; 1566 BIO *bio;
1577 CODE: 1567 CODE:
1578 if((ix != 1 && items > 1) || (ix == 1 && items != 2)) 1568 if((ix != 1 && items > 1) || (ix == 1 && items != 2))
1579 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");
1580 if(items > 1) { 1570 if(items > 1) {
… …
1603 1593
1604 1594
1605MODULE = OpenSSL PACKAGE = OpenSSL::CRL 1595MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1606 1596
1607OpenSSL::CRL 1597OpenSSL::CRL
1608new_from_string(thing) 1598new_from_string(class,thing)
1599 SV *class
1609 SV *thing 1600 SV *thing
1610 ALIAS: 1601 ALIAS:
1611 new_from_file = 1 1602 new_from_file = 1
1612 PREINIT: 1603 PREINIT:
1613 BIO *bio; 1604 BIO *bio;
1614 STRLEN l; 1605 STRLEN l;
1615 char *p, *q = 0; 1606 char *p;
1616 CODE: 1607 CODE:
1617 p = SvPV(thing, l); 1608 p = SvPV(thing, l);
1618 if(ix == 1) { 1609 if(ix == 1) {
1619 bio = BIO_new_file(p, "r"); 1610 bio = BIO_new_file(p, "r");
1620 } else { 1611 } else {

Diff Legend

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