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

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

Diff Legend

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

Comparing OpenSSL/OpenSSL.xs (file contents): Revision 1.6 by root, Sat Oct 27 02:55:31 2001 UTC vs. Revision 1.11 by root, Sat Oct 27 03:29:43 2001 UTC

Diff Legend

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.6 by root, Sat Oct 27 02:55:31 2001 UTC vs.
Revision 1.11 by root, Sat Oct 27 03:29:43 2001 UTC