[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.18 by stefan, Mon Oct 29 05:38:03 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;
		45	typedef BIGNUM *OpenSSL__BN;
67		46
68	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)	47	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)
69	{	48	{
70	if(!ai)	49	if(!ai)
71	croak("got 0-ptr");	50	croak("got 0-ptr");
…		…
113	}	92	}
114	sv_setpv(sv, buf);	93	sv_setpv(sv, buf);
115	return sv;	94	return sv;
116	}	95	}
117		96
118	long fuck_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)	97	long bio_write_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)
119	{	98	{
120	if(m == BIO_CB_WRITE) {	99	if(m == BIO_CB_WRITE) {
121	SV sv = (SV ) BIO_get_callback_arg(bm);	100	SV sv = (SV ) BIO_get_callback_arg(bm);
122	sv_catpvn(sv, ptr, l);	101	sv_catpvn(sv, ptr, l);
123	}	102	}
…		…
135	BIO *bio;	114	BIO *bio;
136	sv = newSVpvn("",0);	115	sv = newSVpvn("",0);
137	// mem is completely broken for write, so we use /dev/null	116	// mem is completely broken for write, so we use /dev/null
138	// and use callbacks-hooks	117	// and use callbacks-hooks
139	bio = BIO_new_file("/dev/null", "wb");	118	bio = BIO_new_file("/dev/null", "wb");
140	BIO_set_callback(bio, fuck_cb);	119	BIO_set_callback(bio, bio_write_cb);
141	BIO_set_callback_arg(bio, (void *)sv);	120	BIO_set_callback_arg(bio, (void *)sv);
142	return bio;	121	return bio;
143	}	122	}
144		123
145	static inline BIO sv_bio_create_file(SV filename)	124	static inline BIO sv_bio_create_file(SV filename)
146	{	125	{
147	char *fn;
148	STRLEN l;	126	STRLEN l;
149		127
150	return BIO_new_file(SvPV(filename, l), "wb");	128	return BIO_new_file(SvPV(filename, l), "wb");
151	}	129	}
152		130
…		…
314	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');	292	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');
315	}	293	}
316	return s;	294	return s;
317	}	295	}
318		296
319	static inline char ol(X509_NAME x)	297	static inline SV ol(X509_NAME x)
320	{	298	{
321	static char buf[256];	299	char *p;
322	X509_NAME_oneline(x, buf, 256);	300	SV *sv = newSVpvn("",0);
		301	X509_NAME_oneline(x, (p=SvGROW(sv,8192)), 8192);
		302	SvCUR_set(sv, strlen(p));
323	return buf;	303	return sv;
324	}	304	}
325		305
		306	#if 0
326	static void run_sha1(char digest, const char msg, int msglen)	307	static void run_sha1(char digest, const char msg, int msglen)
327	{	308	{
328	SHA_CTX ctx;	309	SHA_CTX ctx;
329		310
330	if(!digest \|\| !msg \|\| msglen < 0)	311	if(!digest \|\| !msg \|\| msglen < 0)
331	croak("run_sha1: null pointer or illegal message len");	312	croak("run_sha1: null pointer or illegal message len");
332	SHA1_Init(&ctx);	313	SHA1_Init(&ctx);
333	SHA1_Update(&ctx, msg, msglen);	314	SHA1_Update(&ctx, msg, msglen);
334	SHA1_Final(digest, &ctx);	315	SHA1_Final(digest, &ctx);
335	}	316	}
336		317	#endif
337	static bool is_privkey(RSA *key)	318	static bool is_privkey(RSA *key)
338	{	319	{
339	return (key->n && key->e && key->d && key->p && key->q	320	return (key->n && key->e && key->d && key->p && key->q
340	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;	321	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
341	}	322	}
…		…
412	}	393	}
413		394
414		395
415	MODULE = OpenSSL PACKAGE = OpenSSL::RSA	396	MODULE = OpenSSL PACKAGE = OpenSSL::RSA
416		397
417	void	398	OpenSSL::RSA
418	new_keygen(bits = 128, e = 35)	399	new_keygen(bits = 128, e = 35)
419	IV bits	400	IV bits
420	IV e	401	IV e
421	PREINIT:
422	RSA *key;
423	PPCODE:	402	CODE:
424	if(!(key = RSA_generate_key(bits, e, NULL, NULL)))	403	if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
425	croak("RSA_generate_key");	404	croak("RSA_generate_key");
426	EXTEND(sp, 1);	405	OUTPUT:
427	PUSHs(sv_newmortal());	406	RETVAL
428	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
429		407
430	void	408	OpenSSL::RSA
431	new_pubkey(n, e)	409	new_pubkey(n, e)
432	char *n	410	char *n
433	char *e	411	char *e
434	PREINIT:
435	RSA *key;
436	PPCODE:	412	CODE:
437	EXTEND(sp, 1);
438	PUSHs(sv_newmortal());
439	key = RSA_new();	413	RETVAL = RSA_new();
440	if (!key)	414	if (!RETVAL)
441	croak("can't allocate key");	415	croak("can't allocate key");
442	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	416	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
443	RSA_free(key); croak("can't initialize n");	417	RSA_free(RETVAL); croak("can't initialize n");
444	}	418	}
445	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	419	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
446	RSA_free(key); croak("can't initialize e");	420	RSA_free(RETVAL); croak("can't initialize e");
447	}	421	}
448	//key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;	422	//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);	423	OUTPUT:
		424	RETVAL
