Commit 611fb98ed8ecd6f1350abdc210db3e9315eef389 - libcryptx-perl

+72

-0

CryptX.xs less more

261	261	return str_add_leading_zero(str, maxlen, minlen);
262	262	}
263	263
	264	int _base16_encode(const unsigned char in, unsigned long inlen, unsigned char out, unsigned long *outlen)
	265	{
	266	unsigned long i;
	267	const char alphabet[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
	268
	269	if (outlen < inlen 2) {
	270	outlen = inlen 2;
	271	return CRYPT_BUFFER_OVERFLOW;
	272	}
	273
	274	for (i = 0; i < inlen; i++) {
	275	out[i*2] = (unsigned char)alphabet[in[i] >> 4];
	276	out[i*2+1] = (unsigned char)alphabet[in[i] & 0xF];
	277	}
	278
	279	outlen = inlen 2;
	280	return CRYPT_OK;
	281	}
	282
	283	int _find_hash(const char *name)
	284	{
	285	char ltcname[100] = { 0 };
	286	size_t i, start = 0, ltclen = sizeof(ltcname) - 1;
	287	if (name == NULL \|\| strlen(name) + 1 > ltclen) croak("FATAL: invalid hash name") ;
	288	/* normalize */
	289	for (i = 0; i < ltclen && name[i] > 0; i++) {
	290	if (name[i] >= 'A' && name[i] <= 'Z') {
	291	ltcname[i] = name[i] + 32; /* lowecase */
	292	}
	293	else if (name[i] == '_') {
	294	ltcname[i] = '-';
	295	}
	296	else {
	297	ltcname[i] = name[i];
	298	}
	299	if (name[i] == ':') start = i + 1;
	300	}
	301	/* special cases */
	302	if (strcmp(ltcname + start, "ripemd128") == 0) return find_hash("rmd128");
	303	if (strcmp(ltcname + start, "ripemd160") == 0) return find_hash("rmd160");
	304	if (strcmp(ltcname + start, "ripemd256") == 0) return find_hash("rmd256");
	305	if (strcmp(ltcname + start, "ripemd320") == 0) return find_hash("rmd320");
	306	if (strcmp(ltcname + start, "tiger192") == 0) return find_hash("tiger");
	307	if (strcmp(ltcname + start, "chaes") == 0) return find_hash("chc_hash");
	308	if (strcmp(ltcname + start, "chc-hash") == 0) return find_hash("chc_hash");
	309	return find_hash(ltcname + start);
	310	}
	311
	312	int _find_cipher(const char *name)
	313	{
	314	char ltcname[100] = { 0 };
	315	size_t i, start = 0, ltclen = sizeof(ltcname) - 1;
	316	if (name == NULL \|\| strlen(name) + 1 > ltclen) croak("FATAL: invalid cipher name") ;
	317	/* normalize */
	318	for (i = 0; i < ltclen && name[i] > 0; i++) {
	319	if (name[i] >= 'A' && name[i] <= 'Z') {
	320	ltcname[i] = name[i] + 32; /* lowecase */
	321	}
	322	else if (name[i] == '_') {
	323	ltcname[i] = '-';
	324	}
	325	else {
	326	ltcname[i] = name[i];
	327	}
	328	if (name[i] == ':') start = i + 1;
	329	}
	330	/* special cases */
	331	if (strcmp(ltcname + start, "des-ede") == 0) return find_cipher("3des");
	332	if (strcmp(ltcname + start, "saferp") == 0) return find_cipher("safer+");
	333	return find_cipher(ltcname + start);
	334	}
	335
264	336	/* Math::BigInt::LTM related */
265	337	typedef mp_int * Math__BigInt__LTM;
266	338	STATIC SV * sv_from_mpi(mp_int *mpi) {

+0

-8

_generators/Mac.pm.tt less more

12	12
13	13	use CryptX;
14	14	[%-IF lc_name == 'hmac' %]
15		use Crypt::Digest;
16
17		sub new { my $class = shift; _new(Crypt::Digest::_trans_digest_name(shift), @_) }
18	15	sub [%lc_name%] { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->mac }
19	16	sub [%lc_name%]_hex { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->hexmac }
20	17	sub [%lc_name%]_b64 { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->b64mac }
21	18	sub [%lc_name%]_b64u { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->b64umac }
22	19	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
23		sub new { my $class = shift; _new(@_) }
24	20	sub [%lc_name%] { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->mac }
25	21	sub [%lc_name%]_hex { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->hexmac }
26	22	sub [%lc_name%]_b64 { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->b64mac }
27	23	sub [%lc_name%]_b64u { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->b64umac }
28	24	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
29		sub new { my $class = shift; _new(@_) }
30	25	sub [%lc_name%] { Crypt::Mac::[%orig_name%]->new(shift)->add(@_)->mac }
31	26	sub [%lc_name%]_hex { Crypt::Mac::[%orig_name%]->new(shift)->add(@_)->hexmac }
32	27	sub [%lc_name%]_b64 { Crypt::Mac::[%orig_name%]->new(shift)->add(@_)->b64mac }
33	28	sub [%lc_name%]_b64u { Crypt::Mac::[%orig_name%]->new(shift)->add(@_)->b64umac }
34	29	[%-ELSE%]
35		use Crypt::Cipher;
36
37		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
38	30	sub [%lc_name%] { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->mac }
39	31	sub [%lc_name%]_hex { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->hexmac }
40	32	sub [%lc_name%]_b64 { Crypt::Mac::[%orig_name%]->new(shift, shift)->add(@_)->b64mac }

+75

-75

_generators/Mac.xs.inc.tt less more

3	3
4	4	Crypt::Mac::[%orig_name%]
5	5	[%-IF lc_name == 'hmac' %]
6		_new(char * hash_name, SV * key)
7		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
8		_new(int size, SV * key)
	6	new(char * class, char * hash_name, SV * key)
	7	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
	8	new(char * class, int size, SV * key)
9	9	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
10		_new(SV * key)
11		[%-ELSE%]
12		_new(char * cipher_name, SV * key)
	10	new(char * class, SV * key)
	11	[%-ELSE%]
	12	new(char * class, char * cipher_name, SV * key)
13	13	[%-END%]
14	14	CODE:
15	15	{

19	19	[%-IF lc_name == 'hmac' %]
20	20	int id;
21	21
22		id = find_hash(hash_name);
	22	id = _find_hash(hash_name);
23	23	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
24	24	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
25	25	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
26	26	[%-ELSE%]
27	27	int id;
28	28
29		id = find_cipher(cipher_name);
	29	id = _find_cipher(cipher_name);
30	30	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
31	31	[%-END%]
32	32

89	89	CODE:
90	90	{
91	91	char mac[MAXBLOCKSIZE];
92		unsigned long mac_len;
93		int rv;
94
95		[%-IF lc_name == 'pelican' %]
96		mac_len = 16;
	92	unsigned long maclen;
	93	int rv;
	94
	95	[%-IF lc_name == 'pelican' %]
	96	maclen = 16;
97	97	rv = [%lc_name%]_done(&self->state, (unsigned char*)mac);
98	98	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
99	99	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
100		mac_len = sizeof(mac);
101		rv = [%lc_name%]mac_done(&self->state, (unsigned char*)mac, &mac_len);
102		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
103		[%-ELSE%]
104		mac_len = sizeof(mac);
105		rv = [%lc_name%]_done(&self->state, (unsigned char*)mac, &mac_len);
106		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
107		[%-END%]
108		RETVAL = newSVpvn(mac, mac_len);
	100	maclen = sizeof(mac);
	101	rv = [%lc_name%]mac_done(&self->state, (unsigned char*)mac, &maclen);
	102	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
	103	[%-ELSE%]
	104	maclen = sizeof(mac);
	105	rv = [%lc_name%]_done(&self->state, (unsigned char*)mac, &maclen);
	106	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
	107	[%-END%]
	108	RETVAL = newSVpvn(mac, maclen);
109	109	}
110	110	OUTPUT:
111	111	RETVAL

115	115	CODE:
116	116	{
117	117	unsigned char mac[MAXBLOCKSIZE];
118		unsigned long mac_len;
	118	unsigned long maclen;
119	119	int rv;
120	120	unsigned long outlen;
121		char mac_base64[MAXBLOCKSIZE*2 + 1];
122
123		[%-IF lc_name == 'pelican' %]
124		mac_len = 16;
	121	char out[MAXBLOCKSIZE*2];
	122
	123	[%-IF lc_name == 'pelican' %]
	124	maclen = 16;
125	125	rv = [%lc_name%]_done(&self->state, mac);
126	126	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
127	127	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
128		mac_len = sizeof(mac);
129		rv = [%lc_name%]mac_done(&self->state, mac, &mac_len);
130		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
131		[%-ELSE%]
132		mac_len = sizeof(mac);
133		rv = [%lc_name%]_done(&self->state, mac, &mac_len);
134		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
135		[%-END%]
136		outlen = sizeof(mac_base64);
137		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	128	maclen = sizeof(mac);
	129	rv = [%lc_name%]mac_done(&self->state, mac, &maclen);
	130	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
	131	[%-ELSE%]
	132	maclen = sizeof(mac);
	133	rv = [%lc_name%]_done(&self->state, mac, &maclen);
	134	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
	135	[%-END%]
	136	outlen = sizeof(out);
	137	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
138	138	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
139		RETVAL = newSVpvn(mac_base64, outlen);
	139	RETVAL = newSVpvn(out, outlen);
140	140	}
141	141	OUTPUT:
142	142	RETVAL

146	146	CODE:
147	147	{
148	148	unsigned char mac[MAXBLOCKSIZE];
149		unsigned long mac_len;
	149	unsigned long maclen;
150	150	int rv;
151	151	unsigned long outlen;
152		char mac_base64[MAXBLOCKSIZE*2 + 1];
153
154		[%-IF lc_name == 'pelican' %]
155		mac_len = 16;
	152	char out[MAXBLOCKSIZE*2 + 1];
	153
	154	[%-IF lc_name == 'pelican' %]
	155	maclen = 16;
156	156	rv = [%lc_name%]_done(&self->state, mac);
157	157	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
158	158	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
159		mac_len = sizeof(mac);
160		rv = [%lc_name%]mac_done(&self->state, mac, &mac_len);
161		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
162		[%-ELSE%]
163		mac_len = sizeof(mac);
164		rv = [%lc_name%]_done(&self->state, mac, &mac_len);
165		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
166		[%-END%]
167		outlen = sizeof(mac_base64);
168		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	159	maclen = sizeof(mac);
	160	rv = [%lc_name%]mac_done(&self->state, mac, &maclen);
	161	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
	162	[%-ELSE%]
	163	maclen = sizeof(mac);
	164	rv = [%lc_name%]_done(&self->state, mac, &maclen);
	165	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
	166	[%-END%]
	167	outlen = sizeof(out);
	168	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
169	169	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
170		RETVAL = newSVpvn(mac_base64, outlen);
	170	RETVAL = newSVpvn(out, outlen);
171	171	}
172	172	OUTPUT:
173	173	RETVAL

177	177	CODE:
178	178	{
179	179	unsigned char mac[MAXBLOCKSIZE];
180		unsigned long mac_len, i;
181		int rv;
182		char mac_hex[MAXBLOCKSIZE*2 + 1];
183
184		[%-IF lc_name == 'pelican' %]
185		mac_len = 16;
	180	unsigned long maclen, outlen;
	181	int rv;
	182	char out[MAXBLOCKSIZE*2];
	183
	184	[%-IF lc_name == 'pelican' %]
	185	maclen = 16;
186	186	rv = [%lc_name%]_done(&self->state, mac);
187	187	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
188	188	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
189		mac_len = sizeof(mac);
190		rv = [%lc_name%]mac_done(&self->state, mac, &mac_len);
191		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
192		[%-ELSE%]
193		mac_len = sizeof(mac);
194		rv = [%lc_name%]_done(&self->state, mac, &mac_len);
195		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
196		[%-END%]
197		mac_hex[0] = '\0';
198		for(i=0; i<mac_len; i++)
199		sprintf(&mac_hex[2*i], "%02x", mac[i]);
200		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
201		}
202		OUTPUT:
203		RETVAL
	189	maclen = sizeof(mac);
	190	rv = [%lc_name%]mac_done(&self->state, mac, &maclen);
	191	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
	192	[%-ELSE%]
	193	maclen = sizeof(mac);
	194	rv = [%lc_name%]_done(&self->state, mac, &maclen);
	195	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
	196	[%-END%]
	197	outlen = sizeof(out);
	198	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	199	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	200	RETVAL = newSVpvn(out, outlen);
	201	}
	202	OUTPUT:
	203	RETVAL

+0

-2

_generators/Mode.pm.tt less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+3

-3

_generators/Mode.xs.inc.tt less more

3	3
4	4	Crypt::Mode::[%orig_name%]
5	5	[%-IF lc_name == 'ctr' %]
6		_new(char * cipher_name, int ctr_mode=0, int ctr_width=0, int rounds=0)
	6	new(char * class, char * cipher_name, int ctr_mode=0, int ctr_width=0, int rounds=0)
7	7	[%-ELSE%]
8		_new(char * cipher_name, int rounds=0)
	8	new(char * class, char * cipher_name, int rounds=0)
9	9	[%-END%]
10	10	CODE:
11	11	{

13	13	if (!RETVAL) croak("FATAL: Newz failed");
14	14	RETVAL->direction = 0;
15	15	RETVAL->cipher_rounds = rounds;
16		RETVAL->cipher_id = find_cipher(cipher_name);
	16	RETVAL->cipher_id = _find_cipher(cipher_name);
17	17	if (RETVAL->cipher_id == -1) {
18	18	Safefree(RETVAL);
19	19	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

_generators/Mode_p.xs.inc.tt less more

2	2	[%comment%]
3	3
4	4	Crypt::Mode::[%orig_name%]
5		_new(char * cipher_name, int padding=1, int rounds=0)
	5	new(char * class, char * cipher_name, int padding=1, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct [%lc_name%]_struct);

11	11	RETVAL->padlen = 0;
12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14		RETVAL->cipher_id = find_cipher(cipher_name);
	14	RETVAL->cipher_id = _find_cipher(cipher_name);
15	15	if (RETVAL->cipher_id == -1) {
16	16	Safefree(RETVAL);
17	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

inc/CryptX_AuthEnc_CCM.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::AuthEnc::CCM
1	1
2	2	Crypt::AuthEnc::CCM
3		_new(char * cipher_name, SV * key, SV * nonce, SV * adata, int tag_len, int pt_len)
	3	new(char * class, char * cipher_name, SV * key, SV * nonce, SV * adata, int tag_len, int pt_len)
4	4	CODE:
5	5	{
6	6	unsigned char *k=NULL;

20	20	if (!SvPOK(adata)) croak("FATAL: adata must be string/buffer scalar");
21	21	h = (unsigned char *) SvPVbyte(adata, h_len);
22	22
23		id = find_cipher(cipher_name);
	23	id = _find_cipher(cipher_name);
24	24	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
25	25
26	26	Newz(0, RETVAL, 1, struct ccm_struct);

+1

-1

inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::AuthEnc::ChaCha20Poly1305
1	1
2	2	Crypt::AuthEnc::ChaCha20Poly1305
3		_new(SV * key, SV * nonce = NULL)
	3	new(char * class, SV * key, SV * nonce = NULL)
4	4	CODE:
5	5	{
6	6	int rv;

+2

-2

inc/CryptX_AuthEnc_EAX.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::AuthEnc::EAX
1	1
2	2	Crypt::AuthEnc::EAX
3		_new(char * cipher_name, SV * key, SV * nonce, SV * adata=&PL_sv_undef)
	3	new(char * class, char * cipher_name, SV * key, SV * nonce, SV * adata=&PL_sv_undef)
4	4	CODE:
5	5	{
6	6	STRLEN k_len=0;

20	20	h = (unsigned char *) SvPVbyte(adata, h_len);
21	21	}
22	22
23		id = find_cipher(cipher_name);
	23	id = _find_cipher(cipher_name);
24	24	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
25	25
26	26	Newz(0, RETVAL, 1, struct eax_struct);

+2

-2

inc/CryptX_AuthEnc_GCM.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::AuthEnc::GCM
1	1
2	2	Crypt::AuthEnc::GCM
3		_new(char * cipher_name, SV * key, SV * nonce = NULL)
	3	new(char * class, char * cipher_name, SV * key, SV * nonce = NULL)
4	4	CODE:
5	5	{
6	6	STRLEN k_len = 0, iv_len = 0;

14	14	iv = (unsigned char *)SvPVbyte(nonce, iv_len);
15	15	}
16	16
17		id = find_cipher(cipher_name);
	17	id = _find_cipher(cipher_name);
18	18	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
19	19
20	20	Newz(0, RETVAL, 1, struct gcm_struct);

+2

-2

inc/CryptX_AuthEnc_OCB.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::AuthEnc::OCB
1	1
2	2	Crypt::AuthEnc::OCB
3		_new(char * cipher_name, SV * key, SV * nonce, unsigned long taglen)
	3	new(char * class, char * cipher_name, SV * key, SV * nonce, unsigned long taglen)
4	4	CODE:
5	5	{
6	6	STRLEN k_len=0;

14	14	if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
15	15	n = (unsigned char *) SvPVbyte(nonce, n_len);
16	16
17		id = find_cipher(cipher_name);
	17	id = _find_cipher(cipher_name);
18	18	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
19	19
20	20	Newz(0, RETVAL, 1, struct ocb_struct);

+75

-88

inc/CryptX_Cipher.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::Cipher
1	1
2	2	Crypt::Cipher
3		_new(cipher_name, key, rounds=0)
4		char * cipher_name
5		SV * key
6		int rounds
	3	new(char * class, ...)
7	4	CODE:
8	5	{
9	6	STRLEN key_len;
10		unsigned char *key_data=NULL;
11		int rv;
12		int id;
	7	unsigned char *key_data = NULL;
	8	SV *key;
	9	char *cipher_name;
	10	int rv, id, rounds = 0, idx;
	11
	12	/* we need to handle:
	13	Crypt::Cipher->new('AES');
	14	Crypt::Cipher::AES->new();
	15	*/
	16	idx = strcmp("Crypt::Cipher", class) == 0 ? 1 : 0;
	17	if (idx + 1 > items) croak("FATAL: missing argument");
	18	cipher_name = SvPVX(ST(idx));
	19	key = ST(idx + 1);
	20	if (idx + 3 <= items) rounds = (int)SvIV(ST(idx + 2));
13	21
14	22	if (!SvPOK (key)) croak("FATAL: key must be string scalar");
15	23	key_data = (unsigned char *)SvPVbyte(key, key_len);
16	24
17		id = find_cipher(cipher_name);
	25	id = _find_cipher(cipher_name);
18	26	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
19	27
20	28	Newz(0, RETVAL, 1, struct cipher_struct);

32	40	RETVAL
33	41
34	42	void
35		DESTROY(self)
36		Crypt::Cipher self
	43	DESTROY(Crypt::Cipher self)
37	44	CODE:
38	45	Safefree(self);
39	46
40		int
41		_max_keysize(self, ...)
42		Crypt::Cipher self
43		CODE:
44		RETVAL = self->desc->max_key_length;
45		OUTPUT:
46		RETVAL
47
48		int
49		_min_keysize(self, ...)
50		Crypt::Cipher self
51		CODE:
52		RETVAL = self->desc->min_key_length;
53		OUTPUT:
54		RETVAL
55
56		int
57		_blocksize(self, ...)
58		Crypt::Cipher self
59		CODE:
60		RETVAL = self->desc->block_length;
61		OUTPUT:
62		RETVAL
63
64		int
65		_default_rounds(self, ...)
66		Crypt::Cipher self
67		CODE:
68		RETVAL = self->desc->default_rounds;
69		OUTPUT:
70		RETVAL
71
72	47	SV *
73		encrypt(self, data)
74		Crypt::Cipher self
75		SV * data
	48	encrypt(Crypt::Cipher self, SV * data)
76	49	CODE:
77	50	{
78	51	int rv;

100	73	RETVAL
101	74
102	75	SV *
103		decrypt(self, data)
104		Crypt::Cipher self
105		SV * data
	76	decrypt(Crypt::Cipher self, SV * data)
106	77	CODE:
107	78	{
108	79	int rv;

130	101	RETVAL
131	102
132	103	int
133		_block_length_by_name(cipher_name)
134		char * cipher_name
	104	blocksize(SV * param, char * extra = NULL)
135	105	CODE:
136	106	{
137		int rv, id;
138
139		id = find_cipher(cipher_name);
140		if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
141
142		rv = cipher_descriptor[id].block_length;
143		if (!rv) XSRETURN_UNDEF;
144		RETVAL = rv;
	107	if (sv_isobject(param) && sv_derived_from(param, "Crypt::Cipher")) {
	108	IV tmp = SvIV((SV*)SvRV(param));
	109	Crypt__Cipher obj = INT2PTR(Crypt__Cipher, tmp);
	110	RETVAL = obj->desc->block_length;
	111	}
	112	else {
	113	char *name = SvPOK(param) && strcmp(SvPVX(param), "Crypt::Cipher") ? SvPVX(param) : extra;
	114	int rv, id = _find_cipher(name);
	115	if (id == -1) croak("FATAL: find_cipher failed for '%s'", name);
	116	rv = cipher_descriptor[id].block_length;
	117	if (!rv) croak("FATAL: invalid block_length for '%s'", name);
	118	RETVAL = rv;
	119	}
145	120	}
146	121	OUTPUT:
147	122	RETVAL
148	123
149	124	int
150		_min_key_length_by_name(cipher_name)
151		char * cipher_name
	125	max_keysize(SV * param, char * extra = NULL)
152	126	CODE:
153	127	{
154		int rv, id;
155
156		id = find_cipher(cipher_name);
157		if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
158
159		rv = cipher_descriptor[id].min_key_length;
160		if (!rv) XSRETURN_UNDEF;
161		RETVAL = rv;
	128	if (sv_isobject(param) && sv_derived_from(param, "Crypt::Cipher")) {
	129	IV tmp = SvIV((SV*)SvRV(param));
	130	Crypt__Cipher obj = INT2PTR(Crypt__Cipher, tmp);
	131	RETVAL = obj->desc->max_key_length;
	132	}
	133	else {
	134	char *name = SvPOK(param) && strcmp(SvPVX(param), "Crypt::Cipher") ? SvPVX(param) : extra;
	135	int rv, id = _find_cipher(name);
	136	if (id == -1) croak("FATAL: find_cipher failed for '%s'", name);
	137	rv = cipher_descriptor[id].max_key_length;
	138	if (!rv) croak("FATAL: invalid max_key_length for '%s'", name);
	139	RETVAL = rv;
	140	}
162	141	}
163	142	OUTPUT:
164	143	RETVAL
165	144
166	145	int
167		_max_key_length_by_name(cipher_name)
168		char * cipher_name
	146	min_keysize(SV * param, char * extra = NULL)
169	147	CODE:
170	148	{
171		int rv, id;
172
173		id = find_cipher(cipher_name);
174		if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
175
176		rv = cipher_descriptor[id].max_key_length;
177		if (!rv) XSRETURN_UNDEF;
178		RETVAL = rv;
	149	if (sv_isobject(param) && sv_derived_from(param, "Crypt::Cipher")) {
	150	IV tmp = SvIV((SV*)SvRV(param));
	151	Crypt__Cipher obj = INT2PTR(Crypt__Cipher, tmp);
	152	RETVAL = obj->desc->min_key_length;
	153	}
	154	else {
	155	char *name = SvPOK(param) && strcmp(SvPVX(param), "Crypt::Cipher") ? SvPVX(param) : extra;
	156	int rv, id = _find_cipher(name);
	157	if (id == -1) croak("FATAL: find_cipher failed for '%s'", name);
	158	rv = cipher_descriptor[id].min_key_length;
	159	if (!rv) croak("FATAL: invalid min_key_length for '%s'", name);
	160	RETVAL = rv;
	161	}
179	162	}
180	163	OUTPUT:
181	164	RETVAL
182	165
183	166	int
184		_default_rounds_by_name(cipher_name)
185		char * cipher_name
	167	default_rounds(SV * param, char * extra = NULL)
186	168	CODE:
187	169	{
188		int rv, id;
189
190		id = find_cipher(cipher_name);
191		if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
192
193		rv = cipher_descriptor[id].default_rounds;
194		if (!rv) XSRETURN_UNDEF;
195		RETVAL = rv;
	170	if (sv_isobject(param) && sv_derived_from(param, "Crypt::Cipher")) {
	171	IV tmp = SvIV((SV*)SvRV(param));
	172	Crypt__Cipher obj = INT2PTR(Crypt__Cipher, tmp);
	173	RETVAL = obj->desc->default_rounds;
	174	}
	175	else {
	176	char *name = SvPOK(param) && strcmp(SvPVX(param), "Crypt::Cipher") ? SvPVX(param) : extra;
	177	int rv, id = _find_cipher(name);
	178	if (id == -1) croak("FATAL: find_cipher failed for '%s'", name);
	179	rv = cipher_descriptor[id].default_rounds;
	180	if (!rv) XSRETURN_UNDEF;
	181	RETVAL = rv;
	182	}
196	183	}
197	184	OUTPUT:
198	185	RETVAL

+161

-81

inc/CryptX_Digest.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::Digest
1	1
2	2	Crypt::Digest
3		_new(digest_name)
4		char * digest_name
	3	new(char * cname, char * pname = NULL)
5	4	CODE:
6	5	{
7	6	int rv;
8	7	int id;
9
10		id = find_hash(digest_name);
	8	char *digest_name = strcmp(cname, "Crypt::Digest") == 0 ? pname : cname;
	9
	10	id = _find_hash(digest_name);
11	11	if (id == -1) croak("FATAL: find_hash failed for '%s'", digest_name);
12	12
13	13	Newz(0, RETVAL, 1, struct digest_struct);

25	25	RETVAL
26	26
27	27	void
28		DESTROY(self)
29		Crypt::Digest self
	28	DESTROY(Crypt::Digest self)
30	29	CODE:
31	30	Safefree(self);
32	31
33	32	void
34		reset(self)
35		Crypt::Digest self
	33	reset(Crypt::Digest self)
36	34	PPCODE:
37	35	{
38	36	int rv;

42	40	}
43	41
44	42	Crypt::Digest
45		clone(self)
46		Crypt::Digest self
	43	clone(Crypt::Digest self)
47	44	CODE:
48	45	Newz(0, RETVAL, 1, struct digest_struct);
49	46	if (!RETVAL) croak("FATAL: Newz failed");

70	67	}
71	68
72	69	SV *
73		digest(self)
74		Crypt::Digest self
	70	digest(Crypt::Digest self)
75	71	CODE:
76	72	{
77	73	unsigned char hash[MAXBLOCKSIZE];

85	81	RETVAL
86	82
87	83	SV *
88		hexdigest(self)
89		Crypt::Digest self
90		CODE:
91		{
92		int rv;
93		unsigned long i;
94		unsigned char hash[MAXBLOCKSIZE];
95		char hash_hex[MAXBLOCKSIZE*2 + 1];
96
97		rv = self->desc->done(&self->state, hash);
98		if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
99
100		hash_hex[0] = '\0';
101		for(i=0; i<self->desc->hashsize; i++)
102		sprintf(&hash_hex[2*i], "%02x", hash[i]);
103		RETVAL = newSVpvn(hash_hex, strlen(hash_hex));
104		}
105		OUTPUT:
106		RETVAL
107
108		SV *
109		b64digest(self)
110		Crypt::Digest self
	84	hexdigest(Crypt::Digest self)
111	85	CODE:
112	86	{
113	87	int rv;
114	88	unsigned long outlen;
115	89	unsigned char hash[MAXBLOCKSIZE];
116		char hash_base64[MAXBLOCKSIZE*2 + 1];
117
118		rv = self->desc->done(&self->state, hash);
119		if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
120
121		outlen = sizeof(hash_base64);
122		rv = base64_encode(hash, self->desc->hashsize, (unsigned char *)hash_base64, &outlen);
	90	char out[MAXBLOCKSIZE*2];
	91
	92	rv = self->desc->done(&self->state, hash);
	93	if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
	94
	95	outlen = sizeof(out);
	96	rv = _base16_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
	97	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	98	RETVAL = newSVpvn(out, outlen);
	99	}
	100	OUTPUT:
	101	RETVAL
	102
	103	SV *
	104	b64digest(Crypt::Digest self)
	105	CODE:
	106	{
	107	int rv;
	108	unsigned long outlen;
	109	unsigned char hash[MAXBLOCKSIZE];
	110	char out[MAXBLOCKSIZE*2];
	111
	112	rv = self->desc->done(&self->state, hash);
	113	if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
	114
	115	outlen = sizeof(out);
	116	rv = base64_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
123	117	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
124		RETVAL = newSVpvn(hash_base64, outlen);
125		}
126		OUTPUT:
127		RETVAL
128
129		SV *
130		b64udigest(self)
131		Crypt::Digest self
	118	RETVAL = newSVpvn(out, outlen);
	119	}
	120	OUTPUT:
	121	RETVAL
	122
	123	SV *
	124	b64udigest(Crypt::Digest self)
132	125	CODE:
133	126	{
134	127	int rv;
135	128	unsigned long outlen;
136	129	unsigned char hash[MAXBLOCKSIZE];
137		char hash_base64[MAXBLOCKSIZE*2 + 1];
138
139		rv = self->desc->done(&self->state, hash);
140		if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
141
142		outlen = sizeof(hash_base64);
143		rv = base64url_encode(hash, self->desc->hashsize, (unsigned char *)hash_base64, &outlen);
	130	char out[MAXBLOCKSIZE*2];
	131
	132	rv = self->desc->done(&self->state, hash);
	133	if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
	134
	135	outlen = sizeof(out);
	136	rv = base64url_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
144	137	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
145		RETVAL = newSVpvn(hash_base64, outlen);
	138	RETVAL = newSVpvn(out, outlen);
146	139	}
147	140	OUTPUT:
148	141	RETVAL
149	142
150	143	int
151		_hashsize(self)
152		Crypt::Digest self
153		CODE:
154		RETVAL = self->desc->hashsize;
155		OUTPUT:
156		RETVAL
157
158		int
159		_hashsize_by_name(digest_name)
160		char * digest_name
161		CODE:
162		{
163		int rv, id;
164
165		id = find_hash(digest_name);
166		if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
167
168		rv = hash_descriptor[id].hashsize;
169		if (!rv) croak("FATAL: invalid hashsize for '%s'", digest_name);;
170		RETVAL = rv;
171		}
172		OUTPUT:
173		RETVAL
	144	hashsize(SV * param, char * extra = NULL)
	145	CODE:
	146	{
	147	if (sv_isobject(param) && sv_derived_from(param, "Crypt::Digest")) {
	148	IV tmp = SvIV((SV*)SvRV(param));
	149	Crypt__Digest obj = INT2PTR(Crypt__Digest, tmp);
	150	RETVAL = obj->desc->hashsize;
	151	}
	152	else {
	153	char *digest_name;
	154	int rv, id;
	155	digest_name = SvPOK(param) && strcmp(SvPVX(param), "Crypt::Digest") ? SvPVX(param) : extra;
	156	id = _find_hash(digest_name);
	157	if (id == -1) croak("FATAL: find_hash failed for '%s'", digest_name);
	158	rv = hash_descriptor[id].hashsize;
	159	if (!rv) croak("FATAL: invalid hashsize for '%s'", digest_name);;
	160	RETVAL = rv;
	161	}
	162	}
	163	OUTPUT:
	164	RETVAL
	165
	166	SV *
	167	digest_data(char * digest_name, SV * data)
	168	CODE:
	169	{
	170	STRLEN inlen;
	171	int rv, id;
	172	unsigned char *in, hash[MAXBLOCKSIZE];
	173	unsigned long len = sizeof(hash);
	174
	175	id = _find_hash(digest_name);
	176	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
	177	in = (unsigned char *)SvPVbyte(data, inlen);
	178	rv = hash_memory(id, in, inlen, hash, &len);
	179	if (rv != CRYPT_OK) croak("FATAL: hash_memory failed: %s", error_to_string(rv));
	180	RETVAL = newSVpvn((char *) hash, len);
	181	}
	182	OUTPUT:
	183	RETVAL
	184
	185	SV *
	186	digest_data_hex(char * digest_name, SV * data)
	187	CODE:
	188	{
	189	STRLEN inlen;
	190	int rv, id;
	191	unsigned char *in, hash[MAXBLOCKSIZE];
	192	unsigned long len = sizeof(hash), outlen;
	193	char out[MAXBLOCKSIZE*2];
	194
	195	id = _find_hash(digest_name);
	196	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
	197	in = (unsigned char *)SvPVbyte(data, inlen);
	198	rv = hash_memory(id, in, inlen, hash, &len);
	199	if (rv != CRYPT_OK) croak("FATAL: hash_memory failed: %s", error_to_string(rv));
	200	outlen = sizeof(out);
	201	rv = _base16_encode(hash, len, (unsigned char *)out, &outlen);
	202	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	203	RETVAL = newSVpvn((char *) out, outlen);
	204	}
	205	OUTPUT:
	206	RETVAL
	207
	208	SV *
	209	digest_data_b64(char * digest_name, SV * data)
	210	CODE:
	211	{
	212	STRLEN inlen;
	213	int rv, id;
	214	unsigned char *in, hash[MAXBLOCKSIZE];
	215	unsigned long len = sizeof(hash), outlen;
	216	char out[MAXBLOCKSIZE*2];
	217
	218	id = _find_hash(digest_name);
	219	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
	220	in = (unsigned char *)SvPVbyte(data, inlen);
	221	rv = hash_memory(id, in, inlen, hash, &len);
	222	if (rv != CRYPT_OK) croak("FATAL: hash_memory failed: %s", error_to_string(rv));
	223	outlen = sizeof(out);
	224	rv = base64_encode(hash, len, (unsigned char *)out, &outlen);
	225	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	226	RETVAL = newSVpvn((char *) out, outlen);
	227
	228	}
	229	OUTPUT:
	230	RETVAL
	231
	232	SV *
	233	digest_data_b64u(char * digest_name, SV * data)
	234	CODE:
	235	{
	236	STRLEN inlen;
	237	int rv, id;
	238	unsigned char *in, hash[MAXBLOCKSIZE];
	239	unsigned long len = sizeof(hash), outlen;
	240	char out[MAXBLOCKSIZE*2];
	241
	242	id = _find_hash(digest_name);
	243	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
	244	in = (unsigned char *)SvPVbyte(data, inlen);
	245	rv = hash_memory(id, in, inlen, hash, &len);
	246	if (rv != CRYPT_OK) croak("FATAL: hash_memory failed: %s", error_to_string(rv));
	247	outlen = sizeof(out);
	248	rv = base64url_encode(hash, len, (unsigned char *)out, &outlen);
	249	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	250	RETVAL = newSVpvn((char *) out, outlen);
	251	}
	252	OUTPUT:
	253	RETVAL

+1

-1

inc/CryptX_Digest_SHAKE.xs.inc less more

0	0	MODULE = CryptX PACKAGE = Crypt::Digest::SHAKE
1	1
2	2	Crypt::Digest::SHAKE
3		_new(int num)
	3	new(char * class, int num)
4	4	CODE:
5	5	{
6	6	int rv;

+5

-5

inc/CryptX_KeyDerivation.xs.inc less more

16	16	unsigned char *salt_ptr=NULL;
17	17	STRLEN salt_len=0;
18	18
19		id = find_hash(hash_name);
	19	id = _find_hash(hash_name);
20	20	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
21	21
22	22	password_ptr = (unsigned char *)SvPVbyte(password, password_len);

55	55	unsigned char *salt_ptr=NULL;
56	56	STRLEN salt_len=0;
57	57
58		id = find_hash(hash_name);
	58	id = _find_hash(hash_name);
59	59	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
60	60
61	61	password_ptr = (unsigned char *)SvPVbyte(password, password_len);

93	93	unsigned char *salt_ptr=NULL;
94	94	STRLEN salt_len=0;
95	95
96		id = find_hash(hash_name);
	96	id = _find_hash(hash_name);
97	97	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
98	98
99	99	in_ptr = (unsigned char *)SvPVbyte(in, in_len);

124	124	unsigned char *info_ptr=NULL;
125	125	STRLEN info_len=0;
126	126
127		id = find_hash(hash_name);
	127	id = _find_hash(hash_name);
128	128	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
129	129
130	130	in_ptr = (unsigned char *)SvPVbyte(in, in_len);

164	164	unsigned char *salt_ptr=NULL;
165	165	STRLEN salt_len=0;
166	166
167		id = find_hash(hash_name);
	167	id = _find_hash(hash_name);
168	168	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
169	169
170	170	in_ptr = (unsigned char *)SvPVbyte(in, in_len);

+27

-27

inc/CryptX_Mac_BLAKE2b.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::BLAKE2b
5		_new(int size, SV * key)
	5	new(char * class, int size, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

58	58	CODE:
59	59	{
60	60	char mac[MAXBLOCKSIZE];
61		unsigned long mac_len;
	61	unsigned long maclen;
62	62	int rv;
63	63
64		mac_len = sizeof(mac);
65		rv = blake2bmac_done(&self->state, (unsigned char*)mac, &mac_len);
	64	maclen = sizeof(mac);
	65	rv = blake2bmac_done(&self->state, (unsigned char*)mac, &maclen);
66	66	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, mac_len);
	67	RETVAL = newSVpvn(mac, maclen);
68	68	}
69	69	OUTPUT:
70	70	RETVAL

74	74	CODE:
75	75	{
76	76	unsigned char mac[MAXBLOCKSIZE];
77		unsigned long mac_len;
	77	unsigned long maclen;
78	78	int rv;
79	79	unsigned long outlen;
80		char mac_base64[MAXBLOCKSIZE*2 + 1];
	80	char out[MAXBLOCKSIZE*2];
81	81
82		mac_len = sizeof(mac);
83		rv = blake2bmac_done(&self->state, mac, &mac_len);
	82	maclen = sizeof(mac);
	83	rv = blake2bmac_done(&self->state, mac, &maclen);
84	84	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
85		outlen = sizeof(mac_base64);
86		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	85	outlen = sizeof(out);
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(mac_base64, outlen);
	88	RETVAL = newSVpvn(out, outlen);
89	89	}
90	90	OUTPUT:
91	91	RETVAL

95	95	CODE:
96	96	{
97	97	unsigned char mac[MAXBLOCKSIZE];
98		unsigned long mac_len;
	98	unsigned long maclen;
99	99	int rv;
100	100	unsigned long outlen;
101		char mac_base64[MAXBLOCKSIZE*2 + 1];
	101	char out[MAXBLOCKSIZE*2 + 1];
102	102
103		mac_len = sizeof(mac);
104		rv = blake2bmac_done(&self->state, mac, &mac_len);
	103	maclen = sizeof(mac);
	104	rv = blake2bmac_done(&self->state, mac, &maclen);
105	105	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
106		outlen = sizeof(mac_base64);
107		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	106	outlen = sizeof(out);
	107	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108	108	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(mac_base64, outlen);
	109	RETVAL = newSVpvn(out, outlen);
110	110	}
111	111	OUTPUT:
112	112	RETVAL

116	116	CODE:
117	117	{
118	118	unsigned char mac[MAXBLOCKSIZE];
119		unsigned long mac_len, i;
	119	unsigned long maclen, outlen;
120	120	int rv;
121		char mac_hex[MAXBLOCKSIZE*2 + 1];
	121	char out[MAXBLOCKSIZE*2];
122	122
123		mac_len = sizeof(mac);
124		rv = blake2bmac_done(&self->state, mac, &mac_len);
	123	maclen = sizeof(mac);
	124	rv = blake2bmac_done(&self->state, mac, &maclen);
125	125	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
126		mac_hex[0] = '\0';
127		for(i=0; i<mac_len; i++)
128		sprintf(&mac_hex[2*i], "%02x", mac[i]);
129		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	126	outlen = sizeof(out);
	127	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	128	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	129	RETVAL = newSVpvn(out, outlen);
130	130	}
131	131	OUTPUT:
132	132	RETVAL

+27

-27

inc/CryptX_Mac_BLAKE2s.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::BLAKE2s
5		_new(int size, SV * key)
	5	new(char * class, int size, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

58	58	CODE:
59	59	{
60	60	char mac[MAXBLOCKSIZE];
61		unsigned long mac_len;
	61	unsigned long maclen;
62	62	int rv;
63	63
64		mac_len = sizeof(mac);
65		rv = blake2smac_done(&self->state, (unsigned char*)mac, &mac_len);
	64	maclen = sizeof(mac);
	65	rv = blake2smac_done(&self->state, (unsigned char*)mac, &maclen);
66	66	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, mac_len);
	67	RETVAL = newSVpvn(mac, maclen);
68	68	}
69	69	OUTPUT:
70	70	RETVAL

74	74	CODE:
75	75	{
76	76	unsigned char mac[MAXBLOCKSIZE];
77		unsigned long mac_len;
	77	unsigned long maclen;
78	78	int rv;
79	79	unsigned long outlen;
80		char mac_base64[MAXBLOCKSIZE*2 + 1];
	80	char out[MAXBLOCKSIZE*2];
81	81
82		mac_len = sizeof(mac);
83		rv = blake2smac_done(&self->state, mac, &mac_len);
	82	maclen = sizeof(mac);
	83	rv = blake2smac_done(&self->state, mac, &maclen);
84	84	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
85		outlen = sizeof(mac_base64);
86		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	85	outlen = sizeof(out);
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(mac_base64, outlen);
	88	RETVAL = newSVpvn(out, outlen);
89	89	}
90	90	OUTPUT:
91	91	RETVAL

95	95	CODE:
96	96	{
97	97	unsigned char mac[MAXBLOCKSIZE];
98		unsigned long mac_len;
	98	unsigned long maclen;
99	99	int rv;
100	100	unsigned long outlen;
101		char mac_base64[MAXBLOCKSIZE*2 + 1];
	101	char out[MAXBLOCKSIZE*2 + 1];
102	102
103		mac_len = sizeof(mac);
104		rv = blake2smac_done(&self->state, mac, &mac_len);
	103	maclen = sizeof(mac);
	104	rv = blake2smac_done(&self->state, mac, &maclen);
105	105	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
106		outlen = sizeof(mac_base64);
107		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	106	outlen = sizeof(out);
	107	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108	108	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(mac_base64, outlen);
	109	RETVAL = newSVpvn(out, outlen);
110	110	}
111	111	OUTPUT:
112	112	RETVAL

116	116	CODE:
117	117	{
118	118	unsigned char mac[MAXBLOCKSIZE];
119		unsigned long mac_len, i;
	119	unsigned long maclen, outlen;
120	120	int rv;
121		char mac_hex[MAXBLOCKSIZE*2 + 1];
	121	char out[MAXBLOCKSIZE*2];
122	122
123		mac_len = sizeof(mac);
124		rv = blake2smac_done(&self->state, mac, &mac_len);
	123	maclen = sizeof(mac);
	124	rv = blake2smac_done(&self->state, mac, &maclen);
125	125	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
126		mac_hex[0] = '\0';
127		for(i=0; i<mac_len; i++)
128		sprintf(&mac_hex[2*i], "%02x", mac[i]);
129		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	126	outlen = sizeof(out);
	127	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	128	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	129	RETVAL = newSVpvn(out, outlen);
130	130	}
131	131	OUTPUT:
132	132	RETVAL

+28

-28

inc/CryptX_Mac_F9.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::F9
5		_new(char * cipher_name, SV * key)
	5	new(char * class, char * cipher_name, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

10	10	int rv;
11	11	int id;
12	12
13		id = find_cipher(cipher_name);
	13	id = _find_cipher(cipher_name);
14	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

62	62	CODE:
63	63	{
64	64	char mac[MAXBLOCKSIZE];
65		unsigned long mac_len;
	65	unsigned long maclen;
66	66	int rv;
67	67
68		mac_len = sizeof(mac);
69		rv = f9_done(&self->state, (unsigned char*)mac, &mac_len);
	68	maclen = sizeof(mac);
	69	rv = f9_done(&self->state, (unsigned char*)mac, &maclen);
70	70	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, mac_len);
	71	RETVAL = newSVpvn(mac, maclen);
72	72	}
73	73	OUTPUT:
74	74	RETVAL

78	78	CODE:
79	79	{
80	80	unsigned char mac[MAXBLOCKSIZE];
81		unsigned long mac_len;
	81	unsigned long maclen;
82	82	int rv;
83	83	unsigned long outlen;
84		char mac_base64[MAXBLOCKSIZE*2 + 1];
	84	char out[MAXBLOCKSIZE*2];
85	85
86		mac_len = sizeof(mac);
87		rv = f9_done(&self->state, mac, &mac_len);
	86	maclen = sizeof(mac);
	87	rv = f9_done(&self->state, mac, &maclen);
88	88	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
89		outlen = sizeof(mac_base64);
90		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	89	outlen = sizeof(out);
	90	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91	91	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(mac_base64, outlen);
	92	RETVAL = newSVpvn(out, outlen);
93	93	}
94	94	OUTPUT:
95	95	RETVAL

99	99	CODE:
100	100	{
101	101	unsigned char mac[MAXBLOCKSIZE];
102		unsigned long mac_len;
	102	unsigned long maclen;
103	103	int rv;
104	104	unsigned long outlen;
105		char mac_base64[MAXBLOCKSIZE*2 + 1];
	105	char out[MAXBLOCKSIZE*2 + 1];
106	106
107		mac_len = sizeof(mac);
108		rv = f9_done(&self->state, mac, &mac_len);
	107	maclen = sizeof(mac);
	108	rv = f9_done(&self->state, mac, &maclen);
109	109	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
110		outlen = sizeof(mac_base64);
111		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	110	outlen = sizeof(out);
	111	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112	112	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(mac_base64, outlen);
	113	RETVAL = newSVpvn(out, outlen);
114	114	}
115	115	OUTPUT:
116	116	RETVAL

120	120	CODE:
121	121	{
122	122	unsigned char mac[MAXBLOCKSIZE];
123		unsigned long mac_len, i;
	123	unsigned long maclen, outlen;
124	124	int rv;
125		char mac_hex[MAXBLOCKSIZE*2 + 1];
	125	char out[MAXBLOCKSIZE*2];
126	126
127		mac_len = sizeof(mac);
128		rv = f9_done(&self->state, mac, &mac_len);
	127	maclen = sizeof(mac);
	128	rv = f9_done(&self->state, mac, &maclen);
129	129	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
130		mac_hex[0] = '\0';
131		for(i=0; i<mac_len; i++)
132		sprintf(&mac_hex[2*i], "%02x", mac[i]);
133		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	130	outlen = sizeof(out);
	131	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	132	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	133	RETVAL = newSVpvn(out, outlen);
134	134	}
135	135	OUTPUT:
136	136	RETVAL

+28

-28

inc/CryptX_Mac_HMAC.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::HMAC
5		_new(char * hash_name, SV * key)
	5	new(char * class, char * hash_name, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

10	10	int rv;
11	11	int id;
12	12
13		id = find_hash(hash_name);
	13	id = _find_hash(hash_name);
14	14	if (id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

62	62	CODE:
63	63	{
64	64	char mac[MAXBLOCKSIZE];
65		unsigned long mac_len;
	65	unsigned long maclen;
66	66	int rv;
67	67
68		mac_len = sizeof(mac);
69		rv = hmac_done(&self->state, (unsigned char*)mac, &mac_len);
	68	maclen = sizeof(mac);
	69	rv = hmac_done(&self->state, (unsigned char*)mac, &maclen);
70	70	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, mac_len);
	71	RETVAL = newSVpvn(mac, maclen);
72	72	}
73	73	OUTPUT:
74	74	RETVAL

78	78	CODE:
79	79	{
80	80	unsigned char mac[MAXBLOCKSIZE];
81		unsigned long mac_len;
	81	unsigned long maclen;
82	82	int rv;
83	83	unsigned long outlen;
84		char mac_base64[MAXBLOCKSIZE*2 + 1];
	84	char out[MAXBLOCKSIZE*2];
85	85
86		mac_len = sizeof(mac);
87		rv = hmac_done(&self->state, mac, &mac_len);
	86	maclen = sizeof(mac);
	87	rv = hmac_done(&self->state, mac, &maclen);
88	88	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(mac_base64);
90		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	89	outlen = sizeof(out);
	90	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91	91	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(mac_base64, outlen);
	92	RETVAL = newSVpvn(out, outlen);
93	93	}
94	94	OUTPUT:
95	95	RETVAL

99	99	CODE:
100	100	{
101	101	unsigned char mac[MAXBLOCKSIZE];
102		unsigned long mac_len;
	102	unsigned long maclen;
103	103	int rv;
104	104	unsigned long outlen;
105		char mac_base64[MAXBLOCKSIZE*2 + 1];
	105	char out[MAXBLOCKSIZE*2 + 1];
106	106
107		mac_len = sizeof(mac);
108		rv = hmac_done(&self->state, mac, &mac_len);
	107	maclen = sizeof(mac);
	108	rv = hmac_done(&self->state, mac, &maclen);
109	109	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(mac_base64);
111		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	110	outlen = sizeof(out);
	111	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112	112	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(mac_base64, outlen);
	113	RETVAL = newSVpvn(out, outlen);
114	114	}
115	115	OUTPUT:
116	116	RETVAL

120	120	CODE:
121	121	{
122	122	unsigned char mac[MAXBLOCKSIZE];
123		unsigned long mac_len, i;
	123	unsigned long maclen, outlen;
124	124	int rv;
125		char mac_hex[MAXBLOCKSIZE*2 + 1];
	125	char out[MAXBLOCKSIZE*2];
126	126
127		mac_len = sizeof(mac);
128		rv = hmac_done(&self->state, mac, &mac_len);
	127	maclen = sizeof(mac);
	128	rv = hmac_done(&self->state, mac, &maclen);
129	129	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
130		mac_hex[0] = '\0';
131		for(i=0; i<mac_len; i++)
132		sprintf(&mac_hex[2*i], "%02x", mac[i]);
133		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	130	outlen = sizeof(out);
	131	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	132	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	133	RETVAL = newSVpvn(out, outlen);
134	134	}
135	135	OUTPUT:
136	136	RETVAL

+28

-28

inc/CryptX_Mac_OMAC.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::OMAC
5		_new(char * cipher_name, SV * key)
	5	new(char * class, char * cipher_name, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

10	10	int rv;
11	11	int id;
12	12
13		id = find_cipher(cipher_name);
	13	id = _find_cipher(cipher_name);
14	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

62	62	CODE:
63	63	{
64	64	char mac[MAXBLOCKSIZE];
65		unsigned long mac_len;
	65	unsigned long maclen;
66	66	int rv;
67	67
68		mac_len = sizeof(mac);
69		rv = omac_done(&self->state, (unsigned char*)mac, &mac_len);
	68	maclen = sizeof(mac);
	69	rv = omac_done(&self->state, (unsigned char*)mac, &maclen);
70	70	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, mac_len);
	71	RETVAL = newSVpvn(mac, maclen);
72	72	}
73	73	OUTPUT:
74	74	RETVAL

78	78	CODE:
79	79	{
80	80	unsigned char mac[MAXBLOCKSIZE];
81		unsigned long mac_len;
	81	unsigned long maclen;
82	82	int rv;
83	83	unsigned long outlen;
84		char mac_base64[MAXBLOCKSIZE*2 + 1];
	84	char out[MAXBLOCKSIZE*2];
85	85
86		mac_len = sizeof(mac);
87		rv = omac_done(&self->state, mac, &mac_len);
	86	maclen = sizeof(mac);
	87	rv = omac_done(&self->state, mac, &maclen);
88	88	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(mac_base64);
90		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	89	outlen = sizeof(out);
	90	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91	91	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(mac_base64, outlen);
	92	RETVAL = newSVpvn(out, outlen);
93	93	}
94	94	OUTPUT:
95	95	RETVAL

99	99	CODE:
100	100	{
101	101	unsigned char mac[MAXBLOCKSIZE];
102		unsigned long mac_len;
	102	unsigned long maclen;
103	103	int rv;
104	104	unsigned long outlen;
105		char mac_base64[MAXBLOCKSIZE*2 + 1];
	105	char out[MAXBLOCKSIZE*2 + 1];
106	106
107		mac_len = sizeof(mac);
108		rv = omac_done(&self->state, mac, &mac_len);
	107	maclen = sizeof(mac);
	108	rv = omac_done(&self->state, mac, &maclen);
109	109	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(mac_base64);
111		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	110	outlen = sizeof(out);
	111	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112	112	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(mac_base64, outlen);
	113	RETVAL = newSVpvn(out, outlen);
114	114	}
115	115	OUTPUT:
116	116	RETVAL

120	120	CODE:
121	121	{
122	122	unsigned char mac[MAXBLOCKSIZE];
123		unsigned long mac_len, i;
	123	unsigned long maclen, outlen;
124	124	int rv;
125		char mac_hex[MAXBLOCKSIZE*2 + 1];
	125	char out[MAXBLOCKSIZE*2];
126	126
127		mac_len = sizeof(mac);
128		rv = omac_done(&self->state, mac, &mac_len);
	127	maclen = sizeof(mac);
	128	rv = omac_done(&self->state, mac, &maclen);
129	129	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
130		mac_hex[0] = '\0';
131		for(i=0; i<mac_len; i++)
132		sprintf(&mac_hex[2*i], "%02x", mac[i]);
133		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	130	outlen = sizeof(out);
	131	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	132	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	133	RETVAL = newSVpvn(out, outlen);
134	134	}
135	135	OUTPUT:
136	136	RETVAL

+28

-28

inc/CryptX_Mac_PMAC.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::PMAC
5		_new(char * cipher_name, SV * key)
	5	new(char * class, char * cipher_name, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

10	10	int rv;
11	11	int id;
12	12
13		id = find_cipher(cipher_name);
	13	id = _find_cipher(cipher_name);
14	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

62	62	CODE:
63	63	{
64	64	char mac[MAXBLOCKSIZE];
65		unsigned long mac_len;
	65	unsigned long maclen;
66	66	int rv;
67	67
68		mac_len = sizeof(mac);
69		rv = pmac_done(&self->state, (unsigned char*)mac, &mac_len);
	68	maclen = sizeof(mac);
	69	rv = pmac_done(&self->state, (unsigned char*)mac, &maclen);
70	70	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, mac_len);
	71	RETVAL = newSVpvn(mac, maclen);
72	72	}
73	73	OUTPUT:
74	74	RETVAL

78	78	CODE:
79	79	{
80	80	unsigned char mac[MAXBLOCKSIZE];
81		unsigned long mac_len;
	81	unsigned long maclen;
82	82	int rv;
83	83	unsigned long outlen;
84		char mac_base64[MAXBLOCKSIZE*2 + 1];
	84	char out[MAXBLOCKSIZE*2];
85	85
86		mac_len = sizeof(mac);
87		rv = pmac_done(&self->state, mac, &mac_len);
	86	maclen = sizeof(mac);
	87	rv = pmac_done(&self->state, mac, &maclen);
88	88	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(mac_base64);
90		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	89	outlen = sizeof(out);
	90	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91	91	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(mac_base64, outlen);
	92	RETVAL = newSVpvn(out, outlen);
93	93	}
94	94	OUTPUT:
95	95	RETVAL

99	99	CODE:
100	100	{
101	101	unsigned char mac[MAXBLOCKSIZE];
102		unsigned long mac_len;
	102	unsigned long maclen;
103	103	int rv;
104	104	unsigned long outlen;
105		char mac_base64[MAXBLOCKSIZE*2 + 1];
	105	char out[MAXBLOCKSIZE*2 + 1];
106	106
107		mac_len = sizeof(mac);
108		rv = pmac_done(&self->state, mac, &mac_len);
	107	maclen = sizeof(mac);
	108	rv = pmac_done(&self->state, mac, &maclen);
109	109	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(mac_base64);
111		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	110	outlen = sizeof(out);
	111	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112	112	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(mac_base64, outlen);
	113	RETVAL = newSVpvn(out, outlen);
114	114	}
115	115	OUTPUT:
116	116	RETVAL

120	120	CODE:
121	121	{
122	122	unsigned char mac[MAXBLOCKSIZE];
123		unsigned long mac_len, i;
	123	unsigned long maclen, outlen;
124	124	int rv;
125		char mac_hex[MAXBLOCKSIZE*2 + 1];
	125	char out[MAXBLOCKSIZE*2];
126	126
127		mac_len = sizeof(mac);
128		rv = pmac_done(&self->state, mac, &mac_len);
	127	maclen = sizeof(mac);
	128	rv = pmac_done(&self->state, mac, &maclen);
129	129	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
130		mac_hex[0] = '\0';
131		for(i=0; i<mac_len; i++)
132		sprintf(&mac_hex[2*i], "%02x", mac[i]);
133		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	130	outlen = sizeof(out);
	131	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	132	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	133	RETVAL = newSVpvn(out, outlen);
134	134	}
135	135	OUTPUT:
136	136	RETVAL

+23

-23

inc/CryptX_Mac_Pelican.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::Pelican
5		_new(SV * key)
	5	new(char * class, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

58	58	CODE:
59	59	{
60	60	char mac[MAXBLOCKSIZE];
61		unsigned long mac_len;
	61	unsigned long maclen;
62	62	int rv;
63	63
64		mac_len = 16;
	64	maclen = 16;
65	65	rv = pelican_done(&self->state, (unsigned char*)mac);
66	66	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, mac_len);
	67	RETVAL = newSVpvn(mac, maclen);
68	68	}
69	69	OUTPUT:
70	70	RETVAL

74	74	CODE:
75	75	{
76	76	unsigned char mac[MAXBLOCKSIZE];
77		unsigned long mac_len;
	77	unsigned long maclen;
78	78	int rv;
79	79	unsigned long outlen;
80		char mac_base64[MAXBLOCKSIZE*2 + 1];
	80	char out[MAXBLOCKSIZE*2];
81	81
82		mac_len = 16;
	82	maclen = 16;
83	83	rv = pelican_done(&self->state, mac);
84	84	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
85		outlen = sizeof(mac_base64);
86		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	85	outlen = sizeof(out);
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(mac_base64, outlen);
	88	RETVAL = newSVpvn(out, outlen);
89	89	}
90	90	OUTPUT:
91	91	RETVAL

95	95	CODE:
96	96	{
97	97	unsigned char mac[MAXBLOCKSIZE];
98		unsigned long mac_len;
	98	unsigned long maclen;
99	99	int rv;
100	100	unsigned long outlen;
101		char mac_base64[MAXBLOCKSIZE*2 + 1];
	101	char out[MAXBLOCKSIZE*2 + 1];
102	102
103		mac_len = 16;
	103	maclen = 16;
104	104	rv = pelican_done(&self->state, mac);
105	105	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
106		outlen = sizeof(mac_base64);
107		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	106	outlen = sizeof(out);
	107	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108	108	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(mac_base64, outlen);
	109	RETVAL = newSVpvn(out, outlen);
110	110	}
111	111	OUTPUT:
112	112	RETVAL

116	116	CODE:
117	117	{
118	118	unsigned char mac[MAXBLOCKSIZE];
119		unsigned long mac_len, i;
	119	unsigned long maclen, outlen;
120	120	int rv;
121		char mac_hex[MAXBLOCKSIZE*2 + 1];
	121	char out[MAXBLOCKSIZE*2];
122	122
123		mac_len = 16;
	123	maclen = 16;
124	124	rv = pelican_done(&self->state, mac);
125	125	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
126		mac_hex[0] = '\0';
127		for(i=0; i<mac_len; i++)
128		sprintf(&mac_hex[2*i], "%02x", mac[i]);
129		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	126	outlen = sizeof(out);
	127	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	128	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	129	RETVAL = newSVpvn(out, outlen);
130	130	}
131	131	OUTPUT:
132	132	RETVAL

+27

-27

inc/CryptX_Mac_Poly1305.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::Poly1305
5		_new(SV * key)
	5	new(char * class, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

58	58	CODE:
59	59	{
60	60	char mac[MAXBLOCKSIZE];
61		unsigned long mac_len;
	61	unsigned long maclen;
62	62	int rv;
63	63
64		mac_len = sizeof(mac);
65		rv = poly1305_done(&self->state, (unsigned char*)mac, &mac_len);
	64	maclen = sizeof(mac);
	65	rv = poly1305_done(&self->state, (unsigned char*)mac, &maclen);
66	66	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, mac_len);
	67	RETVAL = newSVpvn(mac, maclen);
68	68	}
69	69	OUTPUT:
70	70	RETVAL

74	74	CODE:
75	75	{
76	76	unsigned char mac[MAXBLOCKSIZE];
77		unsigned long mac_len;
	77	unsigned long maclen;
78	78	int rv;
79	79	unsigned long outlen;
80		char mac_base64[MAXBLOCKSIZE*2 + 1];
	80	char out[MAXBLOCKSIZE*2];
81	81
82		mac_len = sizeof(mac);
83		rv = poly1305_done(&self->state, mac, &mac_len);
	82	maclen = sizeof(mac);
	83	rv = poly1305_done(&self->state, mac, &maclen);
84	84	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
85		outlen = sizeof(mac_base64);
86		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	85	outlen = sizeof(out);
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(mac_base64, outlen);
	88	RETVAL = newSVpvn(out, outlen);
89	89	}
90	90	OUTPUT:
91	91	RETVAL

95	95	CODE:
96	96	{
97	97	unsigned char mac[MAXBLOCKSIZE];
98		unsigned long mac_len;
	98	unsigned long maclen;
99	99	int rv;
100	100	unsigned long outlen;
101		char mac_base64[MAXBLOCKSIZE*2 + 1];
	101	char out[MAXBLOCKSIZE*2 + 1];
102	102
103		mac_len = sizeof(mac);
104		rv = poly1305_done(&self->state, mac, &mac_len);
	103	maclen = sizeof(mac);
	104	rv = poly1305_done(&self->state, mac, &maclen);
105	105	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
106		outlen = sizeof(mac_base64);
107		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	106	outlen = sizeof(out);
	107	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108	108	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(mac_base64, outlen);
	109	RETVAL = newSVpvn(out, outlen);
110	110	}
111	111	OUTPUT:
112	112	RETVAL

116	116	CODE:
117	117	{
118	118	unsigned char mac[MAXBLOCKSIZE];
119		unsigned long mac_len, i;
	119	unsigned long maclen, outlen;
120	120	int rv;
121		char mac_hex[MAXBLOCKSIZE*2 + 1];
	121	char out[MAXBLOCKSIZE*2];
122	122
123		mac_len = sizeof(mac);
124		rv = poly1305_done(&self->state, mac, &mac_len);
	123	maclen = sizeof(mac);
	124	rv = poly1305_done(&self->state, mac, &maclen);
125	125	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
126		mac_hex[0] = '\0';
127		for(i=0; i<mac_len; i++)
128		sprintf(&mac_hex[2*i], "%02x", mac[i]);
129		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	126	outlen = sizeof(out);
	127	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	128	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	129	RETVAL = newSVpvn(out, outlen);
130	130	}
131	131	OUTPUT:
132	132	RETVAL

+28

-28

inc/CryptX_Mac_XCBC.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mac::XCBC
5		_new(char * cipher_name, SV * key)
	5	new(char * class, char * cipher_name, SV * key)
6	6	CODE:
7	7	{
8	8	STRLEN k_len=0;

10	10	int rv;
11	11	int id;
12	12
13		id = find_cipher(cipher_name);
	13	id = _find_cipher(cipher_name);
14	14	if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
15	15
16	16	if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");

62	62	CODE:
63	63	{
64	64	char mac[MAXBLOCKSIZE];
65		unsigned long mac_len;
	65	unsigned long maclen;
66	66	int rv;
67	67
68		mac_len = sizeof(mac);
69		rv = xcbc_done(&self->state, (unsigned char*)mac, &mac_len);
	68	maclen = sizeof(mac);
	69	rv = xcbc_done(&self->state, (unsigned char*)mac, &maclen);
70	70	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, mac_len);
	71	RETVAL = newSVpvn(mac, maclen);
72	72	}
73	73	OUTPUT:
74	74	RETVAL

78	78	CODE:
79	79	{
80	80	unsigned char mac[MAXBLOCKSIZE];
81		unsigned long mac_len;
	81	unsigned long maclen;
82	82	int rv;
83	83	unsigned long outlen;
84		char mac_base64[MAXBLOCKSIZE*2 + 1];
	84	char out[MAXBLOCKSIZE*2];
85	85
86		mac_len = sizeof(mac);
87		rv = xcbc_done(&self->state, mac, &mac_len);
	86	maclen = sizeof(mac);
	87	rv = xcbc_done(&self->state, mac, &maclen);
88	88	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
89		outlen = sizeof(mac_base64);
90		rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	89	outlen = sizeof(out);
	90	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91	91	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(mac_base64, outlen);
	92	RETVAL = newSVpvn(out, outlen);
93	93	}
94	94	OUTPUT:
95	95	RETVAL

99	99	CODE:
100	100	{
101	101	unsigned char mac[MAXBLOCKSIZE];
102		unsigned long mac_len;
	102	unsigned long maclen;
103	103	int rv;
104	104	unsigned long outlen;
105		char mac_base64[MAXBLOCKSIZE*2 + 1];
	105	char out[MAXBLOCKSIZE*2 + 1];
106	106
107		mac_len = sizeof(mac);
108		rv = xcbc_done(&self->state, mac, &mac_len);
	107	maclen = sizeof(mac);
	108	rv = xcbc_done(&self->state, mac, &maclen);
109	109	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
110		outlen = sizeof(mac_base64);
111		rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
	110	outlen = sizeof(out);
	111	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112	112	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(mac_base64, outlen);
	113	RETVAL = newSVpvn(out, outlen);
114	114	}
115	115	OUTPUT:
116	116	RETVAL

120	120	CODE:
121	121	{
122	122	unsigned char mac[MAXBLOCKSIZE];
123		unsigned long mac_len, i;
	123	unsigned long maclen, outlen;
124	124	int rv;
125		char mac_hex[MAXBLOCKSIZE*2 + 1];
	125	char out[MAXBLOCKSIZE*2];
126	126
127		mac_len = sizeof(mac);
128		rv = xcbc_done(&self->state, mac, &mac_len);
	127	maclen = sizeof(mac);
	128	rv = xcbc_done(&self->state, mac, &maclen);
129	129	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
130		mac_hex[0] = '\0';
131		for(i=0; i<mac_len; i++)
132		sprintf(&mac_hex[2*i], "%02x", mac[i]);
133		RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
	130	outlen = sizeof(out);
	131	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	132	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	133	RETVAL = newSVpvn(out, outlen);
134	134	}
135	135	OUTPUT:
136	136	RETVAL

+2

-2

inc/CryptX_Mode_CBC.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mode::CBC
5		_new(char * cipher_name, int padding=1, int rounds=0)
	5	new(char * class, char * cipher_name, int padding=1, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct cbc_struct);

11	11	RETVAL->padlen = 0;
12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14		RETVAL->cipher_id = find_cipher(cipher_name);
	14	RETVAL->cipher_id = _find_cipher(cipher_name);
15	15	if (RETVAL->cipher_id == -1) {
16	16	Safefree(RETVAL);
17	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

inc/CryptX_Mode_CFB.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mode::CFB
5		_new(char * cipher_name, int rounds=0)
	5	new(char * class, char * cipher_name, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct cfb_struct);
9	9	if (!RETVAL) croak("FATAL: Newz failed");
10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12		RETVAL->cipher_id = find_cipher(cipher_name);
	12	RETVAL->cipher_id = _find_cipher(cipher_name);
13	13	if (RETVAL->cipher_id == -1) {
14	14	Safefree(RETVAL);
15	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

inc/CryptX_Mode_CTR.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mode::CTR
5		_new(char * cipher_name, int ctr_mode=0, int ctr_width=0, int rounds=0)
	5	new(char * class, char * cipher_name, int ctr_mode=0, int ctr_width=0, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct ctr_struct);
9	9	if (!RETVAL) croak("FATAL: Newz failed");
10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12		RETVAL->cipher_id = find_cipher(cipher_name);
	12	RETVAL->cipher_id = _find_cipher(cipher_name);
13	13	if (RETVAL->cipher_id == -1) {
14	14	Safefree(RETVAL);
15	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

inc/CryptX_Mode_ECB.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mode::ECB
5		_new(char * cipher_name, int padding=1, int rounds=0)
	5	new(char * class, char * cipher_name, int padding=1, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct ecb_struct);

11	11	RETVAL->padlen = 0;
12	12	RETVAL->direction = 0;
13	13	RETVAL->cipher_rounds = rounds;
14		RETVAL->cipher_id = find_cipher(cipher_name);
	14	RETVAL->cipher_id = _find_cipher(cipher_name);
15	15	if (RETVAL->cipher_id == -1) {
16	16	Safefree(RETVAL);
17	17	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+2

-2

inc/CryptX_Mode_OFB.xs.inc less more

2	2	### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
3	3
4	4	Crypt::Mode::OFB
5		_new(char * cipher_name, int rounds=0)
	5	new(char * class, char * cipher_name, int rounds=0)
6	6	CODE:
7	7	{
8	8	Newz(0, RETVAL, 1, struct ofb_struct);
9	9	if (!RETVAL) croak("FATAL: Newz failed");
10	10	RETVAL->direction = 0;
11	11	RETVAL->cipher_rounds = rounds;
12		RETVAL->cipher_id = find_cipher(cipher_name);
	12	RETVAL->cipher_id = _find_cipher(cipher_name);
13	13	if (RETVAL->cipher_id == -1) {
14	14	Safefree(RETVAL);
15	15	croak("FATAL: find_cipfer failed for '%s'", cipher_name);

+1

-1

inc/CryptX_PK_DSA.xs.inc less more

271	271
272	272	data_ptr = (unsigned char *)SvPVbyte(data, data_len);
273	273
274		hash_id = find_hash(hash_name);
	274	hash_id = _find_hash(hash_name);
275	275	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
276	276	rv = dsa_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
277	277	&self->pstate, self->pindex,

+1

-1

inc/CryptX_PK_ECC.xs.inc less more

288	288
289	289	data_ptr = (unsigned char *)SvPVbyte(data, data_len);
290	290
291		hash_id = find_hash(hash_name);
	291	hash_id = _find_hash(hash_name);
292	292	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
293	293	rv = ecc_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
294	294	&self->pstate, self->pindex,

+6

-6

inc/CryptX_PK_RSA.xs.inc less more

307	307
308	308	RETVAL = newSVpvn(NULL, 0); /* undef */
309	309	if (strnEQ(padding, "oaep", 4)) {
310		hash_id = find_hash(oaep_hash);
	310	hash_id = _find_hash(oaep_hash);
311	311	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
312	312	lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
313	313	rv = rsa_encrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,

352	352
353	353	RETVAL = newSVpvn(NULL, 0); /* undef */
354	354	if (strnEQ(padding, "oaep", 4)) {
355		hash_id = find_hash(oaep_hash);
	355	hash_id = _find_hash(oaep_hash);
356	356	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
357	357	lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
358	358	rv = rsa_decrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,

395	395
396	396	RETVAL = newSVpvn(NULL, 0); /* undef */
397	397	if (strnEQ(padding, "pss", 3)) {
398		hash_id = find_hash(hash_name);
	398	hash_id = _find_hash(hash_name);
399	399	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
400	400	rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_PSS,
401	401	&self->pstate, self->pindex,

404	404	RETVAL = newSVpvn((char*)buffer, buffer_len);
405	405	}
406	406	else if (strnEQ(padding, "v1.5", 4)) {
407		hash_id = find_hash(hash_name);
	407	hash_id = _find_hash(hash_name);
408	408	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
409	409	rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_V1_5,
410	410	&self->pstate, self->pindex,

443	443	RETVAL = 1;
444	444	stat = 0;
445	445	if (strnEQ(padding, "pss", 3)) {
446		hash_id = find_hash(hash_name);
	446	hash_id = _find_hash(hash_name);
447	447	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
448	448	rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_PSS,
449	449	hash_id, saltlen, &stat, &self->key);
450	450	if (rv != CRYPT_OK \|\| stat != 1) RETVAL = 0;
451	451	}
452	452	else if (strnEQ(padding, "v1.5", 4)) {
453		hash_id = find_hash(hash_name);
	453	hash_id = _find_hash(hash_name);
454	454	if (hash_id == -1) croak("FATAL: find_hash failed for '%s'", hash_name);
455	455	rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_V1_5,
456	456	hash_id, 0, &stat, &self->key);

+0

-6

lib/Crypt/AuthEnc/CCM.pm less more

12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14	14	use Crypt::Cipher;
15
16		sub new {
17		my $class = shift;
18		local $SIG{__DIE__} = \&CryptX::_croak;
19		return _new(Crypt::Cipher::_trans_cipher_name(shift), @_);
20		}
21	15
22	16	sub ccm_encrypt_authenticate {
23	17	my $cipher_name = shift;

+0

-6

lib/Crypt/AuthEnc/ChaCha20Poly1305.pm less more

11	11	use Carp;
12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14
15		sub new {
16		my $class = shift;
17		local $SIG{__DIE__} = \&CryptX::_croak;
18		return _new(@_);
19		}
20	14
21	15	sub chacha20poly1305_encrypt_authenticate {
22	16	my $key = shift;

+1

-7

lib/Crypt/AuthEnc/EAX.pm less more

14	14	use Crypt::Cipher;
15	15
16	16	### the following methods/functions are implemented in XS:
17		# - _new
	17	# - new
18	18	# - DESTROY
19	19	# - clone
20	20	# - encrypt_add

22	22	# - decrypt_add
23	23	# - decrypt_done
24	24	# - adata_add
25
26		sub new {
27		my $class = shift;
28		local $SIG{__DIE__} = \&CryptX::_croak;
29		return _new(Crypt::Cipher::_trans_cipher_name(shift), @_);
30		}
31	25
32	26	sub eax_encrypt_authenticate {
33	27	my $cipher_name = shift;

+0

-9

lib/Crypt/AuthEnc/GCM.pm less more

12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14	14	use Crypt::Cipher;
15
16		sub new {
17		my ($class, $cipher, $key, $iv) = @_;
18		local $SIG{__DIE__} = \&CryptX::_croak;
19		my $self = _new(Crypt::Cipher::_trans_cipher_name($cipher), $key);
20		# for backwards compatibility the $iv is optional
21		$self->iv_add($iv) if defined $iv;
22		return $self;
23		}
24	15
25	16	sub gcm_encrypt_authenticate {
26	17	my $cipher_name = shift;

+0

-6

lib/Crypt/AuthEnc/OCB.pm less more

12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14	14	use Crypt::Cipher;
15
16		sub new {
17		my $class = shift;
18		local $SIG{__DIE__} = \&CryptX::_croak;
19		return _new(Crypt::Cipher::_trans_cipher_name(shift), @_);
20		}
21	15
22	16	sub ocb_encrypt_authenticate {
23	17	my $cipher_name = shift;

+7

-75

lib/Crypt/Cipher.pm less more

8	8	use CryptX;
9	9
10	10	### the following methods/functions are implemented in XS:
11		# - _new
	11	# - new
12	12	# - DESTROY
13		# - _keysize
14		# - _max_keysize
15		# - _min_keysize
16		# - _blocksize
17		# - _default_rounds
	13	# - blocksize
	14	# - decrypt
	15	# - default_rounds
18	16	# - encrypt
19		# - decrypt
20		#functions, not methods:
21		# - _block_length_by_name
22		# - _min_key_length_by_name
23		# - _max_key_length_by_name
24		# - _default_rounds_by_name
	17	# - max_keysize
	18	# - min_keysize
25	19
26		sub _trans_cipher_name {
27		my $name = shift \|\| "";
28		my %trans = (
29		DES_EDE => '3des',
30		SAFERP => 'safer+',
31		SAFER_K128 => 'safer-k128',
32		SAFER_K64 => 'safer-k64',
33		SAFER_SK128 => 'safer-sk128',
34		SAFER_SK64 => 'safer-sk64',
35		);
36		$name =~ s/^Crypt::Cipher:://;
37		return $trans{uc($name)} if defined $trans{uc($name)};
38		return lc($name);
39		}
40
41		### METHODS
42
43		sub new {
44		my $pkg = shift;
45		my $cipher_name = $pkg eq __PACKAGE__ ? _trans_cipher_name(shift) : _trans_cipher_name($pkg);
46		local $SIG{__DIE__} = \&CryptX::_croak;
47		return _new($cipher_name, @_);
48		}
49
50		sub blocksize {
51		my $self = shift;
52		return $self->_blocksize if ref($self);
53		$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
54		local $SIG{__DIE__} = \&CryptX::_croak;
55		return _block_length_by_name(_trans_cipher_name($self));
56		}
57
58		sub max_keysize
59		{
60		my $self = shift;
61		return unless defined $self;
62		return $self->_max_keysize if ref($self);
63		$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
64		local $SIG{__DIE__} = \&CryptX::_croak;
65		return _max_key_length_by_name(_trans_cipher_name($self));
66		}
67
68		sub min_keysize {
69		my $self = shift;
70		return unless defined $self;
71		return $self->_min_keysize if ref($self);
72		$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
73		local $SIG{__DIE__} = \&CryptX::_croak;
74		return _min_key_length_by_name(_trans_cipher_name($self));
75		}
76
77		sub keysize {
78		goto &max_keysize;
79		}
80
81		sub default_rounds {
82		my $self = shift;
83		return unless defined $self;
84		return $self->_default_rounds if ref($self);
85		$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
86		local $SIG{__DIE__} = \&CryptX::_croak;
87		return _default_rounds_by_name(_trans_cipher_name($self));
88		}
	20	sub keysize { goto \&max_keysize; } # for Crypt::CBC compatibility
89	21
90	22	sub CLONE_SKIP { 1 } # prevent cloning
91	23

+0

-2

lib/Crypt/Digest/SHAKE.pm less more

6	6	use Carp;
7	7	$Carp::Internal{(__PACKAGE__)}++;
8	8	use CryptX;
9
10		sub new { my $class = shift; _new(@_) }
11	9
12	10	sub addfile {
13	11	my ($self, $file) = @_;

+6

-67

lib/Crypt/Digest.pm less more

13	13	use CryptX;
14	14
15	15	### the following methods/functions are implemented in XS:
16		# - _new
17		# - _hashsize
18		# - _hashsize_by_name (function, not method)
	16	# - new
	17	# - hashsize
19	18	# - clone
20	19	# - reset
21	20	# - digest
22	21	# - hexdigest
23	22	# - b64digest
24	23	# - add
	24	# - digest_data
	25	# - digest_data_hex
	26	# - digest_data_b64
	27	# - digest_data_b64u
25	28	# - DESTROY
26	29
27		sub _trans_digest_name {
28		my $name = shift \|\| "";
29		my %trans = (
30		CHAES => 'chc_hash',
31		RIPEMD128 => 'rmd128',
32		RIPEMD160 => 'rmd160',
33		RIPEMD256 => 'rmd256',
34		RIPEMD320 => 'rmd320',
35		TIGER192 => 'tiger',
36		SHA512_224 => 'sha512-224',
37		SHA512_256 => 'sha512-256',
38		SHA3_224 => 'sha3-224',
39		SHA3_256 => 'sha3-256',
40		SHA3_384 => 'sha3-384',
41		SHA3_512 => 'sha3-512',
42		BLAKE2B_160 => 'blake2b-160',
43		BLAKE2B_256 => 'blake2b-256',
44		BLAKE2B_384 => 'blake2b-384',
45		BLAKE2B_512 => 'blake2b-512',
46		BLAKE2S_128 => 'blake2s-128',
47		BLAKE2S_160 => 'blake2s-160',
48		BLAKE2S_224 => 'blake2s-224',
49		BLAKE2S_256 => 'blake2s-256',
50		);
51		$name =~ s/^Crypt::Digest:://i;
52		return $trans{uc($name)} if defined $trans{uc($name)};
53		return lc($name);
54		}
55
56	30	### METHODS
57
58		sub new {
59		my $pkg = shift;
60		unshift @_, ($pkg eq 'Crypt::Digest' ? _trans_digest_name(shift) : _trans_digest_name($pkg));
61		local $SIG{__DIE__} = \&CryptX::_croak;
62		return _new(@_);
63		}
64
65		sub hashsize {
66		return unless defined $_[0];
67
68		if (ref $_[0]) {
69		local $SIG{__DIE__} = \&CryptX::_croak;
70		return _hashsize(@_);
71		}
72		else {
73		my $pkg = shift;
74		unshift @_, ($pkg eq 'Crypt::Digest' ? _trans_digest_name(shift) : _trans_digest_name($pkg));
75		local $SIG{__DIE__} = \&CryptX::_croak;
76		return _hashsize_by_name(@_);
77		}
78		}
79	31
80	32	sub addfile {
81	33	my ($self, $file) = @_;

103	55	sub CLONE_SKIP { 1 } # prevent cloning
104	56
105	57	### FUNCTIONS
106
107		sub digest_data { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->add(@_)->digest }
108		sub digest_data_hex { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->add(@_)->hexdigest }
109		sub digest_data_b64 { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->add(@_)->b64digest }
110		sub digest_data_b64u { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->add(@_)->b64udigest }
111	58
112	59	sub digest_file { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->addfile(@_)->digest }
113	60	sub digest_file_hex { local $SIG{__DIE__} = \&CryptX::_croak; Crypt::Digest->new(shift)->addfile(@_)->hexdigest }

191	138	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a binary string.
192	139
193	140	$digest_raw = digest_data('SHA1', 'data string');
194		#or
195		$digest_raw = digest_data('SHA1', 'any data', 'more data', 'even more data');
196	141
197	142	=head2 digest_data_hex
198	143
199	144	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a hexadecimal string.
200	145
201	146	$digest_hex = digest_data_hex('SHA1', 'data string');
202		#or
203		$digest_hex = digest_data_hex('SHA1', 'any data', 'more data', 'even more data');
204	147
205	148	=head2 digest_data_b64
206	149
207	150	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
208	151
209	152	$digest_b64 = digest_data_b64('SHA1', 'data string');
210		#or
211		$digest_b64 = digest_data_b64('SHA1', 'any data', 'more data', 'even more data');
212	153
213	154	=head2 digest_data_b64u
214	155
215	156	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
216	157
217	158	$digest_b64url = digest_data_b64u('SHA1', 'data string');
218		#or
219		$digest_b64url = digest_data_b64u('SHA1', 'any data', 'more data', 'even more data');
220	159
221	160	=head2 digest_file
222	161

+5

-5

lib/Crypt/KeyDerivation.pm less more

16	16	sub pbkdf1 {
17	17	my ($password, $salt, $iteration_count, $hash_name, $len) = @_;
18	18	$iteration_count \|\|= 5000;
19		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA256');
	19	$hash_name \|\|= 'SHA256';
20	20	$len \|\|= 32;
21	21	local $SIG{__DIE__} = \&CryptX::_croak;
22	22	return _pkcs_5_alg1($password, $salt, $iteration_count, $hash_name, $len);

25	25	sub pbkdf2 {
26	26	my ($password, $salt, $iteration_count, $hash_name, $len) = @_;
27	27	$iteration_count \|\|= 5000;
28		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA256');
	28	$hash_name \|\|= 'SHA256';
29	29	$len \|\|= 32;
30	30	local $SIG{__DIE__} = \&CryptX::_croak;
31	31	return _pkcs_5_alg2($password, $salt, $iteration_count, $hash_name, $len);

35	35	# RFC: HKDF-Extract(salt, IKM, [Hash]) -> PRK
36	36	#my ($hash_name, $salt, $keying_material) = @_;
37	37	my ($keying_material, $salt, $hash_name) = @_;
38		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA256');
	38	$hash_name \|\|= 'SHA256';
39	39	$salt = pack("H*", "00" x Crypt::Digest->hashsize($hash_name)) unless defined $salt; # according to rfc5869 defaults to HashLen zero octets
40	40	local $SIG{__DIE__} = \&CryptX::_croak;
41	41	return _hkdf_extract($hash_name, $salt, $keying_material);

47	47	my ($keying_material, $hash_name, $len, $info) = @_;
48	48	$len \|\|= 32;
49	49	$info \|\|= '';
50		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA256');
	50	$hash_name \|\|= 'SHA256';
51	51	local $SIG{__DIE__} = \&CryptX::_croak;
52	52	return _hkdf_expand($hash_name, $info, $keying_material, $len);
53	53	}

57	57	my ($keying_material, $salt, $hash_name, $len, $info) = @_;
58	58	$len \|\|= 32;
59	59	$info \|\|= '';
60		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA256');
	60	$hash_name \|\|= 'SHA256';
61	61	$salt = pack("H*", "00" x Crypt::Digest->hashsize($hash_name)) unless defined $salt; # according to rfc5869 defaults to HashLen zero octets
62	62	local $SIG{__DIE__} = \&CryptX::_croak;
63	63	return _hkdf($hash_name, $salt, $info, $keying_material, $len);

+0

-1

lib/Crypt/Mac/BLAKE2b.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		sub new { my $class = shift; _new(@_) }
15	14	sub blake2b { Crypt::Mac::BLAKE2b->new(shift, shift)->add(@_)->mac }
16	15	sub blake2b_hex { Crypt::Mac::BLAKE2b->new(shift, shift)->add(@_)->hexmac }
17	16	sub blake2b_b64 { Crypt::Mac::BLAKE2b->new(shift, shift)->add(@_)->b64mac }

+0

-1

lib/Crypt/Mac/BLAKE2s.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		sub new { my $class = shift; _new(@_) }
15	14	sub blake2s { Crypt::Mac::BLAKE2s->new(shift, shift)->add(@_)->mac }
16	15	sub blake2s_hex { Crypt::Mac::BLAKE2s->new(shift, shift)->add(@_)->hexmac }
17	16	sub blake2s_b64 { Crypt::Mac::BLAKE2s->new(shift, shift)->add(@_)->b64mac }

+0

-3

lib/Crypt/Mac/F9.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		use Crypt::Cipher;
15
16		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
17	14	sub f9 { Crypt::Mac::F9->new(shift, shift)->add(@_)->mac }
18	15	sub f9_hex { Crypt::Mac::F9->new(shift, shift)->add(@_)->hexmac }
19	16	sub f9_b64 { Crypt::Mac::F9->new(shift, shift)->add(@_)->b64mac }

+0

-3

lib/Crypt/Mac/HMAC.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		use Crypt::Digest;
15
16		sub new { my $class = shift; _new(Crypt::Digest::_trans_digest_name(shift), @_) }
17	14	sub hmac { Crypt::Mac::HMAC->new(shift, shift)->add(@_)->mac }
18	15	sub hmac_hex { Crypt::Mac::HMAC->new(shift, shift)->add(@_)->hexmac }
19	16	sub hmac_b64 { Crypt::Mac::HMAC->new(shift, shift)->add(@_)->b64mac }

+0

-3

lib/Crypt/Mac/OMAC.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		use Crypt::Cipher;
15
16		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
17	14	sub omac { Crypt::Mac::OMAC->new(shift, shift)->add(@_)->mac }
18	15	sub omac_hex { Crypt::Mac::OMAC->new(shift, shift)->add(@_)->hexmac }
19	16	sub omac_b64 { Crypt::Mac::OMAC->new(shift, shift)->add(@_)->b64mac }

+0

-3

lib/Crypt/Mac/PMAC.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		use Crypt::Cipher;
15
16		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
17	14	sub pmac { Crypt::Mac::PMAC->new(shift, shift)->add(@_)->mac }
18	15	sub pmac_hex { Crypt::Mac::PMAC->new(shift, shift)->add(@_)->hexmac }
19	16	sub pmac_b64 { Crypt::Mac::PMAC->new(shift, shift)->add(@_)->b64mac }

+0

-1

lib/Crypt/Mac/Pelican.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		sub new { my $class = shift; _new(@_) }
15	14	sub pelican { Crypt::Mac::Pelican->new(shift)->add(@_)->mac }
16	15	sub pelican_hex { Crypt::Mac::Pelican->new(shift)->add(@_)->hexmac }
17	16	sub pelican_b64 { Crypt::Mac::Pelican->new(shift)->add(@_)->b64mac }

+0

-1

lib/Crypt/Mac/Poly1305.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		sub new { my $class = shift; _new(@_) }
15	14	sub poly1305 { Crypt::Mac::Poly1305->new(shift)->add(@_)->mac }
16	15	sub poly1305_hex { Crypt::Mac::Poly1305->new(shift)->add(@_)->hexmac }
17	16	sub poly1305_b64 { Crypt::Mac::Poly1305->new(shift)->add(@_)->b64mac }

+0

-3

lib/Crypt/Mac/XCBC.pm less more

11	11	our @EXPORT = qw();
12	12
13	13	use CryptX;
14		use Crypt::Cipher;
15
16		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
17	14	sub xcbc { Crypt::Mac::XCBC->new(shift, shift)->add(@_)->mac }
18	15	sub xcbc_hex { Crypt::Mac::XCBC->new(shift, shift)->add(@_)->hexmac }
19	16	sub xcbc_b64 { Crypt::Mac::XCBC->new(shift, shift)->add(@_)->b64mac }

+0

-2

lib/Crypt/Mode/CBC.pm less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+0

-2

lib/Crypt/Mode/CFB.pm less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+0

-2

lib/Crypt/Mode/CTR.pm less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+0

-2

lib/Crypt/Mode/ECB.pm less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+0

-2

lib/Crypt/Mode/OFB.pm less more

7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';
10
11		sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
12	10
13	11	1;
14	12

+1

-1

lib/Crypt/PK/DSA.pm less more

97	97
98	98	sub encrypt {
99	99	my ($self, $data, $hash_name) = @_;
100		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	100	$hash_name \|\|= 'SHA1';
101	101	return $self->_encrypt($data, $hash_name);
102	102	}
103	103

+1

-1

lib/Crypt/PK/ECC.pm less more

569	569
570	570	sub encrypt {
571	571	my ($self, $data, $hash_name) = @_;
572		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	572	$hash_name \|\|= 'SHA1';
573	573	return $self->_encrypt($data, $hash_name);
574	574	}
575	575

+6

-6

lib/Crypt/PK/RSA.pm less more

168	168	my ($self, $data, $padding, $hash_name, $lparam) = @_;
169	169	$lparam \|\|= '';
170	170	$padding \|\|= 'oaep';
171		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	171	$hash_name \|\|= 'SHA1';
172	172
173	173	return $self->_encrypt($data, $padding, $hash_name, $lparam);
174	174	}

177	177	my ($self, $data, $padding, $hash_name, $lparam) = @_;
178	178	$lparam \|\|= '';
179	179	$padding \|\|= 'oaep';
180		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	180	$hash_name \|\|= 'SHA1';
181	181
182	182	return $self->_decrypt($data, $padding, $hash_name, $lparam);
183	183	}

186	186	my ($self, $data, $hash_name, $padding, $saltlen) = @_;
187	187	$saltlen \|\|= 12;
188	188	$padding \|\|= 'pss';
189		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	189	$hash_name \|\|= 'SHA1';
190	190
191	191	return $self->_sign($data, $padding, $hash_name, $saltlen);
192	192	}

195	195	my ($self, $data, $hash_name, $padding, $saltlen) = @_;
196	196	$saltlen \|\|= 12;
197	197	$padding \|\|= 'pss';
198		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	198	$hash_name \|\|= 'SHA1';
199	199
200	200	return $self->_sign(digest_data($hash_name, $data), $padding, $hash_name, $saltlen);
201	201	}

204	204	my ($self, $sig, $data, $hash_name, $padding, $saltlen) = @_;
205	205	$saltlen \|\|= 12;
206	206	$padding \|\|= 'pss';
207		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	207	$hash_name \|\|= 'SHA1';
208	208
209	209	return $self->_verify($sig, $data, $padding, $hash_name, $saltlen);
210	210	}

213	213	my ($self, $sig, $data, $hash_name, $padding, $saltlen) = @_;
214	214	$saltlen \|\|= 12;
215	215	$padding \|\|= 'pss';
216		$hash_name = Crypt::Digest::_trans_digest_name($hash_name\|\|'SHA1');
	216	$hash_name \|\|= 'SHA1';
217	217
218	218	return $self->_verify($sig, digest_data($hash_name, $data), $padding, $hash_name, $saltlen);
219	219	}