[p5sagit/p5-mst-13.2.git] / ext / Digest / SHA / SHA.xs

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "ppport.h"

#include <src/sha.c>
#include <src/hmac.c>

static int ix2alg[] =
	{1,1,1,224,224,224,256,256,256,384,384,384,512,512,512};

MODULE = Digest::SHA		PACKAGE = Digest::SHA		

PROTOTYPES: ENABLE

#include <src/sha.h>
#include <src/hmac.h>

int
shaclose(s)
	SHA *	s

int
shadump(file, s)
	char *	file
	SHA *	s

SHA *
shadup(s)
	SHA *	s

SHA *
shaload(file)
	char *	file

SHA *
shaopen(alg)
	int	alg

void
sharewind(s)
	SHA *	s

unsigned long
shawrite(bitstr, bitcnt, s)
	unsigned char *	bitstr
	unsigned long	bitcnt
	SHA *	s

void
sha1(...)
ALIAS:
	Digest::SHA::sha1 = 0
	Digest::SHA::sha1_hex = 1
	Digest::SHA::sha1_base64 = 2
	Digest::SHA::sha224 = 3
	Digest::SHA::sha224_hex = 4
	Digest::SHA::sha224_base64 = 5
	Digest::SHA::sha256 = 6
	Digest::SHA::sha256_hex = 7
	Digest::SHA::sha256_base64 = 8
	Digest::SHA::sha384 = 9
	Digest::SHA::sha384_hex = 10
	Digest::SHA::sha384_base64 = 11
	Digest::SHA::sha512 = 12
	Digest::SHA::sha512_hex = 13
	Digest::SHA::sha512_base64 = 14
PREINIT:
	int i;
	unsigned char *data;
	STRLEN len;
	SHA *state;
	char *result;
PPCODE:
	if ((state = shaopen(ix2alg[ix])) == NULL)
		XSRETURN_UNDEF;
	for (i = 0; i < items; i++) {
		data = (unsigned char *) (SvPV(ST(i), len));
		shawrite(data, len << 3, state);
	}
	shafinish(state);
	len = 0;
	if (ix % 3 == 0) {
		result = (char *) shadigest(state);
		len = shadsize(state);
	}
	else if (ix % 3 == 1)
		result = shahex(state);
	else
		result = shabase64(state);
	ST(0) = sv_2mortal(newSVpv(result, len));
	shaclose(state);
	XSRETURN(1);

void
hmac_sha1(...)
ALIAS:
	Digest::SHA::hmac_sha1 = 0
	Digest::SHA::hmac_sha1_hex = 1
	Digest::SHA::hmac_sha1_base64 = 2
	Digest::SHA::hmac_sha224 = 3
	Digest::SHA::hmac_sha224_hex = 4
	Digest::SHA::hmac_sha224_base64 = 5
	Digest::SHA::hmac_sha256 = 6
	Digest::SHA::hmac_sha256_hex = 7
	Digest::SHA::hmac_sha256_base64 = 8
	Digest::SHA::hmac_sha384 = 9
	Digest::SHA::hmac_sha384_hex = 10
	Digest::SHA::hmac_sha384_base64 = 11
	Digest::SHA::hmac_sha512 = 12
	Digest::SHA::hmac_sha512_hex = 13
	Digest::SHA::hmac_sha512_base64 = 14
PREINIT:
	int i;
	unsigned char *key;
	unsigned char *data;
	STRLEN len;
	HMAC *state;
	char *result;
PPCODE:
	key = (unsigned char *) (SvPV(ST(items-1), len));
	if ((state = hmacopen(ix2alg[ix], key, len)) == NULL)
		XSRETURN_UNDEF;
	for (i = 0; i < items - 1; i++) {
		data = (unsigned char *) (SvPV(ST(i), len));
		hmacwrite(data, len << 3, state);
	}
	hmacfinish(state);
	len = 0;
	if (ix % 3 == 0) {
		result = (char *) hmacdigest(state);
		len = shadsize(state->osha);
	}
	else if (ix % 3 == 1)
		result = hmachex(state);
	else
		result = hmacbase64(state);
	ST(0) = sv_2mortal(newSVpv(result, len));
	hmacclose(state);
	XSRETURN(1);