450		425
451		426
452	void	427	OpenSSL::RSA
453	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	428	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
454	char *n	429	char *n
455	char *e	430	char *e
456	char *p	431	char *p
457	char *q	432	char *q
458	char *dmp1	433	char *dmp1
459	char *dmq1	434	char *dmq1
460	char *iqmp	435	char *iqmp
461	char *d	436	char *d
462	PREINIT:	437	CODE:
463	RSA *key;
464	int rc;	438	int rc;
465	PPCODE:	439
466	EXTEND(sp, 1);
467	PUSHs(sv_newmortal());
468	key = RSA_new();	440	RETVAL = RSA_new();
469	if (!key)	441	if (!RETVAL)
470	croak("can't allocate key");	442	croak("can't allocate key");
471	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	443	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
472	RSA_free(key); croak("can't initialize n");	444	RSA_free(RETVAL); croak("can't initialize n");
473	}	445	}
474	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	446	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
475	RSA_free(key); croak("can't initialize e");	447	RSA_free(RETVAL); croak("can't initialize e");
476	}	448	}
477	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	449	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
478	RSA_free(key); croak("can't initialize p");	450	RSA_free(RETVAL); croak("can't initialize p");
479	}	451	}
480	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	452	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
481	RSA_free(key); croak("can't initialize q");	453	RSA_free(RETVAL); croak("can't initialize q");
482	}	454	}
483	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	455	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
484	RSA_free(key); croak("can't initialize dmp1");	456	RSA_free(RETVAL); croak("can't initialize dmp1");
485	}	457	}
486	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	458	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
487	RSA_free(key); croak("can't initialize dmq1");	459	RSA_free(RETVAL); croak("can't initialize dmq1");
488	}	460	}
489	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	461	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
490	RSA_free(key); croak("can't initialize iqmp");	462	RSA_free(RETVAL); croak("can't initialize iqmp");
491	}	463	}
492	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	464	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
493	RSA_free(key); croak("can't initialize d");	465	RSA_free(RETVAL); croak("can't initialize d");
494	}	466	}
495	if((rc = RSA_check_key(key)) != 1) {	467	if((rc = RSA_check_key(RETVAL)) != 1) {
496	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	468	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
497	}	469	}
498	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	470	OUTPUT:
		471	RETVAL
499		472
500		473
501	void	474	void
502	DESTROY(key)	475	DESTROY(key)
503	RSA* key	476	OpenSSL::RSA key
504	CODE:	477	CODE:
505	if (key) {	478	if (key) {
506	XD("RSA_free(%p)\n", key);	479	XD("RSA_free(%p)\n", key);
507	RSA_free(key);	480	RSA_free(key);
508	}	481	}
509		482
510	IV	483	IV
511	keysize(key)	484	keysize(key)
512	RSA *key;	485	OpenSSL::RSA key;
513	CODE:	486	CODE:
514	if (!key \|\| !key->n)	487	if (!key \|\| !key->n)
515	croak("invalid key");	488	croak("invalid key");
516	RETVAL = BN_num_bits(key->n);	489	RETVAL = BN_num_bits(key->n);
517	OUTPUT:	490	OUTPUT:
518	RETVAL	491	RETVAL
519		492
520	bool	493	bool
521	check_key(key)	494	check_key(key)
522	RSA *key;	495	OpenSSL::RSA key;
523	PPCODE:	496	PPCODE:
524	if(!key)	497	if(!key)
525	XSRETURN_NO;	498	XSRETURN_NO;
526	if(RSA_check_key(key) == 1)	499	if(RSA_check_key(key) == 1)
527	XSRETURN_YES;	500	XSRETURN_YES;
528	XSRETURN_NO;	501	XSRETURN_NO;
529		502
530		503
531	BIGNUM *	504	OpenSSL::BN
532	n(key)	505	n(key)
533	RSA *key;	506	OpenSSL::RSA key;
534	ALIAS:	507	ALIAS:
535	e = 1	508	e = 1
536	d = 2	509	d = 2
537	p = 3	510	p = 3
538	q = 4	511	q = 4
539	dmp1 = 5	512	dmp1 = 5
540	dmq1 = 6	513	dmq1 = 6
541	iqmp = 7	514	iqmp = 7
542	PREINIT:
543	BIGNUM *bn = 0;
544	CODE:	515	CODE:
		516	RETVAL = 0;
