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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.6 by root, Sat Oct 27 02:55:31 2001 UTC vs.
Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC

…		…
32	#define XD(...)	32	#define XD(...)
33	#endif	33	#endif
34		34
35	static const char *ssl_error(void);	35	static const char *ssl_error(void);
36		36
37	#define GEN_INPUT(type,class) \
38	static inline type * input_##type(SV *sv) { \
39	XD("GEN_INPUT " class " sv=%p\n", sv); \
40	if(sv_derived_from(sv, class)) \
41	return (type *) SvIV(SvRV(sv)); \
42	croak("Not a reference to a " class " object"); \
43	return (type *) 0; }
44
45
46	#define GEN_OUTPUT(type,class) \
47	static inline SV* output_##type(type foobar, SV sv) { \
48	XD("GEN_OUTPUT " class " sv=%p\n", sv); \
49	return sv_setref_pv(sv, class, (void *) foobar); \
50	}
51
52
53	#define GEN_IO(type,class) \
54	GEN_INPUT(type,class) \
55	GEN_OUTPUT(type,class)
56
57
58	GEN_IO(PKCS12, "OpenSSL::PKCS12")
59	GEN_IO(PKCS7, "OpenSSL::PKCS7")
60	GEN_IO(RSA, "OpenSSL::RSA")
61	GEN_IO(EVP_MD_CTX, "OpenSSL::Digest")
62	GEN_IO(EVP_CIPHER_CTX, "OpenSSL::Cipher")
63
64	typedef X509 *OpenSSL__X509;	37	typedef X509 *OpenSSL__X509;
65	typedef X509_CRL *OpenSSL__CRL;	38	typedef X509_CRL *OpenSSL__CRL;
66	typedef X509_NAME *OpenSSL__Name;	39	typedef X509_NAME *OpenSSL__Name;
		40	typedef PKCS7 *OpenSSL__PKCS7;
		41	typedef PKCS12 *OpenSSL__PKCS12;
		42	typedef RSA *OpenSSL__RSA;
		43	typedef EVP_MD_CTX *OpenSSL__Digest;
		44	typedef EVP_CIPHER_CTX *OpenSSL__Cipher;
67		45
68	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)	46	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)
69	{	47	{
70	if(!ai)	48	if(!ai)
71	croak("got 0-ptr");	49	croak("got 0-ptr");
…		…
113	}	91	}
114	sv_setpv(sv, buf);	92	sv_setpv(sv, buf);
115	return sv;	93	return sv;
116	}	94	}
117		95
118	long fuck_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)	96	long bio_write_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)
119	{	97	{
120	if(m == BIO_CB_WRITE) {	98	if(m == BIO_CB_WRITE) {
121	SV sv = (SV ) BIO_get_callback_arg(bm);	99	SV sv = (SV ) BIO_get_callback_arg(bm);
122	sv_catpvn(sv, ptr, l);	100	sv_catpvn(sv, ptr, l);
123	}	101	}
…		…
135	BIO *bio;	113	BIO *bio;
136	sv = newSVpvn("",0);	114	sv = newSVpvn("",0);
137	// mem is completely broken for write, so we use /dev/null	115	// mem is completely broken for write, so we use /dev/null
138	// and use callbacks-hooks	116	// and use callbacks-hooks
139	bio = BIO_new_file("/dev/null", "wb");	117	bio = BIO_new_file("/dev/null", "wb");
140	BIO_set_callback(bio, fuck_cb);	118	BIO_set_callback(bio, bio_write_cb);
141	BIO_set_callback_arg(bio, (void *)sv);	119	BIO_set_callback_arg(bio, (void *)sv);
142	return bio;	120	return bio;
143	}	121	}
144		122
145	static inline BIO sv_bio_create_file(SV filename)	123	static inline BIO sv_bio_create_file(SV filename)
146	{	124	{
147	char *fn;
148	STRLEN l;	125	STRLEN l;
149		126
150	return BIO_new_file(SvPV(filename, l), "wb");	127	return BIO_new_file(SvPV(filename, l), "wb");
151	}	128	}
152		129
…		…
314	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');	291	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');
315	}	292	}
316	return s;	293	return s;
317	}	294	}
318		295
319	static inline char ol(X509_NAME x)	296	static inline SV ol(X509_NAME x)
320	{	297	{
321	static char buf[256];	298	char *p;
322	X509_NAME_oneline(x, buf, 256);	299	SV *sv = newSVpvn("",0);
		300	X509_NAME_oneline(x, (p=SvGROW(sv,8192)), 8192);
		301	SvCUR_set(sv, strlen(p));
323	return buf;	302	return sv;
324	}	303	}
325		304
		305	#if 0
