[ViewVC] Diff of: cvs/OpenSSL/OpenSSL.xs

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

…		…
32	#define XD(...)	32	#define XD(...)
33	#endif	33	#endif
34		34
35	static const char *ssl_error(void);	35	static 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
64	typedef X509 *OpenSSL__X509;	37	typedef X509 *OpenSSL__X509;
65	typedef X509_CRL *OpenSSL__CRL;	38	typedef X509_CRL *OpenSSL__CRL;
66	typedef X509_NAME *OpenSSL__Name;	39	typedef X509_NAME *OpenSSL__Name;
		40	typedef PKCS7 *OpenSSL__PKCS7;
		41	typedef PKCS12 *OpenSSL__PKCS12;
		42	typedef RSA *OpenSSL__RSA;
		43	typedef EVP_MD_CTX *OpenSSL__Digest;
		44	typedef EVP_CIPHER_CTX *OpenSSL__Cipher;
67		45
68	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)	46	static 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
415	MODULE = OpenSSL PACKAGE = OpenSSL::RSA	393	MODULE = OpenSSL PACKAGE = OpenSSL::RSA
416		394
417	void	395	OpenSSL::RSA
418	new_keygen(bits = 128, e = 35)	396	new_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
430	void	405	OpenSSL::RSA
431	new_pubkey(n, e)	406	new_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
452	void	424	OpenSSL::RSA
453	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	425	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
454	char *n	426	char *n
455	char *e	427	char *e
456	char *p	428	char *p
457	char *q	429	char *q
458	char *dmp1	430	char *dmp1
459	char *dmq1	431	char *dmq1
460	char *iqmp	432	char *iqmp
461	char *d	433	char *d
462	PREINIT:	434	CODE:
463	RSA *key;
464	int rc;	435	int rc;
465	PPCODE:	436
466	EXTEND(sp, 1);
467	PUSHs(sv_newmortal());
468	key = RSA_new();	437	RETVAL = RSA_new();
469	if (!key)	438	if (!RETVAL)
470	croak("can't allocate key");	439	croak("can't allocate key");
471	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	440	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
472	RSA_free(key); croak("can't initialize n");	441	RSA_free(RETVAL); croak("can't initialize n");
473	}	442	}
474	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	443	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
475	RSA_free(key); croak("can't initialize e");	444	RSA_free(RETVAL); croak("can't initialize e");
476	}	445	}
477	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	446	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
478	RSA_free(key); croak("can't initialize p");	447	RSA_free(RETVAL); croak("can't initialize p");
479	}	448	}
480	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	449	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
481	RSA_free(key); croak("can't initialize q");	450	RSA_free(RETVAL); croak("can't initialize q");
482	}	451	}
483	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	452	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
484	RSA_free(key); croak("can't initialize dmp1");	453	RSA_free(RETVAL); croak("can't initialize dmp1");
485	}	454	}
486	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	455	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
487	RSA_free(key); croak("can't initialize dmq1");	456	RSA_free(RETVAL); croak("can't initialize dmq1");
488	}	457	}
489	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	458	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
490	RSA_free(key); croak("can't initialize iqmp");	459	RSA_free(RETVAL); croak("can't initialize iqmp");
491	}	460	}
492	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	461	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
493	RSA_free(key); croak("can't initialize d");	462	RSA_free(RETVAL); croak("can't initialize d");
494	}	463	}
495	if((rc = RSA_check_key(key)) != 1) {	464	if((rc = RSA_check_key(RETVAL)) != 1) {
496	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	465	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
497	}	466	}
498	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	467	OUTPUT:
		468	RETVAL
