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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.2 by root, Sat Oct 27 02:40:45 2001 UTC vs.
Revision 1.9 by root, Sat Oct 27 03:17:42 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(X509,"OpenSSL::X509")
59	GEN_IO(X509_CRL,"OpenSSL::CRL")
60	GEN_IO(X509_NAME, "OpenSSL::Name")
61	GEN_IO(PKCS12, "OpenSSL::PKCS12")
62	GEN_IO(PKCS7, "OpenSSL::PKCS7")
63	GEN_IO(RSA, "OpenSSL::RSA")
64	GEN_IO(EVP_MD_CTX, "OpenSSL::Digest")
65	GEN_IO(EVP_CIPHER_CTX, "OpenSSL::Cipher")
66
67	typedef X509 *OpenSSL__X509;	37	typedef X509 *OpenSSL__X509;
		38	typedef X509_CRL *OpenSSL__CRL;
		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;
68		45
69	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)	46	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)
70	{	47	{
71	if(!ai)	48	if(!ai)
72	croak("got 0-ptr");	49	croak("got 0-ptr");
…		…
413	}	390	}
414		391
415		392
416	MODULE = OpenSSL PACKAGE = OpenSSL::RSA	393	MODULE = OpenSSL PACKAGE = OpenSSL::RSA
417		394
418	void	395	OpenSSL::RSA
419	new_keygen(bits = 128, e = 35)	396	new_keygen(bits = 128, e = 35)
420	IV bits	397	IV bits
421	IV e	398	IV e
422	PREINIT:
423	RSA *key;
424	PPCODE:	399	CODE:
425	if(!(key = RSA_generate_key(bits, e, NULL, NULL)))	400	if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
426	croak("RSA_generate_key");	401	croak("RSA_generate_key");
427	EXTEND(sp, 1);	402	OUTPUT:
428	PUSHs(sv_newmortal());	403	RETVAL
429	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
430		404
431	void	405	OpenSSL::RSA
432	new_pubkey(n, e)	406	new_pubkey(n, e)
433	char *n	407	char *n
434	char *e	408	char *e
435	PREINIT:
436	RSA *key;
437	PPCODE:	409	CODE:
438	EXTEND(sp, 1);
439	PUSHs(sv_newmortal());
440	key = RSA_new();	410	RETVAL = RSA_new();
441	if (!key)	411	if (!RETVAL)
442	croak("can't allocate key");	412	croak("can't allocate key");
443	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	413	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
444	RSA_free(key); croak("can't initialize n");	414	RSA_free(RETVAL); croak("can't initialize n");
445	}	415	}
446	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	416	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
447	RSA_free(key); croak("can't initialize e");	417	RSA_free(RETVAL); croak("can't initialize e");
448	}	418	}
449	//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;
450	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	420	OUTPUT:
		421	RETVAL
451		422
452		423
453	void	424	OpenSSL::RSA
454	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	425	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
455	char *n	426	char *n
456	char *e	427	char *e
457	char *p	428	char *p
458	char *q	429	char *q
459	char *dmp1	430	char *dmp1
460	char *dmq1	431	char *dmq1
461	char *iqmp	432	char *iqmp
462	char *d	433	char *d
463	PREINIT:	434	CODE:
464	RSA *key;
465	int rc;	435	int rc;
466	PPCODE:	436
467	EXTEND(sp, 1);
468	PUSHs(sv_newmortal());
469	key = RSA_new();	437	RETVAL = RSA_new();
470	if (!key)	438	if (!RETVAL)
471	croak("can't allocate key");	439	croak("can't allocate key");
472	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	440	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
473	RSA_free(key); croak("can't initialize n");	441	RSA_free(RETVAL); croak("can't initialize n");
474	}	442	}
475	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	443	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
476	RSA_free(key); croak("can't initialize e");	444	RSA_free(RETVAL); croak("can't initialize e");
477	}	445	}
478	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	446	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
479	RSA_free(key); croak("can't initialize p");	447	RSA_free(RETVAL); croak("can't initialize p");
480	}	448	}
481	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	449	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
482	RSA_free(key); croak("can't initialize q");	450	RSA_free(RETVAL); croak("can't initialize q");
483	}	451	}
484	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	452	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
485	RSA_free(key); croak("can't initialize dmp1");	453	RSA_free(RETVAL); croak("can't initialize dmp1");
486	}	454	}
487	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	455	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
488	RSA_free(key); croak("can't initialize dmq1");	456	RSA_free(RETVAL); croak("can't initialize dmq1");
489	}	457	}
490	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	458	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
491	RSA_free(key); croak("can't initialize iqmp");	459	RSA_free(RETVAL); croak("can't initialize iqmp");
492	}	460	}
493	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	461	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
494	RSA_free(key); croak("can't initialize d");	462	RSA_free(RETVAL); croak("can't initialize d");
495	}	463	}
496	if((rc = RSA_check_key(key)) != 1) {	464	if((rc = RSA_check_key(RETVAL)) != 1) {
497	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	465	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
498	}	466	}
499	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	467	OUTPUT:
		468	RETVAL