545	if(!key)	517	if(!key)
546	croak("invalid key");	518	croak("invalid key");
547	switch(ix) {	519	switch(ix) {
548	case 0: bn = key->n; break;	520	case 0: RETVAL = key->n; break;
549	case 1: bn = key->e; break;	521	case 1: RETVAL = key->e; break;
550	case 2: bn = key->d; break;	522	case 2: RETVAL = key->d; break;
551	case 3: bn = key->p; break;	523	case 3: RETVAL = key->p; break;
552	case 4: bn = key->q; break;	524	case 4: RETVAL = key->q; break;
553	case 5: bn = key->dmp1; break;	525	case 5: RETVAL = key->dmp1; break;
554	case 6: bn = key->dmq1; break;	526	case 6: RETVAL = key->dmq1; break;
555	case 7: bn = key->iqmp; break;	527	case 7: RETVAL = key->iqmp; break;
556	default:	528	default:
557	croak("huch");	529	croak("huch");
558	}	530	}
559	if(!bn)	531	if(!RETVAL)
560	croak("bignum not defined (maybe pubkey ?)");	532	croak("bignum not defined (maybe pubkey ?)");
561	RETVAL = bn;
562	OUTPUT:	533	OUTPUT:
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;
628	STRLEN totlen;	598	STRLEN totlen;
629	PPCODE:	599	PPCODE:
630	if(cloning)	600	if(cloning)
631	return;	601	return;
632	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);	602	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);
…		…
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;
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	SV *
996	subject_txt(x509)	960	subject_txt(x509)
997	OpenSSL::X509 x509	961	OpenSSL::X509 x509
998	CODE:	962	CODE:
999	RETVAL = ol(X509_get_subject_name(x509));	963	RETVAL = ol(X509_get_subject_name(x509));
1000	OUTPUT:	964	OUTPUT:
1001	RETVAL	965	RETVAL
1002		966
1003		967
1004	char *	968	SV *
1005	issuer_txt(x509)	969	issuer_txt(x509)
1006	OpenSSL::X509 x509	970	OpenSSL::X509 x509
1007	CODE:	971	CODE:
1008	RETVAL = ol(X509_get_issuer_name(x509));	972	RETVAL = ol(X509_get_issuer_name(x509));
1009	OUTPUT:	973	OUTPUT:
…		…
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:
1190	in = SvPV(svin, il);	1152	in = SvPV(svin, il);
1191	ol = (il + 63) & ~63;	1153	ol = (il + 63) & ~63;
1192	RETVAL = NEWSV(0, ol);	1154	RETVAL = NEWSV(0, ol);
1193	SvPOK_only(RETVAL);	1155	SvPOK_only(RETVAL);
1194	SvCUR_set(RETVAL, ol);	1156	SvCUR_set(RETVAL, ol);
1195	out = SvPV_nolen(RETVAL);	1157	out = SvPV_nolen(RETVAL);
1196	if(!out)
1197	croak("memory");
1198	if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) {	1158	if(!EVP_CipherUpdate(ctx, out, &ol, in, il)) {
1199	sv_free(RETVAL);	1159	sv_free(RETVAL);
1200	croak("EVP_CipherUpdate");	1160	croak("EVP_CipherUpdate");
1201	}	1161	}
1202	SvCUR_set(RETVAL, ol);	1162	SvCUR_set(RETVAL, ol);
1203	OUTPUT:	1163	OUTPUT:
1204	RETVAL	1164	RETVAL
1205		1165
1206	SV *	1166	SV *
1207	final(ctx)	1167	final(ctx)
1208	EVP_CIPHER_CTX *ctx	1168	OpenSSL::Cipher ctx
1209	PREINIT:	1169	PREINIT:
1210	STRLEN ol;	1170	STRLEN ol;
1211	unsigned char *out;	1171	unsigned char *out;
1212	CODE:	1172	CODE:
1213	ol = 256;	1173	ol = 256;
…		…
1247	{	1207	{
1248	mds_boot();	1208	mds_boot();
1249	}	1209	}
1250		1210
1251	SV *	1211	SV *
1252	md2(sv)	1212	md2(...)
1253	SV *sv
1254	ALIAS:	1213	ALIAS:
1255	md4 = 0x1	1214	md4 = 0x1
1256	md5 = 0x2	1215	md5 = 0x2
1257	sha = 0x3	1216	sha = 0x3
1258	sha1 = 0x4	1217	sha1 = 0x4
…		…
1276	sha1_base64 = 0x24	1235	sha1_base64 = 0x24
1277	dss_base64 = 0x25	1236	dss_base64 = 0x25
1278	dss1_base64 = 0x26	1237	dss1_base64 = 0x26
1279	mdc2_base64 = 0x27	1238	mdc2_base64 = 0x27
1280	ripemd160_base64 = 0x28	1239	ripemd160_base64 = 0x28
1281	PREINIT:	1240	CODE:
1282	EVP_MD_CTX ctx;	1241	EVP_MD_CTX ctx;
1283	STRLEN l;	1242	STRLEN l;
1284	char *p;	1243	char *p;
1285	unsigned char md[EVP_MAX_MD_SIZE];	1244	unsigned char md[EVP_MAX_MD_SIZE];
1286	unsigned int md_len;	1245	unsigned int md_len;
1287	CODE:	1246	int i;
		1247