326	static void run_sha1(char digest, const char msg, int msglen)	306	static void run_sha1(char digest, const char msg, int msglen)
327	{	307	{
328	SHA_CTX ctx;	308	SHA_CTX ctx;
329		309
330	if(!digest \|\| !msg \|\| msglen < 0)	310	if(!digest \|\| !msg \|\| msglen < 0)
331	croak("run_sha1: null pointer or illegal message len");	311	croak("run_sha1: null pointer or illegal message len");
332	SHA1_Init(&ctx);	312	SHA1_Init(&ctx);
333	SHA1_Update(&ctx, msg, msglen);	313	SHA1_Update(&ctx, msg, msglen);
334	SHA1_Final(digest, &ctx);	314	SHA1_Final(digest, &ctx);
335	}	315	}
336		316	#endif
337	static bool is_privkey(RSA *key)	317	static bool is_privkey(RSA *key)
338	{	318	{
339	return (key->n && key->e && key->d && key->p && key->q	319	return (key->n && key->e && key->d && key->p && key->q
340	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;	320	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
341	}	321	}
…		…
412	}	392	}
413		393
414		394
415	MODULE = OpenSSL PACKAGE = OpenSSL::RSA	395	MODULE = OpenSSL PACKAGE = OpenSSL::RSA
416		396
417	void	397	OpenSSL::RSA
418	new_keygen(bits = 128, e = 35)	398	new_keygen(bits = 128, e = 35)
419	IV bits	399	IV bits
420	IV e	400	IV e
421	PREINIT:
422	RSA *key;
423	PPCODE:	401	CODE:
424	if(!(key = RSA_generate_key(bits, e, NULL, NULL)))	402	if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
425	croak("RSA_generate_key");	403	croak("RSA_generate_key");
426	EXTEND(sp, 1);	404	OUTPUT:
427	PUSHs(sv_newmortal());	405	RETVAL
428	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
429		406
430	void	407	OpenSSL::RSA
431	new_pubkey(n, e)	408	new_pubkey(n, e)
432	char *n	409	char *n
433	char *e	410	char *e
434	PREINIT:
435	RSA *key;
436	PPCODE:	411	CODE:
437	EXTEND(sp, 1);
438	PUSHs(sv_newmortal());
439	key = RSA_new();	412	RETVAL = RSA_new();
440	if (!key)	413	if (!RETVAL)
441	croak("can't allocate key");	414	croak("can't allocate key");
442	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	415	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
443	RSA_free(key); croak("can't initialize n");	416	RSA_free(RETVAL); croak("can't initialize n");
444	}	417	}
445	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	418	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
446	RSA_free(key); croak("can't initialize e");	419	RSA_free(RETVAL); croak("can't initialize e");
447	}	420	}
448	//key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;	421	//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);	422	OUTPUT:
		423	RETVAL
450		424
451		425
452	void	426	OpenSSL::RSA
453	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	427	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
454	char *n	428	char *n
455	char *e	429	char *e
456	char *p	430	char *p
457	char *q	431	char *q
458	char *dmp1	432	char *dmp1
459	char *dmq1	433	char *dmq1
460	char *iqmp	434	char *iqmp
461	char *d	435	char *d
462	PREINIT:	436	CODE:
463	RSA *key;
464	int rc;	437	int rc;
465	PPCODE:	438
466	EXTEND(sp, 1);
467	PUSHs(sv_newmortal());
468	key = RSA_new();	439	RETVAL = RSA_new();
469	if (!key)	440	if (!RETVAL)
470	croak("can't allocate key");	441	croak("can't allocate key");
471	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	442	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
472	RSA_free(key); croak("can't initialize n");	443	RSA_free(RETVAL); croak("can't initialize n");
473	}	444	}
474	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	445	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
475	RSA_free(key); croak("can't initialize e");	446	RSA_free(RETVAL); croak("can't initialize e");
476	}	447	}
477	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	448	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
478	RSA_free(key); croak("can't initialize p");	449	RSA_free(RETVAL); croak("can't initialize p");
479	}	450	}
480	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	451	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
481	RSA_free(key); croak("can't initialize q");	452	RSA_free(RETVAL); croak("can't initialize q");
482	}	453	}
483	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	454	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
484	RSA_free(key); croak("can't initialize dmp1");	455	RSA_free(RETVAL); croak("can't initialize dmp1");
485	}	456	}
486	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	457	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
487	RSA_free(key); croak("can't initialize dmq1");	458	RSA_free(RETVAL); croak("can't initialize dmq1");
488	}	459	}
489	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	460	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
490	RSA_free(key); croak("can't initialize iqmp");	461	RSA_free(RETVAL); croak("can't initialize iqmp");
491	}	462	}
492	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	463	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
493	RSA_free(key); croak("can't initialize d");	464	RSA_free(RETVAL); croak("can't initialize d");
494	}	465	}
495	if((rc = RSA_check_key(key)) != 1) {	466	if((rc = RSA_check_key(RETVAL)) != 1) {
496	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	467	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
497	}	468	}
498	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	469	OUTPUT:
		470	RETVAL