500		469
501		470
502	void	471	void
503	DESTROY(key)	472	DESTROY(key)
504	RSA* key	473	OpenSSL::RSA key
505	CODE:	474	CODE:
506	if (key) {	475	if (key) {
507	XD("RSA_free(%p)\n", key);	476	XD("RSA_free(%p)\n", key);
508	RSA_free(key);	477	RSA_free(key);
509	}	478	}
510		479
511	IV	480	IV
512	keysize(key)	481	keysize(key)
513	RSA *key;	482	OpenSSL::RSA key;
514	CODE:	483	CODE:
515	if (!key \|\| !key->n)	484	if (!key \|\| !key->n)
516	croak("invalid key");	485	croak("invalid key");
517	RETVAL = BN_num_bits(key->n);	486	RETVAL = BN_num_bits(key->n);
518	OUTPUT:	487	OUTPUT:
519	RETVAL	488	RETVAL
520		489
521	bool	490	bool
522	check_key(key)	491	check_key(key)
523	RSA *key;	492	OpenSSL::RSA key;
524	PPCODE:	493	PPCODE:
525	if(!key)	494	if(!key)
526	XSRETURN_NO;	495	XSRETURN_NO;
527	if(RSA_check_key(key) == 1)	496	if(RSA_check_key(key) == 1)
528	XSRETURN_YES;	497	XSRETURN_YES;
529	XSRETURN_NO;	498	XSRETURN_NO;
530		499
531		500
532	BIGNUM *	501	BIGNUM *
533	n(key)	502	n(key)
534	RSA *key;	503	OpenSSL::RSA key;
535	ALIAS:	504	ALIAS:
536	e = 1	505	e = 1
537	d = 2	506	d = 2
538	p = 3	507	p = 3
539	q = 4	508	q = 4
…		…
564	RETVAL	533	RETVAL
565		534
566		535
567	bool	536	bool
568	is_privkey(key)	537	is_privkey(key)
569	RSA *key;	538	OpenSSL::RSA key;
570	CODE:	539	CODE:
571	RETVAL = is_privkey(key);	540	RETVAL = is_privkey(key);
572	OUTPUT:	541	OUTPUT:
573	RETVAL	542	RETVAL
574		543
…		…
620		589
621		590
622		591
623	void	592	void
624	STORABLE_freeze(key, cloning)	593	STORABLE_freeze(key, cloning)
625	RSA *key	594	OpenSSL::RSA key
626	bool cloning	595	bool cloning
627	PREINIT:	596	PREINIT:
628	SV *sv;	597	SV *sv;
629	STRLEN totlen;	598	STRLEN totlen;
630	PPCODE:	599	PPCODE:
…		…
677	}	646	}
678		647
679		648
680	SV *	649	SV *
681	public_encrypt(key, sv)	650	public_encrypt(key, sv)
682	RSA *key;	651	OpenSSL::RSA key;
683	SV *sv;	652	SV *sv;
684	ALIAS:	653	ALIAS:
685	encrypt = 4	654	encrypt = 4
686	public_decrypt = 1	655	public_decrypt = 1
687	verify = 5	656	verify = 5
…		…
720	RETVAL	689	RETVAL
721		690
722		691
723	void	692	void
724	fingerprint(key)	693	fingerprint(key)
725	RSA *key	694	OpenSSL::RSA key
726	PREINIT:	695	PREINIT:
727	char *x;	696	char *x;
728	char dig[SHA_DIGEST_LENGTH];	697	char dig[SHA_DIGEST_LENGTH];
729	int nlen, elen;	698	int nlen, elen;
730	PPCODE:	699	PPCODE:
…		…
741		710
742	MODULE = OpenSSL PACKAGE = OpenSSL::Name	711	MODULE = OpenSSL PACKAGE = OpenSSL::Name
743		712
744	PROTOTYPES: ENABLE	713	PROTOTYPES: ENABLE
745		714
746	void	715	OpenSSL::Name
747	new_name()	716	new(class)
748	PREINIT:	717	SV *class
749	X509_NAME *name;
750	PPCODE:	718	CODE:
751	if(!(name = X509_NAME_new())) {	719	if(!(RETVAL = X509_NAME_new())) {
752	croak("X509_NAME_new");	720	croak("X509_NAME_new");
753	}	721	}
754	EXTEND(sp, 1);	722	OUTPUT:
755	PUSHs(sv_newmortal());	723	RETVAL
756	sv_setref_pv(ST(0), "OpenSSL::Name", (void *) name);
757		724
758		725
759	void	726	void
760	add(name, key, string)	727	add(name, key, string)
761	X509_NAME *name	728	OpenSSL::Name name
762	SV *key	729	SV *key
763	SV *string	730	SV *string
764	PREINIT:	731	PREINIT:
765	STRLEN l, kl;	732	STRLEN l, kl;
766	char p, k;	733	char p, k;
…		…
776	if(!ok)	743	if(!ok)
777	croak("X509_NAME_add_entry_by_*: %s", ssl_error());	744	croak("X509_NAME_add_entry_by_*: %s", ssl_error());
778		745
779	IV	746	IV
780	count(name)	747	count(name)
781	X509_NAME *name	748	OpenSSL::Name name
782	CODE:	749	CODE:
783	RETVAL = X509_NAME_entry_count(name);	750	RETVAL = X509_NAME_entry_count(name);
784	OUTPUT:	751	OUTPUT:
785	RETVAL	752	RETVAL
786		753
787	void	754	void
788	getall(name)	755	getall(name)
789	X509_NAME *name	756	OpenSSL::Name name
790	PREINIT:	757	PREINIT:
791	int cnt, i;	758	int cnt, i;
792	X509_NAME_ENTRY *e;	759	X509_NAME_ENTRY *e;
793	int nid;	760	int nid;
794	ASN1_STRING *s;	761	ASN1_STRING *s;
…		…
803	s = X509_NAME_ENTRY_get_data(e);	770	s = X509_NAME_ENTRY_get_data(e);
804	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));	771	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));
805	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));	772	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));
806	}	773	}
807		774
808
809
810
811
812	void	775	void
813	DESTROY(name)	776	DESTROY(name)
814	X509_NAME *name	777	OpenSSL::Name name
815	CODE:	778	CODE:
816	if(name) {	779	if(name) {
817	XD("X509_NAME_free(%p)\n", name);	780	XD("X509_NAME_free(%p)\n", name);
818	X509_NAME_free(name);	781	X509_NAME_free(name);
819	}	782	}
…		…
902	ERR_load_DSA_strings();	865	ERR_load_DSA_strings();
903	ERR_load_RSA_strings();	866	ERR_load_RSA_strings();
904	}	867	}
905		868
906		869
907	void	870	OpenSSL::X509
908	new_X509()	871	new(class)
909	PREINIT:	872	SV *class
910	X509 *x509;	873	CODE:
911	PPCODE:
912	if((x509=X509_new()) == NULL)	874	if ((RETVAL = X509_new ()) == NULL)
913	croak("X509_new");	875	croak("X509_new");
		876