1288	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);	1248	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
		1249
		1250	for (i = 0; i < items; i++)
		1251	{
1289	p = SvPV(sv, l);	1252	p = SvPV(ST(i), l);
1290	EVP_DigestUpdate(&ctx, p, l);	1253	EVP_DigestUpdate(&ctx, p, l);
		1254	}
		1255
1291	EVP_DigestFinal(&ctx, md, &md_len);	1256	EVP_DigestFinal(&ctx, md, &md_len);
1292	switch(ix & ~15) {	1257	switch(ix & ~15) {
1293	case 0:	1258	case 0:
1294	RETVAL = newSVpvn(md, md_len);	1259	RETVAL = newSVpvn(md, md_len);
1295	break;	1260	break;
…		…
1302	}	1267	}
1303	OUTPUT:	1268	OUTPUT:
1304	RETVAL	1269	RETVAL
1305		1270
1306		1271
1307	void	1272	OpenSSL::Digest
1308	new_md2()	1273	new_md2()
1309	ALIAS:	1274	ALIAS:
1310	new_md4 = 0x1	1275	new_md4 = 0x1
1311	new_md5 = 0x2	1276	new_md5 = 0x2
1312	mew_sha = 0x3	1277	mew_sha = 0x3
1313	new_sha1 = 0x4	1278	new_sha1 = 0x4
1314	new_dss = 0x5	1279	new_dss = 0x5
1315	new_dss1 = 0x6	1280	new_dss1 = 0x6
1316	new_mdc2 = 0x7	1281	new_mdc2 = 0x7
1317	new_ripemd160 = 0x8	1282	new_ripemd160 = 0x8
1318	PREINIT:
1319	EVP_MD_CTX *ctx;
1320	PPCODE:	1283	CODE:
1321	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1284	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1322	if(!ctx)	1285	if(!RETVAL)
1323	croak("out of memory.");	1286	croak("out of memory.");
1324	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1287	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1325	EXTEND(sp, 1);	1288	OUTPUT:
1326	PUSHs(sv_newmortal());	1289	RETVAL
1327	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1328
1329		1290
1330	void	1291	void
1331	DESTROY(ctx)	1292	DESTROY(ctx)
1332	EVP_MD_CTX *ctx	1293	OpenSSL::Digest ctx
1333	CODE:	1294	CODE:
1334	if(ctx)	1295	if(ctx)
1335	free(ctx);	1296	free(ctx);
1336		1297
1337	void	1298	void
1338	update(ctx, sv)	1299	update(ctx, ...)
1339	EVP_MD_CTX *ctx	1300	OpenSSL::Digest ctx
1340	SV *sv
1341	PREINIT:	1301	PREINIT:
1342	STRLEN l;	1302	STRLEN l;
1343	char *p;	1303	char *p;
		1304	int i;
1344	CODE:	1305	CODE:
1345	p = SvPV(sv, l);	1306	for (i = 1; i < items; i++)
1346	EVP_DigestUpdate(ctx, p, l);
1347		1307	{
		1308	p = SvPV(ST(i), l);
		1309	EVP_DigestUpdate(ctx, p, l);
		1310	}