void
hashsize(self)
	SV *	self
ALIAS:
	Digest::SHA::hashsize = 0
	Digest::SHA::algorithm = 1
PREINIT:
	SHA *state;
	int result;
PPCODE:
	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
	result = shadsize(state) << 3;
	if (ix == 1 && result == 160)
		result = 1;
	ST(0) = sv_2mortal(newSViv(result));
	XSRETURN(1);

void
add(self, ...)
	SV *	self
PREINIT:
	int i;
	unsigned char *data;
	STRLEN len;
	SHA *state;
PPCODE:
	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
	for (i = 1; i < items; i++) {
		data = (unsigned char *) (SvPV(ST(i), len));
		shawrite(data, len << 3, state);
	}
	XSRETURN(1);

void
digest(self)
	SV *	self
ALIAS:
	Digest::SHA::digest = 0
	Digest::SHA::Hexdigest = 1
	Digest::SHA::B64digest = 2
PREINIT:
	STRLEN len;
	SHA *state;
	char *result;
PPCODE:
	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
	shafinish(state);
	len = 0;
	if (ix == 0) {
		result = (char *) shadigest(state);
		len = shadsize(state);
	}
	else if (ix == 1)
		result = shahex(state);
	else
		result = shabase64(state);
	ST(0) = sv_2mortal(newSVpv(result, len));
	sharewind(state);
	XSRETURN(1);
Commit	Line	Data
6bc89f92	1	#include "EXTERN.h"
	2	#include "perl.h"
	3	#include "XSUB.h"
	4
	5	#include "ppport.h"
	6
	7	#include <src/sha.c>
	8	#include <src/hmac.c>
	9
	10	static int ix2alg[] =
	11	{1,1,1,224,224,224,256,256,256,384,384,384,512,512,512};
	12
	13	MODULE = Digest::SHA PACKAGE = Digest::SHA
	14
	15	PROTOTYPES: ENABLE
	16
	17	#include <src/sha.h>
	18	#include <src/hmac.h>
	19
	20	int
	21	shaclose(s)
	22	SHA * s
	23
	24	int
	25	shadump(file, s)
	26	char * file
	27	SHA * s
	28
	29	SHA *
	30	shadup(s)
	31	SHA * s
	32
	33	SHA *
	34	shaload(file)
	35	char * file
	36
	37	SHA *
	38	shaopen(alg)
	39	int alg
	40
	41	void
	42	sharewind(s)
	43	SHA * s
	44
	45	unsigned long
	46	shawrite(bitstr, bitcnt, s)
	47	unsigned char * bitstr
	48	unsigned long bitcnt
	49	SHA * s
	50
	51	void
	52	sha1(...)
	53	ALIAS:
	54	Digest::SHA::sha1 = 0
	55	Digest::SHA::sha1_hex = 1
	56	Digest::SHA::sha1_base64 = 2
	57	Digest::SHA::sha224 = 3
	58	Digest::SHA::sha224_hex = 4
	59	Digest::SHA::sha224_base64 = 5
	60	Digest::SHA::sha256 = 6
	61	Digest::SHA::sha256_hex = 7
	62	Digest::SHA::sha256_base64 = 8
	63	Digest::SHA::sha384 = 9
	64	Digest::SHA::sha384_hex = 10