914	if(!X509_set_version(x509, 2)) {	877	if (!X509_set_version (RETVAL, 2))
915	X509_free(x509);	878	{
		879	X509_free (RETVAL);
916	croak("X509_set_version");	880	croak ("X509_set_version");
917	}	881	}
		882
918	ASN1_INTEGER_set(X509_get_serialNumber(x509),0L);	883	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
919	EXTEND(sp, 1);	884	OUTPUT:
920	PUSHs(sv_newmortal());	885	RETVAL
921	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
922		886
923		887
924	void	888	OpenSSL::X509
925	new_from_string(thing)	889	new_from_string(class,thing)
		890	SV *class
926	SV *thing	891	SV *thing
927	ALIAS:	892	ALIAS:
928	new_from_file = 1	893	new_from_file = 1
929	PREINIT:	894	PREINIT:
930	BIO *bio;	895	BIO *bio;
931	X509 *x509;
932	STRLEN l;	896	STRLEN l;
933	char p, q = 0;	897	char p, q = 0;
934	PPCODE:	898	CODE:
935	p = SvPV(thing, l);	899	p = SvPV (thing, l);
936	if(ix == 1) {	900	if(ix == 1) {
937	bio = BIO_new_file(p, "r");	901	bio = BIO_new_file(p, "r");
938	} else {	902	} else {
939	bio = BIO_new_mem_buf (p, l);	903	bio = BIO_new_mem_buf (p, l);
940	}	904	}
941	if(!bio)	905	if(!bio)
942	croak(ssl_error());	906	croak(ssl_error());
943		907
944	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	908	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
945	BIO_free (bio);	909	BIO_free (bio);
946	if(!x509)	910	if(!RETVAL)
947	croak("PEM_read_bio_X509: %s", ssl_error());	911	croak("PEM_read_bio_X509: %s", ssl_error());
948		912
949	EXTEND(sp, 1);	913	OUTPUT:
950	PUSHs(sv_newmortal());	914	RETVAL
951	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
952		915
953	void	916	void
954	DESTROY(x509)	917	DESTROY(x509)
955	OpenSSL::X509 x509	918	OpenSSL::X509 x509
956	CODE:	919	CODE:
957	if (x509) {	920	if (x509) {
958	XD("X509_free(%p)\n", x509);	921	XD("X509_free(%p)\n", x509);
959	X509_free(x509);	922	X509_free (x509);
960	x509 = 0;	923	x509 = 0;
961	}	924	}
962		925
963		926
964	char *	927	char *
…		…
974	RETVAL = dofp(x509, mds[ix]);	937	RETVAL = dofp(x509, mds[ix]);
975	OUTPUT:	938	OUTPUT:
976	RETVAL	939	RETVAL
977		940
978		941
979	X509_NAME *	942	OpenSSL::Name
980	subject(x509)	943	subject(x509)
981	OpenSSL::X509 x509	944	OpenSSL::X509 x509
982	CODE:	945	CODE:
983	RETVAL = X509_get_subject_name(x509);	946	RETVAL = X509_get_subject_name(x509);
984	OUTPUT:	947	OUTPUT:
985	RETVAL	948	RETVAL
986		949
987	X509_NAME *	950	OpenSSL::Name
988	issuer(x509)	951	issuer(x509)
989	OpenSSL::X509 x509	952	OpenSSL::X509 x509
990	CODE:	953	CODE:
991	RETVAL = X509_get_issuer_name(x509);	954	RETVAL = X509_get_issuer_name(x509);
992	OUTPUT:	955	OUTPUT:
…		…
1092	OUTPUT:	1055	OUTPUT:
1093	RETVAL	1056	RETVAL
1094		1057
1095	void	1058	void
1096	set_issuer(x509,name)	1059	set_issuer(x509,name)
1097	X509 *x509	1060	OpenSSL::X509 x509
1098	X509_NAME *name	1061	OpenSSL::Name name
1099	CODE:	1062	CODE:
1100	X509_set_issuer_name(x509, X509_NAME_dup(name));	1063	X509_set_issuer_name(x509, X509_NAME_dup(name));
1101		1064
1102	void	1065	void
1103	set_subject(x509,name)	1066	set_subject(x509,name)
1104	X509 *x509	1067	OpenSSL::X509 x509
1105	X509_NAME *name	1068	OpenSSL::Name name
1106	CODE:	1069	CODE:
1107	X509_set_subject_name(x509, X509_NAME_dup(name));	1070	X509_set_subject_name(x509, X509_NAME_dup(name));
1108		1071
1109	SV *	1072	SV *
1110	errstring(x509)	1073	errstring(x509)
…		…
1129	cipher_boot();	1092	cipher_boot();
1130	}	1093	}
1131		1094
1132	void	1095	void
1133	DESTROY(ctx)	1096	DESTROY(ctx)
1134	EVP_CIPHER_CTX *ctx	1097	OpenSSL::Cipher ctx
1135	CODE:	1098	CODE:
1136	if(ctx) {	1099	if(ctx) {
1137	EVP_CIPHER_CTX_cleanup(ctx);	1100	EVP_CIPHER_CTX_cleanup(ctx);
1138	free(ctx);	1101	free(ctx);
1139	}	1102	}
1140		1103
1141	void	1104	OpenSSL::Cipher
1142	new_decrypt(...)	1105	new_decrypt(...)
1143	ALIAS:	1106	ALIAS:
1144	new_encrypt = 1	1107	new_encrypt = 1
1145	PREINIT:	1108	PREINIT:
1146	char *name;	1109	char *name;
1147	SV *svkey;	1110	SV *svkey;
1148	EVP_CIPHER *ci;	1111	EVP_CIPHER *ci;
1149	EVP_CIPHER_CTX *ctx;
1150	char *key;	1112	char *key;
1151	char iv[EVP_MAX_IV_LENGTH];	1113	char iv[EVP_MAX_IV_LENGTH];
1152	char k[EVP_MAX_KEY_LENGTH];	1114	char k[EVP_MAX_KEY_LENGTH];
1153	int rc;	1115	int rc;
1154	STRLEN keylen;	1116	STRLEN keylen;
1155	PPCODE:	1117	CODE:
1156	if(items < 2 \|\| items > 3) {	1118	if(items < 2 \|\| items > 3) {
1157	croak("usage: new_[en\|de]crypt(ciphname,key)");	1119	croak("usage: new_[en\|de]crypt(ciphname,key)");
1158	}	1120	}
1159	name = SvPV_nolen(ST(items -2));	1121	name = SvPV_nolen(ST(items -2));
1160	svkey = ST(items - 1);	1122	svkey = ST(items - 1);
1161	memset(iv, 0, EVP_MAX_IV_LENGTH);	1123	memset(iv, 0, EVP_MAX_IV_LENGTH);
1162	memset(k, 0, EVP_MAX_KEY_LENGTH);	1124	memset(k, 0, EVP_MAX_KEY_LENGTH);
1163		1125
1164	if(!(ci = lookup_cipher(name)))	1126	if(!(ci = lookup_cipher(name)))
1165	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1127	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1166	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1128	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1167	if(!ctx)	1129	if(!RETVAL)
1168	croak("malloc error");	1130	croak("malloc error");
1169	key = SvPV(svkey, keylen);	1131	key = SvPV(svkey, keylen);
1170	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1132	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1171	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1133	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1172	memset(iv, 0, EVP_MAX_IV_LENGTH);	1134	memset(iv, 0, EVP_MAX_IV_LENGTH);
1173	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1135	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1174	if(!rc) {	1136	if(!rc) {
1175	free(ctx);	1137	free(RETVAL);
1176	croak("EVP_CipherInit");	1138	croak("EVP_CipherInit");
1177	}	1139	}
1178	EXTEND(sp, 1);	1140	OUTPUT:
1179	PUSHs(sv_newmortal());	1141	RETVAL
1180	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1181		1142
1182		1143
1183	SV *	1144	SV *
1184	update(ctx,svin)	1145	update(ctx,svin)
1185	EVP_CIPHER_CTX *ctx	1146	OpenSSL::Cipher ctx
1186	SV *svin	1147	SV *svin
1187	PREINIT:	1148	PREINIT:
1188	unsigned char in, out;	1149	unsigned char in, out;
1189	STRLEN il, ol;	1150	STRLEN il, ol;
1190	CODE:	1151	CODE:
…		…
1204	OUTPUT:	1165	OUTPUT:
1205	RETVAL	1166	RETVAL
1206		1167
1207	SV *	1168	SV *
1208	final(ctx)	1169	final(ctx)
1209	EVP_CIPHER_CTX *ctx	1170	OpenSSL::Cipher ctx
1210	PREINIT:	1171	PREINIT:
1211	STRLEN ol;	1172	STRLEN ol;
1212	unsigned char *out;	1173	unsigned char *out;
1213	CODE:	1174	CODE:
1214	ol = 256;	1175	ol = 256;
…		…
1303	}	1264	}
1304	OUTPUT:	1265	OUTPUT:
1305	RETVAL	1266	RETVAL
1306		1267
1307		1268
1308	void	1269	OpenSSL::Digest
1309	new_md2()	1270	new_md2()
1310	ALIAS:	1271	ALIAS:
1311	new_md4 = 0x1	1272	new_md4 = 0x1
1312	new_md5 = 0x2	1273	new_md5 = 0x2
1313	mew_sha = 0x3	1274	mew_sha = 0x3
1314	new_sha1 = 0x4	1275	new_sha1 = 0x4
1315	new_dss = 0x5	1276	new_dss = 0x5
1316	new_dss1 = 0x6	1277	new_dss1 = 0x6
1317	new_mdc2 = 0x7	1278	new_mdc2 = 0x7
1318	new_ripemd160 = 0x8	1279	new_ripemd160 = 0x8
1319	PREINIT:
1320	EVP_MD_CTX *ctx;
1321	PPCODE:	1280	CODE:
1322	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1281	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1323	if(!ctx)	1282	if(!RETVAL)
1324	croak("out of memory.");	1283	croak("out of memory.");
1325	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1284	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1326	EXTEND(sp, 1);	1285	OUTPUT:
1327	PUSHs(sv_newmortal());	1286	RETVAL
1328	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1329
1330		1287
1331	void	1288	void
1332	DESTROY(ctx)	1289	DESTROY(ctx)
1333	EVP_MD_CTX *ctx	1290	OpenSSL::Digest ctx
1334	CODE:	1291	CODE:
1335	if(ctx)	1292	if(ctx)
1336	free(ctx);	1293	free(ctx);
1337		1294
1338	void	1295	void
1339	update(ctx, sv)	1296	update(ctx, sv)
1340	EVP_MD_CTX *ctx	1297	OpenSSL::Digest ctx
1341	SV *sv	1298	SV *sv
1342	PREINIT:	1299	PREINIT:
1343	STRLEN l;	1300	STRLEN l;
1344	char *p;	1301	char *p;
1345	CODE:	1302	CODE:
1346	p = SvPV(sv, l);	1303	p = SvPV(sv, l);
1347	EVP_DigestUpdate(ctx, p, l);	1304	EVP_DigestUpdate(ctx, p, l);
1348
1349		1305
1350	SV *	1306	SV *
1351	final(ctx)	1307	final(ctx)
1352	EVP_MD_CTX *ctx	1308	OpenSSL::Digest ctx
1353	ALIAS:	1309	ALIAS:
1354	final_hex = 1	1310	final_hex = 1
1355	final_base64 = 2	1311	final_base64 = 2
1356	PREINIT:	1312	PREINIT:
1357	unsigned char md[EVP_MAX_MD_SIZE];	1313	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1437	}	1393	}
1438	OUTPUT:	1394	OUTPUT:
1439	RETVAL	1395	RETVAL
1440		1396
1441		1397
1442	void	1398	OpenSSL::Digest
1443	new_md2(void)	1399	new_md2()
1444	ALIAS:	1400	ALIAS:
1445	new_md4 = 0x1	1401	new_md4 = 0x1
1446	new_md5 = 0x2	1402	new_md5 = 0x2
1447	mew_sha = 0x3	1403	mew_sha = 0x3
1448	new_sha1 = 0x4	1404	new_sha1 = 0x4
1449	new_dss = 0x5	1405	new_dss = 0x5
1450	new_dss1 = 0x6	1406	new_dss1 = 0x6
1451	new_mdc2 = 0x7	1407	new_mdc2 = 0x7
1452	new_ripemd160 = 0x8	1408	new_ripemd160 = 0x8
1453	PREINIT:
1454	EVP_MD_CTX *ctx;
1455	PPCODE:	1409	CODE:
1456	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1410	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1457	if(!ctx)	1411	if(!RETVAL)
1458	croak("out of memory.");	1412	croak("out of memory.");
1459	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1413	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1460	EXTEND(sp, 1);	1414	OUTPUT:
1461	PUSHs(sv_newmortal());	1415	RETVAL
1462	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1463
1464		1416
1465	void	1417	void
1466	DESTROY(ctx)	1418	DESTROY(ctx)
1467	EVP_MD_CTX *ctx	1419	OpenSSL::Digest ctx
1468	CODE:	1420	CODE:
1469	if(ctx)	1421	if(ctx)
1470	free(ctx);	1422	free(ctx);
1471		1423
1472	void	1424	void
1473	update(ctx, sv)	1425	update(ctx, sv)
1474	EVP_MD_CTX *ctx	1426	OpenSSL::Digest ctx
1475	SV *sv	1427	SV *sv
1476	PREINIT:	1428	PREINIT:
1477	STRLEN l;	1429	STRLEN l;
1478	char *p;	1430	char *p;
1479	CODE:	1431	CODE:
…		…
1481	EVP_DigestUpdate(ctx, p, l);	1433	EVP_DigestUpdate(ctx, p, l);
1482		1434
1483		1435
1484	SV *	1436	SV *
1485	final(ctx)	1437	final(ctx)
1486	EVP_MD_CTX *ctx	1438	OpenSSL::Digest ctx
1487	ALIAS:	1439	ALIAS:
1488	final_hex = 1	1440	final_hex = 1
1489	final_base64 = 2	1441	final_base64 = 2
1490	PREINIT:	1442	PREINIT:
1491	unsigned char md[EVP_MAX_MD_SIZE];	1443	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1507	RETVAL	1459	RETVAL
1508		1460
1509		1461
1510	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1462	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1511		1463
1512	void	1464	OpenSSL::PKCS7
1513	new()	1465	new()
1514	PREINIT:
1515	PKCS7 *p7;
1516	PPCODE:	1466	CODE:
1517	if(!(p7 = PKCS7_new())) {	1467	if(!(RETVAL = PKCS7_new())) {
1518	croak("PKCS7_new");	1468	croak("PKCS7_new");
1519	}	1469	}
1520	EXTEND(sp, 1);	1470	OUTPUT:
1521	PUSHs(sv_newmortal());	1471	RETVAL
1522	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1523		1472
1524		1473
1525	void	1474	void
1526	DESTROY(p7)	1475	DESTROY(p7)
1527	PKCS7 *p7;	1476	OpenSSL::PKCS7 p7;
1528	CODE:	1477	CODE:
1529	if(p7) {	1478	if(p7) {
1530	XD("PKCS7_free(%p)\n", p7);	1479	XD("PKCS7_free(%p)\n", p7);
1531	PKCS7_free(p7);	1480	PKCS7_free(p7);
1532	}	1481	}
1533		1482
1534		1483
1535	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1484	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1536		1485
1537	void	1486	OpenSSL::PKCS12
1538	new()	1487	new(class)
1539	PREINIT:	1488	SV *class
1540	PKCS12 *p12;
1541	PPCODE:	1489	CODE:
1542	if(!(p12 = PKCS12_new())) {	1490	if(!(RETVAL = PKCS12_new())) {
1543	croak("PKCS12_new");	1491	croak("PKCS12_new");
1544	}	1492	}
1545	EXTEND(sp, 1);	1493	OUTPUT:
1546	PUSHs(sv_newmortal());	1494	RETVAL
1547	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1548		1495
1549	void	1496	OpenSSL::PKCS12
1550	new_from_string(sv)	1497	new_from_string(class,sv)
		1498	SV *class