499		471
500		472
501	void	473	void
502	DESTROY(key)	474	DESTROY(key)
503	RSA* key	475	OpenSSL::RSA key
504	CODE:	476	CODE:
505	if (key) {	477	if (key) {
506	XD("RSA_free(%p)\n", key);	478	XD("RSA_free(%p)\n", key);
507	RSA_free(key);	479	RSA_free(key);
508	}	480	}
509		481
510	IV	482	IV
511	keysize(key)	483	keysize(key)
512	RSA *key;	484	OpenSSL::RSA key;
513	CODE:	485	CODE:
514	if (!key \|\| !key->n)	486	if (!key \|\| !key->n)
515	croak("invalid key");	487	croak("invalid key");
516	RETVAL = BN_num_bits(key->n);	488	RETVAL = BN_num_bits(key->n);
517	OUTPUT:	489	OUTPUT:
518	RETVAL	490	RETVAL
519		491
520	bool	492	bool
521	check_key(key)	493	check_key(key)
522	RSA *key;	494	OpenSSL::RSA key;
523	PPCODE:	495	PPCODE:
524	if(!key)	496	if(!key)
525	XSRETURN_NO;	497	XSRETURN_NO;
526	if(RSA_check_key(key) == 1)	498	if(RSA_check_key(key) == 1)
527	XSRETURN_YES;	499	XSRETURN_YES;
528	XSRETURN_NO;	500	XSRETURN_NO;
529		501
530		502
531	BIGNUM *	503	BIGNUM *
532	n(key)	504	n(key)
533	RSA *key;	505	OpenSSL::RSA key;
534	ALIAS:	506	ALIAS:
535	e = 1	507	e = 1
536	d = 2	508	d = 2
537	p = 3	509	p = 3
538	q = 4	510	q = 4
…		…
563	RETVAL	535	RETVAL
564		536
565		537
566	bool	538	bool
567	is_privkey(key)	539	is_privkey(key)
568	RSA *key;	540	OpenSSL::RSA key;
569	CODE:	541	CODE:
570	RETVAL = is_privkey(key);	542	RETVAL = is_privkey(key);
571	OUTPUT:	543	OUTPUT:
572	RETVAL	544	RETVAL
573		545
…		…
619		591
620		592
621		593
622	void	594	void
623	STORABLE_freeze(key, cloning)	595	STORABLE_freeze(key, cloning)
624	RSA *key	596	OpenSSL::RSA key
625	bool cloning	597	bool cloning
626	PREINIT:	598	PREINIT:
627	SV *sv;
628	STRLEN totlen;	599	STRLEN totlen;
629	PPCODE:	600	PPCODE:
630	if(cloning)	601	if(cloning)
631	return;	602	return;
632	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);	603	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);
…		…
676	}	647	}
677		648
678		649
679	SV *	650	SV *
680	public_encrypt(key, sv)	651	public_encrypt(key, sv)
681	RSA *key;	652	OpenSSL::RSA key;
682	SV *sv;	653	SV *sv;
683	ALIAS:	654	ALIAS:
684	encrypt = 4	655	encrypt = 4
685	public_decrypt = 1	656	public_decrypt = 1
686	verify = 5	657	verify = 5
…		…
719	RETVAL	690	RETVAL
720		691
721		692
722	void	693	void
723	fingerprint(key)	694	fingerprint(key)
724	RSA *key	695	OpenSSL::RSA key
725	PREINIT:	696	PREINIT:
726	char *x;	697	char *x;
727	char dig[SHA_DIGEST_LENGTH];	698	char dig[SHA_DIGEST_LENGTH];
728	int nlen, elen;	699	int nlen, elen;
729	PPCODE:	700	PPCODE:
…		…
741	MODULE = OpenSSL PACKAGE = OpenSSL::Name	712	MODULE = OpenSSL PACKAGE = OpenSSL::Name
742		713
743	PROTOTYPES: ENABLE	714	PROTOTYPES: ENABLE
744		715
745	OpenSSL::Name	716	OpenSSL::Name
746	new_name()	717	new(class)
		718	SV *class
747	CODE:	719	CODE:
748	if(!(RETVAL = X509_NAME_new())) {	720	if(!(RETVAL = X509_NAME_new())) {
749	croak("X509_NAME_new");	721	croak("X509_NAME_new");
750	}	722	}
751	OUTPUT:	723	OUTPUT:
…		…
799	s = X509_NAME_ENTRY_get_data(e);	771	s = X509_NAME_ENTRY_get_data(e);
800	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));	772	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));
801	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));	773	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));
802	}	774	}
803		775
804
805
806
807
808	void	776	void
809	DESTROY(name)	777	DESTROY(name)
810	OpenSSL::Name name	778	OpenSSL::Name name
811	CODE:	779	CODE:
812	if(name) {	780	if(name) {
…		…
899	ERR_load_RSA_strings();	867	ERR_load_RSA_strings();
900	}	868	}
901		869
902		870
903	OpenSSL::X509	871	OpenSSL::X509
904	new_X509()	872	new(class)
		873	SV *class