65	Digest::SHA::sha384_base64 = 11
66	Digest::SHA::sha512 = 12
67	Digest::SHA::sha512_hex = 13
68	Digest::SHA::sha512_base64 = 14
69	PREINIT:
70	int i;
71	unsigned char *data;
72	STRLEN len;
73	SHA *state;
74	char *result;
75	PPCODE:
76	if ((state = shaopen(ix2alg[ix])) == NULL)
77	XSRETURN_UNDEF;
78	for (i = 0; i < items; i++) {
79	data = (unsigned char *) (SvPV(ST(i), len));
80	shawrite(data, len << 3, state);
81	}
82	shafinish(state);
83	len = 0;
84	if (ix % 3 == 0) {
85	result = (char *) shadigest(state);
86	len = shadsize(state);
87	}
88	else if (ix % 3 == 1)
89	result = shahex(state);
90	else
91	result = shabase64(state);
92	ST(0) = sv_2mortal(newSVpv(result, len));
93	shaclose(state);
94	XSRETURN(1);
95
96	void
97	hmac_sha1(...)
98	ALIAS:
99	Digest::SHA::hmac_sha1 = 0
100	Digest::SHA::hmac_sha1_hex = 1
101	Digest::SHA::hmac_sha1_base64 = 2
102	Digest::SHA::hmac_sha224 = 3
103	Digest::SHA::hmac_sha224_hex = 4
104	Digest::SHA::hmac_sha224_base64 = 5
105	Digest::SHA::hmac_sha256 = 6
106	Digest::SHA::hmac_sha256_hex = 7
107	Digest::SHA::hmac_sha256_base64 = 8
108	Digest::SHA::hmac_sha384 = 9
109	Digest::SHA::hmac_sha384_hex = 10
110	Digest::SHA::hmac_sha384_base64 = 11
111	Digest::SHA::hmac_sha512 = 12
112	Digest::SHA::hmac_sha512_hex = 13
113	Digest::SHA::hmac_sha512_base64 = 14
114	PREINIT:
115	int i;
116	unsigned char *key;
117	unsigned char *data;
118	STRLEN len;
119	HMAC *state;
120	char *result;
121	PPCODE:
122	key = (unsigned char *) (SvPV(ST(items-1), len));
123	if ((state = hmacopen(ix2alg[ix], key, len)) == NULL)
124	XSRETURN_UNDEF;
125	for (i = 0; i < items - 1; i++) {
126	data = (unsigned char *) (SvPV(ST(i), len));
127	hmacwrite(data, len << 3, state);
128	}
129	hmacfinish(state);
130	len = 0;
131	if (ix % 3 == 0) {
132	result = (char *) hmacdigest(state);
133	len = shadsize(state->osha);
134	}
135	else if (ix % 3 == 1)
136	result = hmachex(state);
137	else
138	result = hmacbase64(state);
139	ST(0) = sv_2mortal(newSVpv(result, len));
140	hmacclose(state);
141	XSRETURN(1);
142
143	void
144	hashsize(self)
145	SV * self
146	ALIAS:
147	Digest::SHA::hashsize = 0
148	Digest::SHA::algorithm = 1
149	PREINIT:
150	SHA *state;
151	int result;
152	PPCODE:
153	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
154	result = shadsize(state) << 3;
155	if (ix == 1 && result == 160)
156	result = 1;
157	ST(0) = sv_2mortal(newSViv(result));
158	XSRETURN(1);
159
160	void
161	add(self, ...)
162	SV * self
163	PREINIT:
164	int i;
165	unsigned char *data;
166	STRLEN len;
167	SHA *state;
168	PPCODE:
169	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
170	for (i = 1; i < items; i++) {
171	data = (unsigned char *) (SvPV(ST(i), len));
172	shawrite(data, len << 3, state);
173	}
174	XSRETURN(1);
175
176	void
177	digest(self)
178	SV * self
179	ALIAS:
180	Digest::SHA::digest = 0
181	Digest::SHA::Hexdigest = 1
182	Digest::SHA::B64digest = 2
183	PREINIT:
184	STRLEN len;
185	SHA *state;
186	char *result;
187	PPCODE:
188	state = INT2PTR(SHA *, SvIV(SvRV(SvRV(self))));
189	shafinish(state);
190	len = 0;
191	if (ix == 0) {
192	result = (char *) shadigest(state);
193	len = shadsize(state);
194	}
195	else if (ix == 1)
196	result = shahex(state);
197	else
198	result = shabase64(state);
199	ST(0) = sv_2mortal(newSVpv(result, len));
200	sharewind(state);
201	XSRETURN(1);