499		469
500		470
501	void	471	void
502	DESTROY(key)	472	DESTROY(key)
503	RSA* key	473	OpenSSL::RSA key
504	CODE:	474	CODE:
505	if (key) {	475	if (key) {
506	XD("RSA_free(%p)\n", key);	476	XD("RSA_free(%p)\n", key);
507	RSA_free(key);	477	RSA_free(key);
508	}	478	}
509		479
510	IV	480	IV
511	keysize(key)	481	keysize(key)
512	RSA *key;	482	OpenSSL::RSA key;
513	CODE:	483	CODE:
514	if (!key \|\| !key->n)	484	if (!key \|\| !key->n)
515	croak("invalid key");	485	croak("invalid key");
516	RETVAL = BN_num_bits(key->n);	486	RETVAL = BN_num_bits(key->n);
517	OUTPUT:	487	OUTPUT:
518	RETVAL	488	RETVAL
519		489
520	bool	490	bool
521	check_key(key)	491	check_key(key)
522	RSA *key;	492	OpenSSL::RSA key;
523	PPCODE:	493	PPCODE:
524	if(!key)	494	if(!key)
525	XSRETURN_NO;	495	XSRETURN_NO;
526	if(RSA_check_key(key) == 1)	496	if(RSA_check_key(key) == 1)
527	XSRETURN_YES;	497	XSRETURN_YES;
528	XSRETURN_NO;	498	XSRETURN_NO;
529		499
530		500
531	BIGNUM *	501	BIGNUM *
532	n(key)	502	n(key)
533	RSA *key;	503	OpenSSL::RSA key;
534	ALIAS:	504	ALIAS:
535	e = 1	505	e = 1
536	d = 2	506	d = 2
537	p = 3	507	p = 3
538	q = 4	508	q = 4
…		…
563	RETVAL	533	RETVAL
564		534
565		535
566	bool	536	bool
567	is_privkey(key)	537	is_privkey(key)
568	RSA *key;	538	OpenSSL::RSA key;
569	CODE:	539	CODE:
570	RETVAL = is_privkey(key);	540	RETVAL = is_privkey(key);
571	OUTPUT:	541	OUTPUT:
572	RETVAL	542	RETVAL
573		543
…		…
619		589
620		590
621		591
622	void	592	void
623	STORABLE_freeze(key, cloning)	593	STORABLE_freeze(key, cloning)
624	RSA *key	594	OpenSSL::RSA key
625	bool cloning	595	bool cloning
626	PREINIT:	596	PREINIT:
627	SV *sv;	597	SV *sv;
628	STRLEN totlen;	598	STRLEN totlen;
629	PPCODE:	599	PPCODE:
…		…
676	}	646	}
677		647
678		648
679	SV *	649	SV *
680	public_encrypt(key, sv)	650	public_encrypt(key, sv)
681	RSA *key;	651	OpenSSL::RSA key;
682	SV *sv;	652	SV *sv;
683	ALIAS:	653	ALIAS:
684	encrypt = 4	654	encrypt = 4
685	public_decrypt = 1	655	public_decrypt = 1
686	verify = 5	656	verify = 5
…		…
719	RETVAL	689	RETVAL
720		690
721		691
722	void	692	void
723	fingerprint(key)	693	fingerprint(key)
724	RSA *key	694	OpenSSL::RSA key
725	PREINIT:	695	PREINIT:
726	char *x;	696	char *x;
727	char dig[SHA_DIGEST_LENGTH];	697	char dig[SHA_DIGEST_LENGTH];
728	int nlen, elen;	698	int nlen, elen;
729	PPCODE:	699	PPCODE:
…		…
913	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);	883	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
914	OUTPUT:	884	OUTPUT:
915	RETVAL	885	RETVAL
916		886
917		887
918	void	888	OpenSSL::X509
919	new_from_string(class,thing)	889	new_from_string(class,thing)
920	SV *class	890	SV *class
921	SV *thing	891	SV *thing
922	ALIAS:	892	ALIAS:
923	new_from_file = 1	893	new_from_file = 1
924	PREINIT:	894	PREINIT:
925	BIO *bio;	895	BIO *bio;
926	X509 *x509;
927	STRLEN l;	896	STRLEN l;
928	char p, q = 0;	897	char p, q = 0;
929	PPCODE:	898	CODE:
930	p = SvPV (thing, l);	899	p = SvPV (thing, l);
931	if(ix == 1) {	900	if(ix == 1) {
932	bio = BIO_new_file(p, "r");	901	bio = BIO_new_file(p, "r");
933	} else {	902	} else {
934	bio = BIO_new_mem_buf (p, l);	903	bio = BIO_new_mem_buf (p, l);
935	}	904	}
936	if(!bio)	905	if(!bio)
937	croak(ssl_error());	906	croak(ssl_error());
938		907
939	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	908	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
940	BIO_free (bio);	909	BIO_free (bio);
941	if(!x509)	910	if(!RETVAL)
942	croak("PEM_read_bio_X509: %s", ssl_error());	911	croak("PEM_read_bio_X509: %s", ssl_error());
943		912
944	EXTEND(sp, 1);	913	OUTPUT:
945	PUSHs(sv_newmortal());	914	RETVAL
946	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
947		915
948	void	916	void
949	DESTROY(x509)	917	DESTROY(x509)
950	OpenSSL::X509 x509	918	OpenSSL::X509 x509
951	CODE:	919	CODE:
…		…
973		941
974	OpenSSL::Name	942	OpenSSL::Name
975	subject(x509)	943	subject(x509)
976	OpenSSL::X509 x509	944	OpenSSL::X509 x509
977	CODE:	945	CODE:
978	RETVAL = X509_get_subject_name(x509);	946	RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
979	OUTPUT:	947	OUTPUT:
980	RETVAL	948	RETVAL
981		949
982	OpenSSL::Name	950	OpenSSL::Name
983	issuer(x509)	951	issuer(x509)
984	OpenSSL::X509 x509	952	OpenSSL::X509 x509
985	CODE:	953	CODE:
986	RETVAL = X509_get_issuer_name(x509);	954	RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
987	OUTPUT:	955	OUTPUT:
988	RETVAL	956	RETVAL
989		957
990		958
991	char *	959	char *
…		…
1124	cipher_boot();	1092	cipher_boot();
1125	}	1093	}
1126		1094
1127	void	1095	void
1128	DESTROY(ctx)	1096	DESTROY(ctx)
1129	EVP_CIPHER_CTX *ctx	1097	OpenSSL::Cipher ctx
1130	CODE:	1098	CODE:
1131	if(ctx) {	1099	if(ctx) {
1132	EVP_CIPHER_CTX_cleanup(ctx);	1100	EVP_CIPHER_CTX_cleanup(ctx);
1133	free(ctx);	1101	free(ctx);
1134	}	1102	}
1135		1103
1136	void	1104	OpenSSL::Cipher
1137	new_decrypt(...)	1105	new_decrypt(...)
1138	ALIAS:	1106	ALIAS:
1139	new_encrypt = 1	1107	new_encrypt = 1
1140	PREINIT:	1108	PREINIT:
1141	char *name;	1109	char *name;
1142	SV *svkey;	1110	SV *svkey;
1143	EVP_CIPHER *ci;	1111	EVP_CIPHER *ci;
1144	EVP_CIPHER_CTX *ctx;
1145	char *key;	1112	char *key;
1146	char iv[EVP_MAX_IV_LENGTH];	1113	char iv[EVP_MAX_IV_LENGTH];
1147	char k[EVP_MAX_KEY_LENGTH];	1114	char k[EVP_MAX_KEY_LENGTH];
1148	int rc;	1115	int rc;
1149	STRLEN keylen;	1116	STRLEN keylen;
1150	PPCODE:	1117	CODE:
1151	if(items < 2 \|\| items > 3) {	1118	if(items < 2 \|\| items > 3) {
1152	croak("usage: new_[en\|de]crypt(ciphname,key)");	1119	croak("usage: new_[en\|de]crypt(ciphname,key)");
1153	}	1120	}
1154	name = SvPV_nolen(ST(items -2));	1121	name = SvPV_nolen(ST(items -2));
1155	svkey = ST(items - 1);	1122	svkey = ST(items - 1);
1156	memset(iv, 0, EVP_MAX_IV_LENGTH);	1123	memset(iv, 0, EVP_MAX_IV_LENGTH);
1157	memset(k, 0, EVP_MAX_KEY_LENGTH);	1124	memset(k, 0, EVP_MAX_KEY_LENGTH);
1158		1125
1159	if(!(ci = lookup_cipher(name)))	1126	if(!(ci = lookup_cipher(name)))
1160	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1127	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1161	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1128	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1162	if(!ctx)	1129	if(!RETVAL)
1163	croak("malloc error");	1130	croak("malloc error");
1164	key = SvPV(svkey, keylen);	1131	key = SvPV(svkey, keylen);
1165	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1132	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1166	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1133	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1167	memset(iv, 0, EVP_MAX_IV_LENGTH);	1134	memset(iv, 0, EVP_MAX_IV_LENGTH);
1168	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1135	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1169	if(!rc) {	1136	if(!rc) {
1170	free(ctx);	1137	free(RETVAL);
1171	croak("EVP_CipherInit");	1138	croak("EVP_CipherInit");
1172	}	1139	}
1173	EXTEND(sp, 1);	1140	OUTPUT:
1174	PUSHs(sv_newmortal());	1141	RETVAL
1175	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1176		1142
1177		1143
1178	SV *	1144	SV *
1179	update(ctx,svin)	1145	update(ctx,svin)
1180	EVP_CIPHER_CTX *ctx	1146	OpenSSL::Cipher ctx
1181	SV *svin	1147	SV *svin
1182	PREINIT:	1148	PREINIT:
1183	unsigned char in, out;	1149	unsigned char in, out;
1184	STRLEN il, ol;	1150	STRLEN il, ol;
1185	CODE:	1151	CODE:
…		…
1199	OUTPUT:	1165	OUTPUT:
1200	RETVAL	1166	RETVAL
1201		1167
1202	SV *	1168	SV *
1203	final(ctx)	1169	final(ctx)
1204	EVP_CIPHER_CTX *ctx	1170	OpenSSL::Cipher ctx
1205	PREINIT:	1171	PREINIT:
1206	STRLEN ol;	1172	STRLEN ol;
1207	unsigned char *out;	1173	unsigned char *out;
1208	CODE:	1174	CODE:
1209	ol = 256;	1175	ol = 256;
…		…
1298	}	1264	}
1299	OUTPUT:	1265	OUTPUT:
1300	RETVAL	1266	RETVAL
1301		1267
1302		1268
1303	void	1269	OpenSSL::Digest
1304	new_md2()	1270	new_md2()
1305	ALIAS:	1271	ALIAS:
1306	new_md4 = 0x1	1272	new_md4 = 0x1
1307	new_md5 = 0x2	1273	new_md5 = 0x2
1308	mew_sha = 0x3	1274	mew_sha = 0x3
1309	new_sha1 = 0x4	1275	new_sha1 = 0x4
1310	new_dss = 0x5	1276	new_dss = 0x5
1311	new_dss1 = 0x6	1277	new_dss1 = 0x6
1312	new_mdc2 = 0x7	1278	new_mdc2 = 0x7
1313	new_ripemd160 = 0x8	1279	new_ripemd160 = 0x8
1314	PREINIT:
1315	EVP_MD_CTX *ctx;
1316	PPCODE:	1280	CODE:
1317	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1281	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1318	if(!ctx)	1282	if(!RETVAL)
1319	croak("out of memory.");	1283	croak("out of memory.");
1320	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1284	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1321	EXTEND(sp, 1);	1285	OUTPUT:
1322	PUSHs(sv_newmortal());	1286	RETVAL
1323	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1324
1325		1287
1326	void	1288	void
1327	DESTROY(ctx)	1289	DESTROY(ctx)
1328	EVP_MD_CTX *ctx	1290	OpenSSL::Digest ctx
1329	CODE:	1291	CODE:
1330	if(ctx)	1292	if(ctx)
1331	free(ctx);	1293	free(ctx);
1332		1294
1333	void	1295	void
1334	update(ctx, sv)	1296	update(ctx, sv)
1335	EVP_MD_CTX *ctx	1297	OpenSSL::Digest ctx
1336	SV *sv	1298	SV *sv
1337	PREINIT:	1299	PREINIT:
1338	STRLEN l;	1300	STRLEN l;
1339	char *p;	1301	char *p;
1340	CODE:	1302	CODE:
1341	p = SvPV(sv, l);	1303	p = SvPV(sv, l);
1342	EVP_DigestUpdate(ctx, p, l);	1304	EVP_DigestUpdate(ctx, p, l);
1343
1344		1305
1345	SV *	1306	SV *
1346	final(ctx)	1307	final(ctx)
1347	EVP_MD_CTX *ctx	1308	OpenSSL::Digest ctx
1348	ALIAS:	1309	ALIAS:
1349	final_hex = 1	1310	final_hex = 1
1350	final_base64 = 2	1311	final_base64 = 2
1351	PREINIT:	1312	PREINIT:
1352	unsigned char md[EVP_MAX_MD_SIZE];	1313	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1432	}	1393	}
1433	OUTPUT:	1394	OUTPUT:
1434	RETVAL	1395	RETVAL
1435		1396
1436		1397
1437	void	1398	OpenSSL::Digest
1438	new_md2(void)	1399	new_md2()
1439	ALIAS:	1400	ALIAS:
1440	new_md4 = 0x1	1401	new_md4 = 0x1
1441	new_md5 = 0x2	1402	new_md5 = 0x2
1442	mew_sha = 0x3	1403	mew_sha = 0x3
1443	new_sha1 = 0x4	1404	new_sha1 = 0x4
1444	new_dss = 0x5	1405	new_dss = 0x5
1445	new_dss1 = 0x6	1406	new_dss1 = 0x6
1446	new_mdc2 = 0x7	1407	new_mdc2 = 0x7
1447	new_ripemd160 = 0x8	1408	new_ripemd160 = 0x8
1448	PREINIT:
1449	EVP_MD_CTX *ctx;
1450	PPCODE:	1409	CODE:
1451	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1410	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1452	if(!ctx)	1411	if(!RETVAL)
1453	croak("out of memory.");	1412	croak("out of memory.");
1454	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1413	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1455	EXTEND(sp, 1);	1414	OUTPUT:
1456	PUSHs(sv_newmortal());	1415	RETVAL
1457	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1458
1459		1416
1460	void	1417	void
1461	DESTROY(ctx)	1418	DESTROY(ctx)
1462	EVP_MD_CTX *ctx	1419	OpenSSL::Digest ctx
1463	CODE:	1420	CODE:
1464	if(ctx)	1421	if(ctx)
1465	free(ctx);	1422	free(ctx);
1466		1423
1467	void	1424	void
1468	update(ctx, sv)	1425	update(ctx, sv)
1469	EVP_MD_CTX *ctx	1426	OpenSSL::Digest ctx
1470	SV *sv	1427	SV *sv
1471	PREINIT:	1428	PREINIT:
1472	STRLEN l;	1429	STRLEN l;
1473	char *p;	1430	char *p;
1474	CODE:	1431	CODE:
…		…
1476	EVP_DigestUpdate(ctx, p, l);	1433	EVP_DigestUpdate(ctx, p, l);
1477		1434
1478		1435
1479	SV *	1436	SV *
1480	final(ctx)	1437	final(ctx)
1481	EVP_MD_CTX *ctx	1438	OpenSSL::Digest ctx
1482	ALIAS:	1439	ALIAS:
1483	final_hex = 1	1440	final_hex = 1
1484	final_base64 = 2	1441	final_base64 = 2
1485	PREINIT:	1442	PREINIT:
1486	unsigned char md[EVP_MAX_MD_SIZE];	1443	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1502	RETVAL	1459	RETVAL
1503		1460
1504		1461
1505	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1462	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1506		1463
1507	void	1464	OpenSSL::PKCS7
1508	new()	1465	new()
1509	PREINIT:
1510	PKCS7 *p7;
1511	PPCODE:	1466	CODE:
1512	if(!(p7 = PKCS7_new())) {	1467	if(!(RETVAL = PKCS7_new())) {
1513	croak("PKCS7_new");	1468	croak("PKCS7_new");
1514	}	1469	}
1515	EXTEND(sp, 1);	1470	OUTPUT:
1516	PUSHs(sv_newmortal());	1471	RETVAL
1517	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1518		1472
1519		1473
1520	void	1474	void
1521	DESTROY(p7)	1475	DESTROY(p7)
1522	PKCS7 *p7;	1476	OpenSSL::PKCS7 p7;
1523	CODE:	1477	CODE:
1524	if(p7) {	1478	if(p7) {
1525	XD("PKCS7_free(%p)\n", p7);	1479	XD("PKCS7_free(%p)\n", p7);
1526	PKCS7_free(p7);	1480	PKCS7_free(p7);
1527	}	1481	}
1528		1482
1529		1483
1530	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1484	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1531		1485
1532	void	1486	OpenSSL::PKCS12
1533	new()	1487	new(class)
1534	PREINIT:	1488	SV *class
1535	PKCS12 *p12;
1536	PPCODE:	1489	CODE:
1537	if(!(p12 = PKCS12_new())) {	1490	if(!(RETVAL = PKCS12_new())) {
1538	croak("PKCS12_new");	1491	croak("PKCS12_new");
1539	}	1492	}
1540	EXTEND(sp, 1);	1493	OUTPUT:
1541	PUSHs(sv_newmortal());	1494	RETVAL
1542	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1543		1495
1544	void	1496	OpenSSL::PKCS12
1545	new_from_string(sv)	1497	new_from_string(class,sv)
		1498	SV *class