905	CODE:	874	CODE:
906	if ((RETVAL = X509_new ()) == NULL)	875	if ((RETVAL = X509_new ()) == NULL)
907	croak("X509_new");	876	croak("X509_new");
908		877
909	if (!X509_set_version (RETVAL, 2))	878	if (!X509_set_version (RETVAL, 2))
…		…
915	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);	884	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
916	OUTPUT:	885	OUTPUT:
917	RETVAL	886	RETVAL
918		887
919		888
920	void	889	OpenSSL::X509
921	new_from_string(thing)	890	new_from_string(class,thing)
		891	SV *class
922	SV *thing	892	SV *thing
923	ALIAS:	893	ALIAS:
924	new_from_file = 1	894	new_from_file = 1
925	PREINIT:	895	PREINIT:
926	BIO *bio;	896	BIO *bio;
927	X509 *x509;
928	STRLEN l;	897	STRLEN l;
929	char p, q = 0;	898	char *p;
930	PPCODE:	899	CODE:
931	p = SvPV (thing, l);	900	p = SvPV (thing, l);
932	if(ix == 1) {	901	if(ix == 1) {
933	bio = BIO_new_file(p, "r");	902	bio = BIO_new_file(p, "r");
934	} else {	903	} else {
935	bio = BIO_new_mem_buf (p, l);	904	bio = BIO_new_mem_buf (p, l);
936	}	905	}
937	if(!bio)	906	if(!bio)
938	croak(ssl_error());	907	croak(ssl_error());
939		908
940	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	909	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
941	BIO_free (bio);	910	BIO_free (bio);
942	if(!x509)	911	if(!RETVAL)
943	croak("PEM_read_bio_X509: %s", ssl_error());	912	croak("PEM_read_bio_X509: %s", ssl_error());
944		913
945	EXTEND(sp, 1);	914	OUTPUT:
946	PUSHs(sv_newmortal());	915	RETVAL
947	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
948		916
949	void	917	void
950	DESTROY(x509)	918	DESTROY(x509)
951	OpenSSL::X509 x509	919	OpenSSL::X509 x509
952	CODE:	920	CODE:
…		…
974		942
975	OpenSSL::Name	943	OpenSSL::Name
976	subject(x509)	944	subject(x509)
977	OpenSSL::X509 x509	945	OpenSSL::X509 x509
978	CODE:	946	CODE:
979	RETVAL = X509_get_subject_name(x509);	947	RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
980	OUTPUT:	948	OUTPUT:
981	RETVAL	949	RETVAL
982		950
983	OpenSSL::Name	951	OpenSSL::Name
984	issuer(x509)	952	issuer(x509)
985	OpenSSL::X509 x509	953	OpenSSL::X509 x509
986	CODE:	954	CODE:
987	RETVAL = X509_get_issuer_name(x509);	955	RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
988	OUTPUT:	956	OUTPUT:
989	RETVAL	957	RETVAL
990		958
991		959
992	char *	960	SV *
993	subject_txt(x509)	961	subject_txt(x509)
994	OpenSSL::X509 x509	962	OpenSSL::X509 x509
995	CODE:	963	CODE:
996	RETVAL = ol(X509_get_subject_name(x509));	964	RETVAL = ol(X509_get_subject_name(x509));
997	OUTPUT:	965	OUTPUT:
998	RETVAL	966	RETVAL
999		967
1000		968
1001	char *	969	SV *
1002	issuer_txt(x509)	970	issuer_txt(x509)
1003	OpenSSL::X509 x509	971	OpenSSL::X509 x509
1004	CODE:	972	CODE:
1005	RETVAL = ol(X509_get_issuer_name(x509));	973	RETVAL = ol(X509_get_issuer_name(x509));
1006	OUTPUT:	974	OUTPUT:
…		…
1125	cipher_boot();	1093	cipher_boot();
1126	}	1094	}
1127		1095
1128	void	1096	void
1129	DESTROY(ctx)	1097	DESTROY(ctx)
1130	EVP_CIPHER_CTX *ctx	1098	OpenSSL::Cipher ctx
1131	CODE:	1099	CODE:
1132	if(ctx) {	1100	if(ctx) {
1133	EVP_CIPHER_CTX_cleanup(ctx);	1101	EVP_CIPHER_CTX_cleanup(ctx);
1134	free(ctx);	1102	free(ctx);
1135	}	1103	}
1136		1104
1137	void	1105	OpenSSL::Cipher
1138	new_decrypt(...)	1106	new_decrypt(...)
1139	ALIAS:	1107	ALIAS:
1140	new_encrypt = 1	1108	new_encrypt = 1
1141	PREINIT:	1109	PREINIT:
1142	char *name;	1110	char *name;
1143	SV *svkey;	1111	SV *svkey;
1144	EVP_CIPHER *ci;	1112	EVP_CIPHER *ci;
1145	EVP_CIPHER_CTX *ctx;
1146	char *key;	1113	char *key;
1147	char iv[EVP_MAX_IV_LENGTH];	1114	char iv[EVP_MAX_IV_LENGTH];
1148	char k[EVP_MAX_KEY_LENGTH];	1115	char k[EVP_MAX_KEY_LENGTH];
1149	int rc;	1116	int rc;
1150	STRLEN keylen;	1117	STRLEN keylen;
1151	PPCODE:	1118	CODE:
1152	if(items < 2 \|\| items > 3) {	1119	if(items < 2 \|\| items > 3) {
1153	croak("usage: new_[en\|de]crypt(ciphname,key)");	1120	croak("usage: new_[en\|de]crypt(ciphname,key)");
1154	}	1121	}
1155	name = SvPV_nolen(ST(items -2));	1122	name = SvPV_nolen(ST(items -2));
1156	svkey = ST(items - 1);	1123	svkey = ST(items - 1);
1157	memset(iv, 0, EVP_MAX_IV_LENGTH);	1124	memset(iv, 0, EVP_MAX_IV_LENGTH);
1158	memset(k, 0, EVP_MAX_KEY_LENGTH);	1125	memset(k, 0, EVP_MAX_KEY_LENGTH);
1159		1126
1160	if(!(ci = lookup_cipher(name)))	1127	if(!(ci = lookup_cipher(name)))
1161	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1128	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1162	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1129	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1163	if(!ctx)	1130	if(!RETVAL)
1164	croak("malloc error");	1131	croak("malloc error");
1165	key = SvPV(svkey, keylen);	1132	key = SvPV(svkey, keylen);
1166	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1133	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1167	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1134	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1168	memset(iv, 0, EVP_MAX_IV_LENGTH);	1135	memset(iv, 0, EVP_MAX_IV_LENGTH);
1169	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1136	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1170	if(!rc) {	1137	if(!rc) {
1171	free(ctx);	1138	free(RETVAL);
1172	croak("EVP_CipherInit");	1139	croak("EVP_CipherInit");
1173	}	1140	}
1174	EXTEND(sp, 1);	1141	OUTPUT:
1175	PUSHs(sv_newmortal());	1142	RETVAL
1176	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1177		1143
1178		1144
1179	SV *	1145	SV *
1180	update(ctx,svin)	1146	update(ctx,svin)
1181	EVP_CIPHER_CTX *ctx	1147	OpenSSL::Cipher ctx
1182	SV *svin	1148	SV *svin
1183	PREINIT:	1149	PREINIT:
1184	unsigned char in, out;	1150	unsigned char in, out;
1185	STRLEN il, ol;	1151	STRLEN il, ol;
1186	CODE:	1152	CODE:
…		…
1200	OUTPUT:	1166	OUTPUT:
1201	RETVAL	1167	RETVAL
1202		1168
1203	SV *	1169	SV *
1204	final(ctx)	1170	final(ctx)
1205	EVP_CIPHER_CTX *ctx	1171	OpenSSL::Cipher ctx
1206	PREINIT:	1172	PREINIT:
1207	STRLEN ol;	1173	STRLEN ol;
1208	unsigned char *out;	1174	unsigned char *out;
1209	CODE:	1175	CODE:
1210	ol = 256;	1176	ol = 256;
…		…
1244	{	1210	{
1245	mds_boot();	1211	mds_boot();
1246	}	1212	}
1247		1213
1248	SV *	1214	SV *
1249	md2(sv)	1215	md2(...)
1250	SV *sv
1251	ALIAS:	1216	ALIAS:
1252	md4 = 0x1	1217	md4 = 0x1
1253	md5 = 0x2	1218	md5 = 0x2
1254	sha = 0x3	1219	sha = 0x3
1255	sha1 = 0x4	1220	sha1 = 0x4
…		…
1273	sha1_base64 = 0x24	1238	sha1_base64 = 0x24
1274	dss_base64 = 0x25	1239	dss_base64 = 0x25
1275	dss1_base64 = 0x26	1240	dss1_base64 = 0x26
1276	mdc2_base64 = 0x27	1241	mdc2_base64 = 0x27
1277	ripemd160_base64 = 0x28	1242	ripemd160_base64 = 0x28
1278	PREINIT:	1243	CODE:
1279	EVP_MD_CTX ctx;	1244	EVP_MD_CTX ctx;
1280	STRLEN l;	1245	STRLEN l;
1281	char *p;	1246	char *p;
1282	unsigned char md[EVP_MAX_MD_SIZE];	1247	unsigned char md[EVP_MAX_MD_SIZE];
1283	unsigned int md_len;	1248	unsigned int md_len;
1284	CODE:	1249	int i;
		1250