1348		1311
1349	SV *	1312	SV *
1350	final(ctx)	1313	final(ctx)
1351	EVP_MD_CTX *ctx	1314	OpenSSL::Digest ctx
1352	ALIAS:	1315	ALIAS:
1353	final_hex = 1	1316	final_hex = 1
1354	final_base64 = 2	1317	final_base64 = 2
1355	PREINIT:	1318	PREINIT:
1356	unsigned char md[EVP_MAX_MD_SIZE];	1319	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1410	dss_base64 = 0x25	1373	dss_base64 = 0x25
1411	dss1_base64 = 0x26	1374	dss1_base64 = 0x26
1412	mdc2_base64 = 0x27	1375	mdc2_base64 = 0x27
1413	ripemd160_base64 = 0x28	1376	ripemd160_base64 = 0x28
1414	PREINIT:	1377	PREINIT:
1415	HMAC_CTX ctx;
1416	STRLEN l, keylen;	1378	STRLEN l, keylen;
1417	char *p;	1379	char *p;
1418	char *key;	1380	char *key;
1419	unsigned char md[EVP_MAX_MD_SIZE];	1381	unsigned char md[EVP_MAX_MD_SIZE];
1420	unsigned int md_len;	1382	unsigned int md_len;
…		…
1436	}	1398	}
1437	OUTPUT:	1399	OUTPUT:
1438	RETVAL	1400	RETVAL
1439		1401
1440		1402
1441	void	1403	OpenSSL::Digest
1442	new_md2(void)	1404	new_md2()
1443	ALIAS:	1405	ALIAS:
1444	new_md4 = 0x1	1406	new_md4 = 0x1
1445	new_md5 = 0x2	1407	new_md5 = 0x2
1446	mew_sha = 0x3	1408	mew_sha = 0x3
1447	new_sha1 = 0x4	1409	new_sha1 = 0x4
1448	new_dss = 0x5	1410	new_dss = 0x5
1449	new_dss1 = 0x6	1411	new_dss1 = 0x6
1450	new_mdc2 = 0x7	1412	new_mdc2 = 0x7
1451	new_ripemd160 = 0x8	1413	new_ripemd160 = 0x8
1452	PREINIT:
1453	EVP_MD_CTX *ctx;
1454	PPCODE:	1414	CODE:
1455	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1415	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1456	if(!ctx)	1416	if(!RETVAL)
1457	croak("out of memory.");	1417	croak("out of memory.");
1458	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1418	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1459	EXTEND(sp, 1);	1419	OUTPUT:
1460	PUSHs(sv_newmortal());	1420	RETVAL
1461	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1462
1463		1421
1464	void	1422	void
1465	DESTROY(ctx)	1423	DESTROY(ctx)
1466	EVP_MD_CTX *ctx	1424	OpenSSL::Digest ctx
1467	CODE:	1425	CODE:
1468	if(ctx)	1426	if(ctx)
1469	free(ctx);	1427	free(ctx);
1470		1428
1471	void	1429	void
1472	update(ctx, sv)	1430	update(ctx, ...)
1473	EVP_MD_CTX *ctx	1431	OpenSSL::Digest ctx
1474	SV *sv
1475	PREINIT:	1432	PREINIT:
1476	STRLEN l;	1433	STRLEN l;
1477	char *p;	1434	char *p;
		1435	int i;
1478	CODE:	1436	CODE:
1479	p = SvPV(sv, l);	1437	for (i = 1; i < items; i++)
1480	EVP_DigestUpdate(ctx, p, l);
1481		1438	{
		1439	p = SvPV(ST(i), l);
		1440	EVP_DigestUpdate(ctx, p, l);
		1441	}
1482		1442
1483	SV *	1443	SV *
1484	final(ctx)	1444	final(ctx)
1485	EVP_MD_CTX *ctx	1445	OpenSSL::Digest ctx
1486	ALIAS:	1446	ALIAS:
1487	final_hex = 1	1447	final_hex = 1
1488	final_base64 = 2	1448	final_base64 = 2
1489	PREINIT:	1449	PREINIT:
1490	unsigned char md[EVP_MAX_MD_SIZE];	1450	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1506	RETVAL	1466	RETVAL
1507		1467
1508		1468
1509	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1469	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1510		1470
1511	void	1471	OpenSSL::PKCS7
1512	new()	1472	new()
1513	PREINIT:
1514	PKCS7 *p7;
1515	PPCODE:	1473	CODE:
1516	if(!(p7 = PKCS7_new())) {	1474	if(!(RETVAL = PKCS7_new())) {
1517	croak("PKCS7_new");	1475	croak("PKCS7_new");
1518	}	1476	}
1519	EXTEND(sp, 1);	1477	OUTPUT:
1520	PUSHs(sv_newmortal());	1478	RETVAL
1521	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1522		1479
1523		1480
1524	void	1481	void
1525	DESTROY(p7)	1482	DESTROY(p7)
1526	PKCS7 *p7;	1483	OpenSSL::PKCS7 p7;
1527	CODE:	1484	CODE:
1528	if(p7) {	1485	if(p7) {
1529	XD("PKCS7_free(%p)\n", p7);	1486	XD("PKCS7_free(%p)\n", p7);
1530	PKCS7_free(p7);	1487	PKCS7_free(p7);
1531	}	1488	}
1532		1489
1533		1490
1534	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1491	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1535		1492
1536	void	1493	OpenSSL::PKCS12
1537	new()	1494	new(class)
1538	PREINIT:	1495	SV *class
1539	PKCS12 *p12;
1540	PPCODE:	1496	CODE:
1541	if(!(p12 = PKCS12_new())) {	1497	if(!(RETVAL = PKCS12_new())) {
1542	croak("PKCS12_new");	1498	croak("PKCS12_new");
1543	}	1499	}
1544	EXTEND(sp, 1);	1500	OUTPUT:
1545	PUSHs(sv_newmortal());	1501	RETVAL
1546	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1547		1502
1548	void	1503	OpenSSL::PKCS12
1549	new_from_string(sv)	1504	new_from_string(class,sv)
		1505	SV *class