1546	SV *sv	1499	SV *sv
1547	ALIAS:	1500	ALIAS:
1548	new_from_file = 1	1501	new_from_file = 1
1549	PREINIT:	1502	PREINIT:
1550	PKCS12 *p12;
1551	BIO *bio;	1503	BIO *bio;
1552	char *s;	1504	char *s;
1553	STRLEN len;	1505	STRLEN len;
1554	PPCODE:	1506	CODE:
1555	s = SvPV(sv, len);	1507	s = SvPV(sv, len);
1556	if(ix == 1) {	1508	if(ix == 1) {
1557	bio = BIO_new_file(s, "r");	1509	bio = BIO_new_file(s, "r");
1558	} else {	1510	} else {
1559	bio = BIO_new_mem_buf (s, len);	1511	bio = BIO_new_mem_buf (s, len);
1560	}	1512	}
1561	if(!bio)	1513	if(!bio)
1562	croak("BIO_new_mem_buf");	1514	croak("BIO_new_mem_buf");
1563	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1515	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1564	BIO_free(bio);	1516	BIO_free(bio);
1565	croak("d2i_PKCS12_BIO: %s", ssl_error());	1517	croak("d2i_PKCS12_BIO: %s", ssl_error());
1566	}	1518	}
1567	BIO_free(bio);	1519	BIO_free(bio);
1568	EXTEND(sp, 1);	1520	OUTPUT:
1569	PUSHs(sv_newmortal());	1521	RETVAL
1570	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1571		1522
1572		1523
1573	SV*	1524	SV*
1574	mac_ok(p12, pwd)	1525	mac_ok(p12, pwd)
1575	PKCS12 *p12	1526	OpenSSL::PKCS12 p12
1576	char *pwd	1527	char *pwd
1577	CODE:	1528	CODE:
1578		1529
1579	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;	1530	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1580	OUTPUT:	1531	OUTPUT:
1581	RETVAL	1532	RETVAL
1582		1533
1583	void	1534	void
1584	changepass(p12, oldpwd, newpwd)	1535	changepass(p12, oldpwd, newpwd)
1585	PKCS12 *p12	1536	OpenSSL::PKCS12 p12
1586	SV *oldpwd	1537	SV *oldpwd
1587	SV *newpwd	1538	SV *newpwd
1588	PREINIT:	1539	PREINIT:
1589	char *op = 0;	1540	char *op = 0;
1590	char *np = 0;	1541	char *np = 0;
…		…
1597	croak("PKCS12_newpass: %s", ssl_error());	1548	croak("PKCS12_newpass: %s", ssl_error());
1598	}	1549	}
1599		1550
1600	SV*	1551	SV*
1601	as_string(p12,...)	1552	as_string(p12,...)
1602	PKCS12 *p12	1553	OpenSSL::PKCS12 p12
1603	ALIAS:	1554	ALIAS:
1604	as_file = 1	1555	as_file = 1
1605	PROTOTYPE: $;$	1556	PROTOTYPE: $;$
1606	PREINIT:	1557	PREINIT:
1607	SV *sv;	1558	SV *sv;
…		…
1624	OUTPUT:	1575	OUTPUT:
1625	RETVAL	1576	RETVAL
1626		1577
1627	void	1578	void
1628	DESTROY(p12)	1579	DESTROY(p12)
1629	PKCS12 *p12;	1580	OpenSSL::PKCS12 p12;
1630	CODE:	1581	CODE:
1631	if(p12) {	1582	if(p12) {
1632	XD("PKCS12_free(%p)\n", p12);	1583	XD("PKCS12_free(%p)\n", p12);
1633	PKCS12_free(p12);	1584	PKCS12_free(p12);
1634	}	1585	}

Diff Legend

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

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

Diff Legend

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