1285	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);	1251	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
		1252
		1253	for (i = 0; i < items; i++)
		1254	{
1286	p = SvPV(sv, l);	1255	p = SvPV(ST(i), l);
1287	EVP_DigestUpdate(&ctx, p, l);	1256	EVP_DigestUpdate(&ctx, p, l);
		1257	}
		1258
1288	EVP_DigestFinal(&ctx, md, &md_len);	1259	EVP_DigestFinal(&ctx, md, &md_len);
1289	switch(ix & ~15) {	1260	switch(ix & ~15) {
1290	case 0:	1261	case 0:
1291	RETVAL = newSVpvn(md, md_len);	1262	RETVAL = newSVpvn(md, md_len);
1292	break;	1263	break;
…		…
1299	}	1270	}
1300	OUTPUT:	1271	OUTPUT:
1301	RETVAL	1272	RETVAL
1302		1273
1303		1274
1304	void	1275	OpenSSL::Digest
1305	new_md2()	1276	new_md2()
1306	ALIAS:	1277	ALIAS:
1307	new_md4 = 0x1	1278	new_md4 = 0x1
1308	new_md5 = 0x2	1279	new_md5 = 0x2
1309	mew_sha = 0x3	1280	mew_sha = 0x3
1310	new_sha1 = 0x4	1281	new_sha1 = 0x4
1311	new_dss = 0x5	1282	new_dss = 0x5
1312	new_dss1 = 0x6	1283	new_dss1 = 0x6
1313	new_mdc2 = 0x7	1284	new_mdc2 = 0x7
1314	new_ripemd160 = 0x8	1285	new_ripemd160 = 0x8
1315	PREINIT:
1316	EVP_MD_CTX *ctx;
1317	PPCODE:	1286	CODE:
1318	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1287	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1319	if(!ctx)	1288	if(!RETVAL)
1320	croak("out of memory.");	1289	croak("out of memory.");
1321	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1290	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1322	EXTEND(sp, 1);	1291	OUTPUT:
1323	PUSHs(sv_newmortal());	1292	RETVAL
1324	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1325
1326		1293
1327	void	1294	void
1328	DESTROY(ctx)	1295	DESTROY(ctx)
1329	EVP_MD_CTX *ctx	1296	OpenSSL::Digest ctx
1330	CODE:	1297	CODE:
1331	if(ctx)	1298	if(ctx)
1332	free(ctx);	1299	free(ctx);
1333		1300
1334	void	1301	void
1335	update(ctx, sv)	1302	update(ctx, ...)
1336	EVP_MD_CTX *ctx	1303	OpenSSL::Digest ctx
1337	SV *sv
1338	PREINIT:	1304	PREINIT:
1339	STRLEN l;	1305	STRLEN l;
1340	char *p;	1306	char *p;
		1307	int i;
