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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.3 by root, Sat Oct 27 02:43:28 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(X509_CRL,"OpenSSL::CRL")
59	GEN_IO(X509_NAME, "OpenSSL::Name")
60	GEN_IO(PKCS12, "OpenSSL::PKCS12")
61	GEN_IO(PKCS7, "OpenSSL::PKCS7")
62	GEN_IO(RSA, "OpenSSL::RSA")
63	GEN_IO(EVP_MD_CTX, "OpenSSL::Digest")
64	GEN_IO(EVP_CIPHER_CTX, "OpenSSL::Cipher")
65
66	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;
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:
…		…
740		710
741	MODULE = OpenSSL PACKAGE = OpenSSL::Name	711	MODULE = OpenSSL PACKAGE = OpenSSL::Name
742		712
743	PROTOTYPES: ENABLE	713	PROTOTYPES: ENABLE
744		714
745	void	715	OpenSSL::Name
746	new_name()	716	new(class)
747	PREINIT:	717	SV *class
748	X509_NAME *name;
749	PPCODE:	718	CODE:
750	if(!(name = X509_NAME_new())) {	719	if(!(RETVAL = X509_NAME_new())) {
751	croak("X509_NAME_new");	720	croak("X509_NAME_new");
752	}	721	}
753	EXTEND(sp, 1);	722	OUTPUT:
754	PUSHs(sv_newmortal());	723	RETVAL
755	sv_setref_pv(ST(0), "OpenSSL::Name", (void *) name);
756		724
757		725
758	void	726	void
759	add(name, key, string)	727	add(name, key, string)
760	X509_NAME *name	728	OpenSSL::Name name
761	SV *key	729	SV *key
762	SV *string	730	SV *string
763	PREINIT:	731	PREINIT:
764	STRLEN l, kl;	732	STRLEN l, kl;
765	char p, k;	733	char p, k;
…		…
775	if(!ok)	743	if(!ok)
776	croak("X509_NAME_add_entry_by_*: %s", ssl_error());	744	croak("X509_NAME_add_entry_by_*: %s", ssl_error());
777		745
778	IV	746	IV
779	count(name)	747	count(name)
780	X509_NAME *name	748	OpenSSL::Name name
781	CODE:	749	CODE:
782	RETVAL = X509_NAME_entry_count(name);	750	RETVAL = X509_NAME_entry_count(name);
783	OUTPUT:	751	OUTPUT:
784	RETVAL	752	RETVAL
785		753
786	void	754	void
787	getall(name)	755	getall(name)
788	X509_NAME *name	756	OpenSSL::Name name
789	PREINIT:	757	PREINIT:
790	int cnt, i;	758	int cnt, i;
791	X509_NAME_ENTRY *e;	759	X509_NAME_ENTRY *e;
792	int nid;	760	int nid;
793	ASN1_STRING *s;	761	ASN1_STRING *s;
…		…
802	s = X509_NAME_ENTRY_get_data(e);	770	s = X509_NAME_ENTRY_get_data(e);
803	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));	771	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));
804	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));	772	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));
805	}	773	}
806		774
807
808
809
810
811	void	775	void
812	DESTROY(name)	776	DESTROY(name)
813	X509_NAME *name	777	OpenSSL::Name name
814	CODE:	778	CODE:
815	if(name) {	779	if(name) {
816	XD("X509_NAME_free(%p)\n", name);	780	XD("X509_NAME_free(%p)\n", name);
817	X509_NAME_free(name);	781	X509_NAME_free(name);
818	}	782	}
…		…
901	ERR_load_DSA_strings();	865	ERR_load_DSA_strings();
902	ERR_load_RSA_strings();	866	ERR_load_RSA_strings();
903	}	867	}
904		868
905		869
906	void	870	OpenSSL::X509
907	new_X509()	871	new(class)
908	PREINIT:	872	SV *class
909	X509 *x509;	873	CODE:
910	PPCODE:
911	if((x509=X509_new()) == NULL)	874	if ((RETVAL = X509_new ()) == NULL)
912	croak("X509_new");	875	croak("X509_new");
		876