1550	SV *sv	1506	SV *sv
1551	ALIAS:	1507	ALIAS:
1552	new_from_file = 1	1508	new_from_file = 1
1553	PREINIT:	1509	PREINIT:
1554	PKCS12 *p12;
1555	BIO *bio;	1510	BIO *bio;
1556	char *s;	1511	char *s;
1557	STRLEN len;	1512	STRLEN len;
1558	PPCODE:	1513	CODE:
1559	s = SvPV(sv, len);	1514	s = SvPV(sv, len);
1560	if(ix == 1) {	1515	if(ix == 1) {
1561	bio = BIO_new_file(s, "r");	1516	bio = BIO_new_file(s, "r");
1562	} else {	1517	} else {
1563	bio = BIO_new_mem_buf (s, len);	1518	bio = BIO_new_mem_buf (s, len);
1564	}	1519	}
1565	if(!bio)	1520	if(!bio)
1566	croak("BIO_new_mem_buf");	1521	croak("BIO_new_mem_buf");
1567	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1522	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1568	BIO_free(bio);	1523	BIO_free(bio);
1569	croak("d2i_PKCS12_BIO: %s", ssl_error());	1524	croak("d2i_PKCS12_BIO: %s", ssl_error());
1570	}	1525	}
1571	BIO_free(bio);	1526	BIO_free(bio);
1572	EXTEND(sp, 1);	1527	OUTPUT:
1573	PUSHs(sv_newmortal());	1528	RETVAL
1574	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1575		1529
1576		1530
1577	SV*	1531	SV*
1578	mac_ok(p12, pwd)	1532	mac_ok(p12, pwd)
1579	PKCS12 *p12	1533	OpenSSL::PKCS12 p12
1580	char *pwd	1534	char *pwd
1581	CODE:	1535	CODE:
1582		1536
1583	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;	1537	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1584	OUTPUT:	1538	OUTPUT:
1585	RETVAL	1539	RETVAL
1586		1540
1587	void	1541	void
1588	changepass(p12, oldpwd, newpwd)	1542	changepass(p12, oldpwd, newpwd)
1589	PKCS12 *p12	1543	OpenSSL::PKCS12 p12
1590	SV *oldpwd	1544	SV *oldpwd
1591	SV *newpwd	1545	SV *newpwd
1592	PREINIT:	1546	PREINIT:
1593	char *op = 0;	1547	char *op = 0;
1594	char *np = 0;	1548	char *np = 0;
…		…
1601	croak("PKCS12_newpass: %s", ssl_error());	1555	croak("PKCS12_newpass: %s", ssl_error());
1602	}	1556	}
1603		1557
1604	SV*	1558	SV*
1605	as_string(p12,...)	1559	as_string(p12,...)
1606	PKCS12 *p12	1560	OpenSSL::PKCS12 p12
1607	ALIAS:	1561	ALIAS:
1608	as_file = 1	1562	as_file = 1
1609	PROTOTYPE: $;$	1563	PROTOTYPE: $;$
1610	PREINIT:	1564	PREINIT:
1611	SV *sv;
1612	BIO *bio;	1565	BIO *bio;
1613	CODE:	1566	CODE:
1614	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))	1567	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))
1615	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");	1568	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");
1616	if(items > 1) {	1569	if(items > 1) {
…		…
1628	OUTPUT:	1581	OUTPUT:
1629	RETVAL	1582	RETVAL
1630		1583
1631	void	1584	void
1632	DESTROY(p12)	1585	DESTROY(p12)
1633	PKCS12 *p12;	1586	OpenSSL::PKCS12 p12;
1634	CODE:	1587	CODE:
1635	if(p12) {	1588	if(p12) {
1636	XD("PKCS12_free(%p)\n", p12);	1589	XD("PKCS12_free(%p)\n", p12);
1637	PKCS12_free(p12);	1590	PKCS12_free(p12);
1638	}	1591	}
1639		1592
1640		1593
1641	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1594	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1642		1595
1643	void	1596	OpenSSL::CRL
1644	new_from_string(thing)	1597	new_from_string(class,thing)
		1598	SV *class
1645	SV *thing	1599	SV *thing
1646	ALIAS:	1600	ALIAS:
1647	new_from_file = 1	1601	new_from_file = 1
1648	PREINIT:	1602	PREINIT:
1649	BIO *bio;	1603	BIO *bio;
1650	X509_CRL *crl;
1651	STRLEN l;	1604	STRLEN l;
1652	char p, q = 0;	1605	char *p;
1653	PPCODE:	1606	CODE:
1654	p = SvPV(thing, l);	1607	p = SvPV(thing, l);
1655	if(ix == 1) {	1608	if(ix == 1) {
1656	bio = BIO_new_file(p, "r");	1609	bio = BIO_new_file(p, "r");
1657	} else {	1610	} else {
1658	bio = BIO_new_mem_buf (p, l);	1611	bio = BIO_new_mem_buf (p, l);
1659	}	1612	}
1660	if(!bio)	1613	if(!bio)
1661	croak(ssl_error());	1614	croak(ssl_error());
1662		1615
1663	crl = PEM_read_bio_X509_CRL (bio, 0, 0, 0);	1616	RETVAL = PEM_read_bio_X509_CRL (bio, 0, 0, 0);
1664	BIO_free (bio);	1617	BIO_free (bio);
1665	if(!crl)	1618	if(!RETVAL)
1666	croak("PEM_read_bio_X509_CRL: %s", ssl_error());	1619	croak("PEM_read_bio_X509_CRL: %s", ssl_error());
1667		1620
1668	EXTEND(sp, 1);	1621	OUTPUT:
1669	PUSHs(sv_newmortal());	1622	RETVAL
1670	sv_setref_pv(ST(0), "OpenSSL::CRL", (void *) crl);
1671		1623
1672	void	1624	void
1673	DESTROY(crl)	1625	DESTROY(crl)
1674	X509_CRL *crl	1626	OpenSSL::CRL crl
1675	CODE:	1627	CODE:
1676	if (crl) {	1628	if (crl) {
1677	XD("X509_CRL_free (%p)\n", crl);	1629	XD("X509_CRL_free (%p)\n", crl);
1678	X509_CRL_free(crl);	1630	X509_CRL_free(crl);
1679	crl = 0;	1631	crl = 0;
1680	}	1632	}
1681		1633
1682	SV*	1634	SV*
1683	info(crl)	1635	info(crl)
1684	X509_CRL *crl	1636	OpenSSL::CRL crl
1685	PREINIT:	1637	PREINIT:
1686	BIO *bio;	1638	BIO *bio;
1687	CODE:	1639	CODE:
1688	bio = sv_bio_create();	1640	bio = sv_bio_create();
1689	if(!X509_CRL_print(bio,crl)) {	1641	if(!X509_CRL_print(bio,crl)) {
…		…
1692	}	1644	}
1693	RETVAL = sv_bio_final(bio);	1645	RETVAL = sv_bio_final(bio);
1694	OUTPUT:	1646	OUTPUT:
1695	RETVAL	1647	RETVAL
1696		1648
		1649	#include "EXTERN.h"
		1650	#include "perl.h"
		1651	#include "XSUB.h"
		1652
		1653	#include <openssl/bn.h>
		1654
		1655
		1656	MODULE = OpenSSL PACKAGE = OpenSSL::BN
		1657
		1658	OpenSSL::BN
		1659	new(class,...)
		1660	SV *class
		1661	CODE:
		1662	unsigned char *p;
		1663	RETVAL = BN_new();
		1664	BN_init(RETVAL);
		1665	if(items == 2) {
		1666	p = SvPV(ST(1), PL_na);
		1667	BN_dec2bn(&RETVAL, p);
		1668	} else {
		1669	BN_zero(RETVAL);
		1670	}
		1671	OUTPUT:
		1672	RETVAL
		1673
		1674	OpenSSL::BN
		1675	clone(bn)
		1676	OpenSSL::BN bn
		1677	CODE:
		1678	RETVAL = BN_dup(bn);
		1679	OUTPUT:
		1680	RETVAL
		1681
		1682	OpenSSL::BN
		1683	add(bn1,bn2)
		1684	OpenSSL::BN bn1
		1685	OpenSSL::BN bn2
		1686	ALIAS:
		1687	sub = 1
		1688	CODE:
		1689	RETVAL = BN_new();
		1690	BN_init(RETVAL);
		1691	switch(ix) {
		1692	case 0:
		1693	BN_add(RETVAL, bn1, bn2);
		1694	break;
		1695	case 1:
		1696	BN_sub(RETVAL, bn1, bn2);
		1697	break;
		1698	}
		1699	OUTPUT:
		1700	RETVAL
		1701
		1702	OpenSSL::BN
		1703	mul(bn1,bn2)
		1704	OpenSSL::BN bn1
		1705	OpenSSL::BN bn2
		1706	ALIAS:
		1707	div = 1
		1708	mod = 2
		1709	exp = 3
		1710	CODE:
		1711	BN_CTX *ctx;
		1712	ctx = BN_CTX_new();
		1713	BN_CTX_init(ctx);
		1714	RETVAL = BN_new();
		1715	BN_init(RETVAL);
		1716	switch(ix) {
		1717	case 0:
		1718	BN_mul(RETVAL, bn1, bn2, ctx);
		1719	break;
		1720	case 1:
		1721	{
		1722	BIGNUM *tmp = BN_new();
		1723	BN_init(tmp);
		1724	if(BN_is_zero(bn2)) {
		1725	BN_clear_free(tmp);
		1726	croak("Illegal division by zero");
		1727	}
		1728	BN_div(RETVAL, tmp, bn1, bn2, ctx);
		1729	BN_clear_free(tmp);
		1730	}
		1731	break;
		1732	case 2:
		1733	{
		1734	BIGNUM *tmp = BN_new();
		1735	BN_init(tmp);
		1736	if(BN_is_zero(bn2)) {
		1737	BN_clear_free(tmp);
		1738	croak("Illegal modulus zero");
		1739	}
		1740	BN_div(tmp, RETVAL, bn1, bn2, ctx);
		1741	BN_clear_free(tmp);
		1742	}
		1743	break;
		1744	case 3:
		1745	{
		1746	BN_exp(RETVAL, bn1, bn2, ctx);
		1747	}
		1748	break;
		1749	}
		1750	BN_CTX_free(ctx);
		1751	OUTPUT:
		1752	RETVAL
		1753
		1754	IV
		1755	icmp(bn1,bn2)
		1756	OpenSSL::BN bn1
		1757	OpenSSL::BN bn2
		1758	CODE:
		1759	RETVAL = BN_cmp(bn1,bn2);
		1760	OUTPUT:
		1761	RETVAL
		1762
		1763	void
		1764	inc(bn)
		1765	OpenSSL::BN bn
		1766	ALIAS:
		1767	dec = 1
		1768	CODE:
		1769	((ix) ? BN_sub_word : BN_add_word)(bn, 1);
		1770
		1771
		1772	SV *
		1773	stringify(bn)
		1774	OpenSSL::BN bn
		1775	CODE:
		1776	char *p;
		1777	p = BN_bn2dec(bn);
		1778	RETVAL = newSVpv(p,0);
		1779	free(p);
		1780	OUTPUT:
		1781	RETVAL
		1782
		1783	OpenSSL::BN
		1784	lshift(bn,cnt)
		1785	OpenSSL::BN bn
		1786	IV cnt
		1787	ALIAS:
		1788	rshift = 1
		1789	CODE:
		1790	RETVAL = BN_new();
		1791	BN_init(RETVAL);
		1792	if(ix)
		1793	BN_rshift(RETVAL,bn,cnt);
		1794	else
		1795	BN_lshift(RETVAL, bn, cnt);
		1796	OUTPUT:
		1797	RETVAL
		1798
		1799	OpenSSL::BN
		1800	sqr(bn)
		1801	OpenSSL::BN bn
		1802	CODE:
		1803	BN_CTX *ctx;
		1804	ctx = BN_CTX_new();
		1805	BN_CTX_init(ctx);
		1806	RETVAL = BN_new();
		1807	BN_init(RETVAL);
		1808	BN_sqr(RETVAL, bn, ctx);
		1809	BN_CTX_free(ctx);
		1810	OUTPUT:
		1811	RETVAL
		1812
		1813	bool
		1814	bnbool(bn)
		1815	OpenSSL::BN bn
		1816	CODE:
		1817	RETVAL = !BN_is_zero(bn);
		1818	OUTPUT:
		1819	RETVAL
		1820
		1821	bool
		1822	isprime(bn)
		1823	OpenSSL::BN bn
		1824	CODE:
		1825	BN_CTX *ctx;
		1826	ctx = BN_CTX_new();
		1827	BN_CTX_init(ctx);
		1828	RETVAL = BN_is_prime(bn, 30, 0, ctx, 0);
		1829	OUTPUT:
		1830	RETVAL
		1831
		1832
		1833	void
		1834	DESTROY(bn)
		1835	OpenSSL::BN bn
		1836	CODE:
		1837	BN_clear_free(bn);
		1838
		1839
		1840

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.18 by stefan, Mon Oct 29 05:38:03 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.18 by stefan, Mon Oct 29 05:38:03 2001 UTC