1341	CODE:	1308	CODE:
1342	p = SvPV(sv, l);	1309	for (i = 1; i < items; i++)
1343	EVP_DigestUpdate(ctx, p, l);
1344		1310	{
		1311	p = SvPV(ST(i), l);
		1312	EVP_DigestUpdate(ctx, p, l);
		1313	}
1345		1314
1346	SV *	1315	SV *
1347	final(ctx)	1316	final(ctx)
1348	EVP_MD_CTX *ctx	1317	OpenSSL::Digest ctx
1349	ALIAS:	1318	ALIAS:
1350	final_hex = 1	1319	final_hex = 1
1351	final_base64 = 2	1320	final_base64 = 2
1352	PREINIT:	1321	PREINIT:
1353	unsigned char md[EVP_MAX_MD_SIZE];	1322	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1407	dss_base64 = 0x25	1376	dss_base64 = 0x25
1408	dss1_base64 = 0x26	1377	dss1_base64 = 0x26
1409	mdc2_base64 = 0x27	1378	mdc2_base64 = 0x27
1410	ripemd160_base64 = 0x28	1379	ripemd160_base64 = 0x28
1411	PREINIT:	1380	PREINIT:
1412	HMAC_CTX ctx;
1413	STRLEN l, keylen;	1381	STRLEN l, keylen;
1414	char *p;	1382	char *p;
1415	char *key;	1383	char *key;
1416	unsigned char md[EVP_MAX_MD_SIZE];	1384	unsigned char md[EVP_MAX_MD_SIZE];
1417	unsigned int md_len;	1385	unsigned int md_len;
…		…
1433	}	1401	}
1434	OUTPUT:	1402	OUTPUT:
1435	RETVAL	1403	RETVAL
1436		1404
1437		1405
1438	void	1406	OpenSSL::Digest
1439	new_md2(void)	1407	new_md2()
1440	ALIAS:	1408	ALIAS:
1441	new_md4 = 0x1	1409	new_md4 = 0x1
1442	new_md5 = 0x2	1410	new_md5 = 0x2
1443	mew_sha = 0x3	1411	mew_sha = 0x3
1444	new_sha1 = 0x4	1412	new_sha1 = 0x4
1445	new_dss = 0x5	1413	new_dss = 0x5
1446	new_dss1 = 0x6	1414	new_dss1 = 0x6
1447	new_mdc2 = 0x7	1415	new_mdc2 = 0x7
1448	new_ripemd160 = 0x8	1416	new_ripemd160 = 0x8
1449	PREINIT:
1450	EVP_MD_CTX *ctx;
1451	PPCODE:	1417	CODE:
1452	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1418	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1453	if(!ctx)	1419	if(!RETVAL)
1454	croak("out of memory.");	1420	croak("out of memory.");
1455	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1421	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1456	EXTEND(sp, 1);	1422	OUTPUT:
1457	PUSHs(sv_newmortal());	1423	RETVAL
1458	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1459
1460		1424
1461	void	1425	void
1462	DESTROY(ctx)	1426	DESTROY(ctx)
1463	EVP_MD_CTX *ctx	1427	OpenSSL::Digest ctx
1464	CODE:	1428	CODE:
1465	if(ctx)	1429	if(ctx)
1466	free(ctx);	1430	free(ctx);
1467		1431
1468	void	1432	void
1469	update(ctx, sv)	1433	update(ctx, sv)
1470	EVP_MD_CTX *ctx	1434	OpenSSL::Digest ctx
1471	SV *sv	1435	SV *sv
1472	PREINIT:	1436	PREINIT:
1473	STRLEN l;	1437	STRLEN l;
1474	char *p;	1438	char *p;
1475	CODE:	1439	CODE:
…		…
1477	EVP_DigestUpdate(ctx, p, l);	1441	EVP_DigestUpdate(ctx, p, l);
1478		1442
1479		1443
1480	SV *	1444	SV *
1481	final(ctx)	1445	final(ctx)
1482	EVP_MD_CTX *ctx	1446	OpenSSL::Digest ctx
1483	ALIAS:	1447	ALIAS:
1484	final_hex = 1	1448	final_hex = 1
1485	final_base64 = 2	1449	final_base64 = 2
1486	PREINIT:	1450	PREINIT:
1487	unsigned char md[EVP_MAX_MD_SIZE];	1451	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1503	RETVAL	1467	RETVAL
1504		1468
1505		1469
1506	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1470	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1507		1471
1508	void	1472	OpenSSL::PKCS7
1509	new()	1473	new()
1510	PREINIT:
1511	PKCS7 *p7;
1512	PPCODE:	1474	CODE:
1513	if(!(p7 = PKCS7_new())) {	1475	if(!(RETVAL = PKCS7_new())) {
1514	croak("PKCS7_new");	1476	croak("PKCS7_new");
1515	}	1477	}
1516	EXTEND(sp, 1);	1478	OUTPUT:
1517	PUSHs(sv_newmortal());	1479	RETVAL
1518	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1519		1480
1520		1481
1521	void	1482	void
1522	DESTROY(p7)	1483	DESTROY(p7)
1523	PKCS7 *p7;	1484	OpenSSL::PKCS7 p7;
1524	CODE:	1485	CODE:
1525	if(p7) {	1486	if(p7) {
1526	XD("PKCS7_free(%p)\n", p7);	1487	XD("PKCS7_free(%p)\n", p7);
1527	PKCS7_free(p7);	1488	PKCS7_free(p7);
1528	}	1489	}
1529		1490
1530		1491
1531	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1492	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1532		1493
1533	void	1494	OpenSSL::PKCS12
1534	new()	1495	new(class)
1535	PREINIT:	1496	SV *class
1536	PKCS12 *p12;
1537	PPCODE:	1497	CODE:
1538	if(!(p12 = PKCS12_new())) {	1498	if(!(RETVAL = PKCS12_new())) {
1539	croak("PKCS12_new");	1499	croak("PKCS12_new");
1540	}	1500	}
1541	EXTEND(sp, 1);	1501	OUTPUT:
1542	PUSHs(sv_newmortal());	1502	RETVAL
1543	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1544		1503
1545	void	1504	OpenSSL::PKCS12
1546	new_from_string(sv)	1505	new_from_string(class,sv)
		1506	SV *class