913	if(!X509_set_version(x509, 2)) {	877	if (!X509_set_version (RETVAL, 2))
914	X509_free(x509);	878	{
		879	X509_free (RETVAL);
915	croak("X509_set_version");	880	croak ("X509_set_version");
916	}	881	}
		882
917	ASN1_INTEGER_set(X509_get_serialNumber(x509),0L);	883	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
918	EXTEND(sp, 1);	884	OUTPUT:
919	PUSHs(sv_newmortal());	885	RETVAL
920	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
921		886
922		887
923	void	888	OpenSSL::X509
924	new_from_string(thing)	889	new_from_string(class,thing)
		890	SV *class
925	SV *thing	891	SV *thing
926	ALIAS:	892	ALIAS:
927	new_from_file = 1	893	new_from_file = 1
928	PREINIT:	894	PREINIT:
929	BIO *bio;	895	BIO *bio;
930	X509 *x509;
931	STRLEN l;	896	STRLEN l;
932	char p, q = 0;	897	char p, q = 0;
933	PPCODE:	898	CODE:
934	p = SvPV(thing, l);	899	p = SvPV (thing, l);
935	if(ix == 1) {	900	if(ix == 1) {
936	bio = BIO_new_file(p, "r");	901	bio = BIO_new_file(p, "r");
937	} else {	902	} else {
938	bio = BIO_new_mem_buf (p, l);	903	bio = BIO_new_mem_buf (p, l);
939	}	904	}
940	if(!bio)	905	if(!bio)
941	croak(ssl_error());	906	croak(ssl_error());
942		907
943	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	908	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
944	BIO_free (bio);	909	BIO_free (bio);
945	if(!x509)	910	if(!RETVAL)
946	croak("PEM_read_bio_X509: %s", ssl_error());	911	croak("PEM_read_bio_X509: %s", ssl_error());
947		912
948	EXTEND(sp, 1);	913	OUTPUT:
949	PUSHs(sv_newmortal());	914	RETVAL
950	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
951		915
952	void	916	void
953	DESTROY(x509)	917	DESTROY(x509)
954	OpenSSL::X509 x509	918	OpenSSL::X509 x509
955	CODE:	919	CODE:
956	if (x509) {	920	if (x509) {
957	XD("X509_free(%p)\n", x509);	921	XD("X509_free(%p)\n", x509);
958	X509_free(x509);	922	X509_free (x509);
959	x509 = 0;	923	x509 = 0;
960	}	924	}
961		925
962		926
963	char *	927	char *
…		…
973	RETVAL = dofp(x509, mds[ix]);	937	RETVAL = dofp(x509, mds[ix]);
974	OUTPUT:	938	OUTPUT:
975	RETVAL	939	RETVAL
976		940
977		941
978	X509_NAME *	942	OpenSSL::Name
979	subject(x509)	943	subject(x509)
980	OpenSSL::X509 x509	944	OpenSSL::X509 x509
981	CODE:	945	CODE:
982	RETVAL = X509_get_subject_name(x509);	946	RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
983	OUTPUT:	947	OUTPUT:
984	RETVAL	948	RETVAL
985		949
986	X509_NAME *	950	OpenSSL::Name
987	issuer(x509)	951	issuer(x509)
988	OpenSSL::X509 x509	952	OpenSSL::X509 x509
989	CODE:	953	CODE:
990	RETVAL = X509_get_issuer_name(x509);	954	RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
991	OUTPUT:	955	OUTPUT:
992	RETVAL	956	RETVAL
993		957
994		958
995	char *	959	char *
…		…
1092	RETVAL	1056	RETVAL
1093		1057
1094	void	1058	void
1095	set_issuer(x509,name)	1059	set_issuer(x509,name)
1096	OpenSSL::X509 x509	1060	OpenSSL::X509 x509
1097	X509_NAME *name	1061	OpenSSL::Name name
1098	CODE:	1062	CODE:
1099	X509_set_issuer_name(x509, X509_NAME_dup(name));	1063	X509_set_issuer_name(x509, X509_NAME_dup(name));
1100		1064
1101	void	1065	void
1102	set_subject(x509,name)	1066	set_subject(x509,name)
1103	OpenSSL::X509 x509	1067	OpenSSL::X509 x509
1104	X509_NAME *name	1068	OpenSSL::Name name
1105	CODE:	1069	CODE:
1106	X509_set_subject_name(x509, X509_NAME_dup(name));	1070	X509_set_subject_name(x509, X509_NAME_dup(name));
1107		1071
1108	SV *	1072	SV *
1109	errstring(x509)	1073	errstring(x509)
…		…
1128	cipher_boot();	1092	cipher_boot();
1129	}	1093	}
1130		1094
1131	void	1095	void
1132	DESTROY(ctx)	1096	DESTROY(ctx)
1133	EVP_CIPHER_CTX *ctx	1097	OpenSSL::Cipher ctx
1134	CODE:	1098	CODE:
1135	if(ctx) {	1099	if(ctx) {
1136	EVP_CIPHER_CTX_cleanup(ctx);	1100	EVP_CIPHER_CTX_cleanup(ctx);
1137	free(ctx);	1101	free(ctx);
1138	}	1102	}
1139		1103
1140	void	1104	OpenSSL::Cipher
1141	new_decrypt(...)	1105	new_decrypt(...)
1142	ALIAS:	1106	ALIAS:
1143	new_encrypt = 1	1107	new_encrypt = 1
1144	PREINIT:	1108	PREINIT:
1145	char *name;	1109	char *name;
1146	SV *svkey;	1110	SV *svkey;
1147	EVP_CIPHER *ci;	1111	EVP_CIPHER *ci;
1148	EVP_CIPHER_CTX *ctx;
1149	char *key;	1112	char *key;
1150	char iv[EVP_MAX_IV_LENGTH];	1113	char iv[EVP_MAX_IV_LENGTH];
1151	char k[EVP_MAX_KEY_LENGTH];	1114	char k[EVP_MAX_KEY_LENGTH];
1152	int rc;	1115	int rc;
1153	STRLEN keylen;	1116	STRLEN keylen;
1154	PPCODE:	1117	CODE:
1155	if(items < 2 \|\| items > 3) {	1118	if(items < 2 \|\| items > 3) {
1156	croak("usage: new_[en\|de]crypt(ciphname,key)");	1119	croak("usage: new_[en\|de]crypt(ciphname,key)");
1157	}	1120	}
1158	name = SvPV_nolen(ST(items -2));	1121	name = SvPV_nolen(ST(items -2));
1159	svkey = ST(items - 1);	1122	svkey = ST(items - 1);
1160	memset(iv, 0, EVP_MAX_IV_LENGTH);	1123	memset(iv, 0, EVP_MAX_IV_LENGTH);
1161	memset(k, 0, EVP_MAX_KEY_LENGTH);	1124	memset(k, 0, EVP_MAX_KEY_LENGTH);
1162		1125
1163	if(!(ci = lookup_cipher(name)))	1126	if(!(ci = lookup_cipher(name)))
1164	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1127	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1165	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1128	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1166	if(!ctx)	1129	if(!RETVAL)
1167	croak("malloc error");	1130	croak("malloc error");
1168	key = SvPV(svkey, keylen);	1131	key = SvPV(svkey, keylen);
1169	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1132	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1170	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1133	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1171	memset(iv, 0, EVP_MAX_IV_LENGTH);	1134	memset(iv, 0, EVP_MAX_IV_LENGTH);
1172	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1135	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1173	if(!rc) {	1136	if(!rc) {
1174	free(ctx);	1137	free(RETVAL);
1175	croak("EVP_CipherInit");	1138	croak("EVP_CipherInit");
1176	}	1139	}
1177	EXTEND(sp, 1);	1140	OUTPUT:
1178	PUSHs(sv_newmortal());	1141	RETVAL
1179	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1180		1142
1181		1143
1182	SV *	1144	SV *
1183	update(ctx,svin)	1145	update(ctx,svin)
1184	EVP_CIPHER_CTX *ctx	1146	OpenSSL::Cipher ctx
1185	SV *svin	1147	SV *svin
1186	PREINIT:	1148	PREINIT:
1187	unsigned char in, out;	1149	unsigned char in, out;
1188	STRLEN il, ol;	1150	STRLEN il, ol;
1189	CODE:	1151	CODE:
…		…
1203	OUTPUT:	1165	OUTPUT:
1204	RETVAL	1166	RETVAL
1205		1167
1206	SV *	1168	SV *
1207	final(ctx)	1169	final(ctx)
1208	EVP_CIPHER_CTX *ctx	1170	OpenSSL::Cipher ctx
1209	PREINIT:	1171	PREINIT:
1210	STRLEN ol;	1172	STRLEN ol;
1211	unsigned char *out;	1173	unsigned char *out;
1212	CODE:	1174	CODE:
1213	ol = 256;	1175	ol = 256;
…		…
1302	}	1264	}
1303	OUTPUT:	1265	OUTPUT:
1304	RETVAL	1266	RETVAL
1305		1267
1306		1268
1307	void	1269	OpenSSL::Digest
1308	new_md2()	1270	new_md2()
1309	ALIAS:	1271	ALIAS:
1310	new_md4 = 0x1	1272	new_md4 = 0x1
1311	new_md5 = 0x2	1273	new_md5 = 0x2
1312	mew_sha = 0x3	1274	mew_sha = 0x3
1313	new_sha1 = 0x4	1275	new_sha1 = 0x4
1314	new_dss = 0x5	1276	new_dss = 0x5
1315	new_dss1 = 0x6	1277	new_dss1 = 0x6
1316	new_mdc2 = 0x7	1278	new_mdc2 = 0x7
1317	new_ripemd160 = 0x8	1279	new_ripemd160 = 0x8
1318	PREINIT:
1319	EVP_MD_CTX *ctx;
1320	PPCODE:	1280	CODE:
1321	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1281	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1322	if(!ctx)	1282	if(!RETVAL)
1323	croak("out of memory.");	1283	croak("out of memory.");
1324	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1284	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1325	EXTEND(sp, 1);	1285	OUTPUT:
1326	PUSHs(sv_newmortal());	1286	RETVAL
1327	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1328
1329		1287
1330	void	1288	void
1331	DESTROY(ctx)	1289	DESTROY(ctx)
1332	EVP_MD_CTX *ctx	1290	OpenSSL::Digest ctx
1333	CODE:	1291	CODE:
1334	if(ctx)	1292	if(ctx)
1335	free(ctx);	1293	free(ctx);
1336		1294
1337	void	1295	void
1338	update(ctx, sv)	1296	update(ctx, sv)
1339	EVP_MD_CTX *ctx	1297	OpenSSL::Digest ctx
1340	SV *sv	1298	SV *sv
1341	PREINIT:	1299	PREINIT:
1342	STRLEN l;	1300	STRLEN l;
1343	char *p;	1301	char *p;
1344	CODE:	1302	CODE:
1345	p = SvPV(sv, l);	1303	p = SvPV(sv, l);
1346	EVP_DigestUpdate(ctx, p, l);	1304	EVP_DigestUpdate(ctx, p, l);
1347
1348		1305
1349	SV *	1306	SV *
1350	final(ctx)	1307	final(ctx)
1351	EVP_MD_CTX *ctx	1308	OpenSSL::Digest ctx
1352	ALIAS:	1309	ALIAS:
1353	final_hex = 1	1310	final_hex = 1
1354	final_base64 = 2	1311	final_base64 = 2
1355	PREINIT:	1312	PREINIT:
1356	unsigned char md[EVP_MAX_MD_SIZE];	1313	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1436	}	1393	}
1437	OUTPUT:	1394	OUTPUT:
1438	RETVAL	1395	RETVAL
1439		1396
1440		1397
1441	void	1398	OpenSSL::Digest
1442	new_md2(void)	1399	new_md2()
1443	ALIAS:	1400	ALIAS:
1444	new_md4 = 0x1	1401	new_md4 = 0x1
1445	new_md5 = 0x2	1402	new_md5 = 0x2
1446	mew_sha = 0x3	1403	mew_sha = 0x3
1447	new_sha1 = 0x4	1404	new_sha1 = 0x4
1448	new_dss = 0x5	1405	new_dss = 0x5
1449	new_dss1 = 0x6	1406	new_dss1 = 0x6
1450	new_mdc2 = 0x7	1407	new_mdc2 = 0x7
1451	new_ripemd160 = 0x8	1408	new_ripemd160 = 0x8
1452	PREINIT:
1453	EVP_MD_CTX *ctx;
1454	PPCODE:	1409	CODE:
1455	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1410	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1456	if(!ctx)	1411	if(!RETVAL)
1457	croak("out of memory.");	1412	croak("out of memory.");
1458	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1413	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1459	EXTEND(sp, 1);	1414	OUTPUT:
1460	PUSHs(sv_newmortal());	1415	RETVAL
1461	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1462
1463		1416
1464	void	1417	void
1465	DESTROY(ctx)	1418	DESTROY(ctx)
1466	EVP_MD_CTX *ctx	1419	OpenSSL::Digest ctx
1467	CODE:	1420	CODE:
1468	if(ctx)	1421	if(ctx)
1469	free(ctx);	1422	free(ctx);
1470		1423
1471	void	1424	void
1472	update(ctx, sv)	1425	update(ctx, sv)
1473	EVP_MD_CTX *ctx	1426	OpenSSL::Digest ctx
1474	SV *sv	1427	SV *sv
1475	PREINIT:	1428	PREINIT:
1476	STRLEN l;	1429	STRLEN l;
1477	char *p;	1430	char *p;
1478	CODE:	1431	CODE:
…		…
1480	EVP_DigestUpdate(ctx, p, l);	1433	EVP_DigestUpdate(ctx, p, l);
1481		1434
1482		1435
1483	SV *	1436	SV *
1484	final(ctx)	1437	final(ctx)
1485	EVP_MD_CTX *ctx	1438	OpenSSL::Digest ctx
1486	ALIAS:	1439	ALIAS:
1487	final_hex = 1	1440	final_hex = 1
1488	final_base64 = 2	1441	final_base64 = 2
1489	PREINIT:	1442	PREINIT:
1490	unsigned char md[EVP_MAX_MD_SIZE];	1443	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1506	RETVAL	1459	RETVAL
1507		1460
1508		1461
1509	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1462	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1510		1463
1511	void	1464	OpenSSL::PKCS7
1512	new()	1465	new()
1513	PREINIT:
1514	PKCS7 *p7;
1515	PPCODE:	1466	CODE:
1516	if(!(p7 = PKCS7_new())) {	1467	if(!(RETVAL = PKCS7_new())) {
1517	croak("PKCS7_new");	1468	croak("PKCS7_new");
1518	}	1469	}
1519	EXTEND(sp, 1);	1470	OUTPUT:
1520	PUSHs(sv_newmortal());	1471	RETVAL
1521	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1522		1472
1523		1473
1524	void	1474	void
1525	DESTROY(p7)	1475	DESTROY(p7)
1526	PKCS7 *p7;	1476	OpenSSL::PKCS7 p7;
1527	CODE:	1477	CODE:
1528	if(p7) {	1478	if(p7) {
1529	XD("PKCS7_free(%p)\n", p7);	1479	XD("PKCS7_free(%p)\n", p7);
1530	PKCS7_free(p7);	1480	PKCS7_free(p7);
1531	}	1481	}
1532		1482
1533		1483
1534	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1484	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1535		1485
1536	void	1486	OpenSSL::PKCS12
1537	new()	1487	new(class)
1538	PREINIT:	1488	SV *class
1539	PKCS12 *p12;
1540	PPCODE:	1489	CODE:
1541	if(!(p12 = PKCS12_new())) {	1490	if(!(RETVAL = PKCS12_new())) {
1542	croak("PKCS12_new");	1491	croak("PKCS12_new");
1543	}	1492	}
1544	EXTEND(sp, 1);	1493	OUTPUT:
1545	PUSHs(sv_newmortal());	1494	RETVAL
1546	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1547		1495
1548	void	1496	OpenSSL::PKCS12
1549	new_from_string(sv)	1497	new_from_string(class,sv)
		1498	SV *class
1550	SV *sv	1499	SV *sv
1551	ALIAS:	1500	ALIAS:
1552	new_from_file = 1	1501	new_from_file = 1
1553	PREINIT:	1502	PREINIT:
1554	PKCS12 *p12;
1555	BIO *bio;	1503	BIO *bio;
1556	char *s;	1504	char *s;
1557	STRLEN len;	1505	STRLEN len;
1558	PPCODE:	1506	CODE:
1559	s = SvPV(sv, len);	1507	s = SvPV(sv, len);
1560	if(ix == 1) {	1508	if(ix == 1) {
1561	bio = BIO_new_file(s, "r");	1509	bio = BIO_new_file(s, "r");
1562	} else {	1510	} else {
1563	bio = BIO_new_mem_buf (s, len);	1511	bio = BIO_new_mem_buf (s, len);
1564	}	1512	}
1565	if(!bio)	1513	if(!bio)
1566	croak("BIO_new_mem_buf");	1514	croak("BIO_new_mem_buf");
1567	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1515	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1568	BIO_free(bio);	1516	BIO_free(bio);
1569	croak("d2i_PKCS12_BIO: %s", ssl_error());	1517	croak("d2i_PKCS12_BIO: %s", ssl_error());
1570	}	1518	}
1571	BIO_free(bio);	1519	BIO_free(bio);
1572	EXTEND(sp, 1);	1520	OUTPUT:
1573	PUSHs(sv_newmortal());	1521	RETVAL
1574	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1575		1522
1576		1523
1577	SV*	1524	SV*
1578	mac_ok(p12, pwd)	1525	mac_ok(p12, pwd)
1579	PKCS12 *p12	1526	OpenSSL::PKCS12 p12
1580	char *pwd	1527	char *pwd
1581	CODE:	1528	CODE:
1582		1529
1583	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;
1584	OUTPUT:	1531	OUTPUT:
1585	RETVAL	1532	RETVAL
1586		1533
1587	void	1534	void
1588	changepass(p12, oldpwd, newpwd)	1535	changepass(p12, oldpwd, newpwd)
1589	PKCS12 *p12	1536	OpenSSL::PKCS12 p12
1590	SV *oldpwd	1537	SV *oldpwd
1591	SV *newpwd	1538	SV *newpwd
1592	PREINIT:	1539	PREINIT:
1593	char *op = 0;	1540	char *op = 0;
1594	char *np = 0;	1541	char *np = 0;
…		…
1601	croak("PKCS12_newpass: %s", ssl_error());	1548	croak("PKCS12_newpass: %s", ssl_error());
1602	}	1549	}
1603		1550
1604	SV*	1551	SV*
1605	as_string(p12,...)	1552	as_string(p12,...)
1606	PKCS12 *p12	1553	OpenSSL::PKCS12 p12
1607	ALIAS:	1554	ALIAS:
1608	as_file = 1	1555	as_file = 1
1609	PROTOTYPE: $;$	1556	PROTOTYPE: $;$
1610	PREINIT:	1557	PREINIT:
1611	SV *sv;	1558	SV *sv;
…		…
1628	OUTPUT:	1575	OUTPUT:
1629	RETVAL	1576	RETVAL
1630		1577
1631	void	1578	void
1632	DESTROY(p12)	1579	DESTROY(p12)
1633	PKCS12 *p12;	1580	OpenSSL::PKCS12 p12;
1634	CODE:	1581	CODE:
1635	if(p12) {	1582	if(p12) {
1636	XD("PKCS12_free(%p)\n", p12);	1583	XD("PKCS12_free(%p)\n", p12);
1637	PKCS12_free(p12);	1584	PKCS12_free(p12);
1638	}	1585	}
1639		1586
1640		1587
1641	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1588	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1642		1589
1643	void	1590	OpenSSL::CRL
1644	new_from_string(thing)	1591	new_from_string(thing)
1645	SV *thing	1592	SV *thing
1646	ALIAS:	1593	ALIAS:
1647	new_from_file = 1	1594	new_from_file = 1
1648	PREINIT:	1595	PREINIT:
1649	BIO *bio;	1596	BIO *bio;
1650	X509_CRL *crl;
1651	STRLEN l;	1597	STRLEN l;
1652	char p, q = 0;	1598	char p, q = 0;
1653	PPCODE:	1599	CODE:
1654	p = SvPV(thing, l);	1600	p = SvPV(thing, l);
1655	if(ix == 1) {	1601	if(ix == 1) {
1656	bio = BIO_new_file(p, "r");	1602	bio = BIO_new_file(p, "r");
1657	} else {	1603	} else {
1658	bio = BIO_new_mem_buf (p, l);	1604	bio = BIO_new_mem_buf (p, l);
1659	}	1605	}
1660	if(!bio)	1606	if(!bio)
1661	croak(ssl_error());	1607	croak(ssl_error());
1662		1608
1663	crl = PEM_read_bio_X509_CRL (bio, 0, 0, 0);	1609	RETVAL = PEM_read_bio_X509_CRL (bio, 0, 0, 0);
1664	BIO_free (bio);	1610	BIO_free (bio);
1665	if(!crl)	1611	if(!RETVAL)
1666	croak("PEM_read_bio_X509_CRL: %s", ssl_error());	1612	croak("PEM_read_bio_X509_CRL: %s", ssl_error());
1667		1613
1668	EXTEND(sp, 1);	1614	OUTPUT:
1669	PUSHs(sv_newmortal());	1615	RETVAL
1670	sv_setref_pv(ST(0), "OpenSSL::CRL", (void *) crl);
1671		1616
1672	void	1617	void
1673	DESTROY(crl)	1618	DESTROY(crl)
1674	X509_CRL *crl	1619	OpenSSL::CRL crl
1675	CODE:	1620	CODE:
1676	if (crl) {	1621	if (crl) {
1677	XD("X509_CRL_free (%p)\n", crl);	1622	XD("X509_CRL_free (%p)\n", crl);
1678	X509_CRL_free(crl);	1623	X509_CRL_free(crl);
1679	crl = 0;	1624	crl = 0;
1680	}	1625	}
1681		1626
1682	SV*	1627	SV*
1683	info(crl)	1628	info(crl)
1684	X509_CRL *crl	1629	OpenSSL::CRL crl
1685	PREINIT:	1630	PREINIT:
1686	BIO *bio;	1631	BIO *bio;
1687	CODE:	1632	CODE:
1688	bio = sv_bio_create();	1633	bio = sv_bio_create();
1689	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.3 by root, Sat Oct 27 02:43:28 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.3 by root, Sat Oct 27 02:43:28 2001 UTC vs.
Revision 1.10 by root, Sat Oct 27 03:27:06 2001 UTC