1551	SV *sv	1499	SV *sv
1552	ALIAS:	1500	ALIAS:
1553	new_from_file = 1	1501	new_from_file = 1
1554	PREINIT:	1502	PREINIT:
1555	PKCS12 *p12;
1556	BIO *bio;	1503	BIO *bio;
1557	char *s;	1504	char *s;
1558	STRLEN len;	1505	STRLEN len;
1559	PPCODE:	1506	CODE:
1560	s = SvPV(sv, len);	1507	s = SvPV(sv, len);
1561	if(ix == 1) {	1508	if(ix == 1) {
1562	bio = BIO_new_file(s, "r");	1509	bio = BIO_new_file(s, "r");
1563	} else {	1510	} else {
1564	bio = BIO_new_mem_buf (s, len);	1511	bio = BIO_new_mem_buf (s, len);
1565	}	1512	}
1566	if(!bio)	1513	if(!bio)
1567	croak("BIO_new_mem_buf");	1514	croak("BIO_new_mem_buf");
1568	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1515	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1569	BIO_free(bio);	1516	BIO_free(bio);
1570	croak("d2i_PKCS12_BIO: %s", ssl_error());	1517	croak("d2i_PKCS12_BIO: %s", ssl_error());
1571	}	1518	}
1572	BIO_free(bio);	1519	BIO_free(bio);
1573	EXTEND(sp, 1);	1520	OUTPUT:
1574	PUSHs(sv_newmortal());	1521	RETVAL
1575	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1576		1522
1577		1523
1578	SV*	1524	SV*
1579	mac_ok(p12, pwd)	1525	mac_ok(p12, pwd)
1580	PKCS12 *p12	1526	OpenSSL::PKCS12 p12
1581	char *pwd	1527	char *pwd
1582	CODE:	1528	CODE:
1583		1529
1584	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;
1585	OUTPUT:	1531	OUTPUT:
1586	RETVAL	1532	RETVAL
1587		1533
1588	void	1534	void
1589	changepass(p12, oldpwd, newpwd)	1535	changepass(p12, oldpwd, newpwd)
1590	PKCS12 *p12	1536	OpenSSL::PKCS12 p12
1591	SV *oldpwd	1537	SV *oldpwd
1592	SV *newpwd	1538	SV *newpwd
1593	PREINIT:	1539	PREINIT:
1594	char *op = 0;	1540	char *op = 0;
1595	char *np = 0;	1541	char *np = 0;
…		…
1602	croak("PKCS12_newpass: %s", ssl_error());	1548	croak("PKCS12_newpass: %s", ssl_error());
1603	}	1549	}
1604		1550
1605	SV*	1551	SV*
1606	as_string(p12,...)	1552	as_string(p12,...)
1607	PKCS12 *p12	1553	OpenSSL::PKCS12 p12
1608	ALIAS:	1554	ALIAS:
1609	as_file = 1	1555	as_file = 1
1610	PROTOTYPE: $;$	1556	PROTOTYPE: $;$
1611	PREINIT:	1557	PREINIT:
1612	SV *sv;	1558	SV *sv;
…		…
1629	OUTPUT:	1575	OUTPUT:
1630	RETVAL	1576	RETVAL
1631		1577
1632	void	1578	void
1633	DESTROY(p12)	1579	DESTROY(p12)
1634	PKCS12 *p12;	1580	OpenSSL::PKCS12 p12;
1635	CODE:	1581	CODE:
1636	if(p12) {	1582	if(p12) {
1637	XD("PKCS12_free(%p)\n", p12);	1583	XD("PKCS12_free(%p)\n", p12);
1638	PKCS12_free(p12);	1584	PKCS12_free(p12);
1639	}	1585	}
1640		1586
1641		1587
1642	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1588	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1643		1589
1644	void	1590	OpenSSL::CRL
1645	new_from_string(thing)	1591	new_from_string(thing)
1646	SV *thing	1592	SV *thing
1647	ALIAS:	1593	ALIAS:
1648	new_from_file = 1	1594	new_from_file = 1
1649	PREINIT:	1595	PREINIT:
1650	BIO *bio;	1596	BIO *bio;
1651	X509_CRL *crl;
1652	STRLEN l;	1597	STRLEN l;
1653	char p, q = 0;	1598	char p, q = 0;
1654	PPCODE:	1599	CODE:
1655	p = SvPV(thing, l);	1600	p = SvPV(thing, l);
1656	if(ix == 1) {	1601	if(ix == 1) {
1657	bio = BIO_new_file(p, "r");	1602	bio = BIO_new_file(p, "r");
1658	} else {	1603	} else {
1659	bio = BIO_new_mem_buf (p, l);	1604	bio = BIO_new_mem_buf (p, l);
1660	}	1605	}
1661	if(!bio)	1606	if(!bio)
1662	croak(ssl_error());	1607	croak(ssl_error());
1663		1608
1664	crl = PEM_read_bio_X509_CRL (bio, 0, 0, 0);	1609	RETVAL = PEM_read_bio_X509_CRL (bio, 0, 0, 0);
1665	BIO_free (bio);	1610	BIO_free (bio);
1666	if(!crl)	1611	if(!RETVAL)
1667	croak("PEM_read_bio_X509_CRL: %s", ssl_error());	1612	croak("PEM_read_bio_X509_CRL: %s", ssl_error());
1668		1613
1669	EXTEND(sp, 1);	1614	OUTPUT:
1670	PUSHs(sv_newmortal());	1615	RETVAL
1671	sv_setref_pv(ST(0), "OpenSSL::CRL", (void *) crl);
1672		1616
1673	void	1617	void
1674	DESTROY(crl)	1618	DESTROY(crl)
1675	X509_CRL *crl	1619	OpenSSL::CRL crl
1676	CODE:	1620	CODE:
1677	if (crl) {	1621	if (crl) {
1678	XD("X509_CRL_free (%p)\n", crl);	1622	XD("X509_CRL_free (%p)\n", crl);
1679	X509_CRL_free(crl);	1623	X509_CRL_free(crl);
1680	crl = 0;	1624	crl = 0;
1681	}	1625	}
1682		1626
1683	SV*	1627	SV*
1684	info(crl)	1628	info(crl)
1685	X509_CRL *crl	1629	OpenSSL::CRL crl
1686	PREINIT:	1630	PREINIT:
1687	BIO *bio;	1631	BIO *bio;
1688	CODE:	1632	CODE:
1689	bio = sv_bio_create();	1633	bio = sv_bio_create();
1690	if(!X509_CRL_print(bio,crl)) {	1634	if(!X509_CRL_print(bio,crl)) {

Diff Legend

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

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

Diff Legend

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