1547	SV *sv	1507	SV *sv
1548	ALIAS:	1508	ALIAS:
1549	new_from_file = 1	1509	new_from_file = 1
1550	PREINIT:	1510	PREINIT:
1551	PKCS12 *p12;
1552	BIO *bio;	1511	BIO *bio;
1553	char *s;	1512	char *s;
1554	STRLEN len;	1513	STRLEN len;
1555	PPCODE:	1514	CODE:
1556	s = SvPV(sv, len);	1515	s = SvPV(sv, len);
1557	if(ix == 1) {	1516	if(ix == 1) {
1558	bio = BIO_new_file(s, "r");	1517	bio = BIO_new_file(s, "r");
1559	} else {	1518	} else {
1560	bio = BIO_new_mem_buf (s, len);	1519	bio = BIO_new_mem_buf (s, len);
1561	}	1520	}
1562	if(!bio)	1521	if(!bio)
1563	croak("BIO_new_mem_buf");	1522	croak("BIO_new_mem_buf");
1564	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1523	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1565	BIO_free(bio);	1524	BIO_free(bio);
1566	croak("d2i_PKCS12_BIO: %s", ssl_error());	1525	croak("d2i_PKCS12_BIO: %s", ssl_error());
1567	}	1526	}
1568	BIO_free(bio);	1527	BIO_free(bio);
1569	EXTEND(sp, 1);	1528	OUTPUT:
1570	PUSHs(sv_newmortal());	1529	RETVAL
1571	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1572		1530
1573		1531
1574	SV*	1532	SV*
1575	mac_ok(p12, pwd)	1533	mac_ok(p12, pwd)
1576	PKCS12 *p12	1534	OpenSSL::PKCS12 p12
1577	char *pwd	1535	char *pwd
1578	CODE:	1536	CODE:
1579		1537
1580	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;	1538	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1581	OUTPUT:	1539	OUTPUT:
1582	RETVAL	1540	RETVAL
1583		1541
1584	void	1542	void
1585	changepass(p12, oldpwd, newpwd)	1543	changepass(p12, oldpwd, newpwd)
1586	PKCS12 *p12	1544	OpenSSL::PKCS12 p12
1587	SV *oldpwd	1545	SV *oldpwd
1588	SV *newpwd	1546	SV *newpwd
1589	PREINIT:	1547	PREINIT:
1590	char *op = 0;	1548	char *op = 0;
1591	char *np = 0;	1549	char *np = 0;
…		…
1598	croak("PKCS12_newpass: %s", ssl_error());	1556	croak("PKCS12_newpass: %s", ssl_error());
1599	}	1557	}
1600		1558
1601	SV*	1559	SV*
1602	as_string(p12,...)	1560	as_string(p12,...)
1603	PKCS12 *p12	1561	OpenSSL::PKCS12 p12
1604	ALIAS:	1562	ALIAS:
1605	as_file = 1	1563	as_file = 1
1606	PROTOTYPE: $;$	1564	PROTOTYPE: $;$
1607	PREINIT:	1565	PREINIT:
1608	SV *sv;
1609	BIO *bio;	1566	BIO *bio;
1610	CODE:	1567	CODE:
1611	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))	1568	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))
1612	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");	1569	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");
1613	if(items > 1) {	1570	if(items > 1) {
…		…
1625	OUTPUT:	1582	OUTPUT:
1626	RETVAL	1583	RETVAL
1627		1584
1628	void	1585	void
1629	DESTROY(p12)	1586	DESTROY(p12)
1630	PKCS12 *p12;	1587	OpenSSL::PKCS12 p12;
1631	CODE:	1588	CODE:
1632	if(p12) {	1589	if(p12) {
1633	XD("PKCS12_free(%p)\n", p12);	1590	XD("PKCS12_free(%p)\n", p12);
1634	PKCS12_free(p12);	1591	PKCS12_free(p12);
1635	}	1592	}
1636		1593
1637		1594
1638	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1595	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1639		1596
1640	OpenSSL::CRL	1597	OpenSSL::CRL
1641	new_from_string(thing)	1598	new_from_string(class,thing)
		1599	SV *class
1642	SV *thing	1600	SV *thing
1643	ALIAS:	1601	ALIAS:
1644	new_from_file = 1	1602	new_from_file = 1
1645	PREINIT:	1603	PREINIT:
1646	BIO *bio;	1604	BIO *bio;
1647	STRLEN l;	1605	STRLEN l;
1648	char p, q = 0;	1606	char *p;
1649	CODE:	1607	CODE:
1650	p = SvPV(thing, l);	1608	p = SvPV(thing, l);
1651	if(ix == 1) {	1609	if(ix == 1) {
1652	bio = BIO_new_file(p, "r");	1610	bio = BIO_new_file(p, "r");
1653	} else {	1611	} else {

Diff Legend

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

Comparing OpenSSL/OpenSSL.xs (file contents): Revision 1.6 by root, Sat Oct 27 02:55:31 2001 UTC vs. Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC

Diff Legend

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.6 by root, Sat Oct 27 02:55:31 2001 UTC vs.
Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC