Commit 71011c20aa43c8ee74649115d838243c3f064b78 - libcryptx-perl

+6

-7

_generators/Cipher.pm.tt less more

5	5	use warnings;
6	6	our $VERSION = '[%(pmver \|\| "0.000")%]';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('[%orig_name%]') }
	11	sub keysize { Crypt::Cipher::keysize('[%orig_name%]') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('[%orig_name%]') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('[%orig_name%]') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('[%orig_name%]') }
16	15
17	16	1;
18	17

+11

-13

_generators/Digest.pm.tt less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub [%lc_name%] { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub [%lc_name%]_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub [%lc_name%]_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub [%lc_name%]_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub [%lc_name%]_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub [%lc_name%]_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub [%lc_name%]_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub [%lc_name%]_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('[%orig_name%]') }
	18	sub [%lc_name%] { Crypt::Digest::digest_data('[%orig_name%]', @_) }
	19	sub [%lc_name%]_hex { Crypt::Digest::digest_data_hex('[%orig_name%]', @_) }
	20	sub [%lc_name%]_b64 { Crypt::Digest::digest_data_b64('[%orig_name%]', @_) }
	21	sub [%lc_name%]_b64u { Crypt::Digest::digest_data_b64u('[%orig_name%]', @_) }
	22	sub [%lc_name%]_file { Crypt::Digest::digest_file('[%orig_name%]', @_) }
	23	sub [%lc_name%]_file_hex { Crypt::Digest::digest_file_hex('[%orig_name%]', @_) }
	24	sub [%lc_name%]_file_b64 { Crypt::Digest::digest_file_b64('[%orig_name%]', @_) }
	25	sub [%lc_name%]_file_b64u { Crypt::Digest::digest_file_b64u('[%orig_name%]', @_) }
28	26
29	27	1;
30	28

+12

-1

_generators/Digest.t.tt less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 8[%t_strings_count%] + 9[%t_files_count%] + 6;
	5	use Test::More tests => 8[%t_strings_count%] + 9[%t_files_count%] + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::[%orig_name%] qw( [%lc_name%] [%lc_name%]_hex [%lc_name%]_b64 [%lc_name%]_b64u [%lc_name%]_file [%lc_name%]_file_hex [%lc_name%]_file_b64 [%lc_name%]_file_b64u );

13	13	is( Crypt::Digest::[%orig_name%]->hashsize, [%hashsize%], 'hashsize/4');
14	14	is( Crypt::Digest->new('[%orig_name%]')->hashsize, [%hashsize%], 'hashsize/5');
15	15	is( Crypt::Digest::[%orig_name%]->new->hashsize, [%hashsize%], 'hashsize/6');
	16
	17	is( [%lc_name%]("A","A","A"), pack("H*","[%tripple_A.hex%]"), '[%lc_name%] (raw/tripple_A)');
	18	is( [%lc_name%]_hex("A","A","A"), "[%tripple_A.hex%]", '[%lc_name%] (hex/tripple_A)');
	19	is( [%lc_name%]_b64("A","A","A"), "[%tripple_A.base64%]", '[%lc_name%] (base64/tripple_A)');
	20	is( [%lc_name%]_b64u("A","A","A"), "[%tripple_A.base64url%]", '[%lc_name%] (base64url/tripple_A)');
	21	is( digest_data('[%orig_name%]', "A","A","A"), pack("H*","[%tripple_A.hex%]"), '[%lc_name%] (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('[%orig_name%]', "A","A","A"), "[%tripple_A.hex%]", '[%lc_name%] (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('[%orig_name%]', "A","A","A"), "[%tripple_A.base64%]", '[%lc_name%] (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('[%orig_name%]', "A","A","A"), "[%tripple_A.base64url%]", '[%lc_name%] (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::[%orig_name%]->new->add("A","A","A")->hexdigest, "[%tripple_A.hex%]", '[%lc_name%] (OO/tripple_A)');
	26	is( Crypt::Digest::[%orig_name%]->new->add("A")->add("A")->add("A")->hexdigest, "[%tripple_A.hex%]", '[%lc_name%] (OO3/tripple_A)');
16	27
17	28	[% FOREACH v IN t_strings %]
18	29	is( [%lc_name%]([%v.data%]), pack("H*","[%v.hex%]"), '[%lc_name%] (raw/[%loop.count%])');

+34

-4

_generators/Mac.pm.tt less more

9	9	our %EXPORT_TAGS = ( all => [qw( [%lc_name%] [%lc_name%]_hex [%lc_name%]_b64 [%lc_name%]_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

94	90
95	91	[%-IF lc_name == 'hmac' %]
96	92	$[%lc_name%]_raw = [%lc_name%]($hash_name, $key, 'data buffer');
	93	#or
	94	$[%lc_name%]_raw = [%lc_name%]($hash_name, $key, 'any data', 'more data', 'even more data');
97	95
98	96	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
99	97	# $key ......... the key (octets/bytes)
100	98	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
101	99	$[%lc_name%]_raw = [%lc_name%]($size, $key, 'data buffer');
	100	#or
	101	$[%lc_name%]_raw = [%lc_name%]($size, $key, 'any data', 'more data', 'even more data');
102	102	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
103	103	$[%lc_name%]_raw = [%lc_name%]($key, 'data buffer');
	104	#or
	105	$[%lc_name%]_raw = [%lc_name%]($key, 'any data', 'more data', 'even more data');
104	106	[%-ELSE%]
105	107	$[%lc_name%]_raw = [%lc_name%]($cipher_name, $key, 'data buffer');
	108	#or
	109	$[%lc_name%]_raw = [%lc_name%]($cipher_name, $key, 'any data', 'more data', 'even more data');
106	110	[%-END%]
107	111
108	112	=head2 [%lc_name%]_hex

111	115
112	116	[%-IF lc_name == 'hmac' %]
113	117	$[%lc_name%]_hex = [%lc_name%]_hex($hash_name, $key, 'data buffer');
	118	#or
	119	$[%lc_name%]_hex = [%lc_name%]_hex($hash_name, $key, 'any data', 'more data', 'even more data');
114	120
115	121	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
116	122	# $key ......... the key (octets/bytes, not hex!)
117	123	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
118	124	$[%lc_name%]_hex = [%lc_name%]_hex($size, $key, 'data buffer');
	125	#or
	126	$[%lc_name%]_hex = [%lc_name%]_hex($size, $key, 'any data', 'more data', 'even more data');
119	127	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
120	128	$[%lc_name%]_hex = [%lc_name%]_hex($key, 'data buffer');
	129	#or
	130	$[%lc_name%]_hex = [%lc_name%]_hex($key, 'any data', 'more data', 'even more data');
121	131	[%-ELSE%]
122	132	$[%lc_name%]_hex = [%lc_name%]_hex($cipher_name, $key, 'data buffer');
	133	#or
	134	$[%lc_name%]_hex = [%lc_name%]_hex($cipher_name, $key, 'any data', 'more data', 'even more data');
123	135	[%-END%]
124	136
125	137	=head2 [%lc_name%]_b64

128	140
129	141	[%-IF lc_name == 'hmac' %]
130	142	$[%lc_name%]_b64 = [%lc_name%]_b64($hash_name, $key, 'data buffer');
	143	#or
	144	$[%lc_name%]_b64 = [%lc_name%]_b64($hash_name, $key, 'any data', 'more data', 'even more data');
131	145
132	146	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
133	147	# $key ......... the key (octets/bytes, not Base64!)
134	148	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
135	149	$[%lc_name%]_b64 = [%lc_name%]_b64($size, $key, 'data buffer');
	150	#or
	151	$[%lc_name%]_b64 = [%lc_name%]_b64($size, $key, 'any data', 'more data', 'even more data');
136	152	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
137	153	$[%lc_name%]_b64 = [%lc_name%]_b64($key, 'data buffer');
	154	#or
	155	$[%lc_name%]_b64 = [%lc_name%]_b64($key, 'any data', 'more data', 'even more data');
138	156	[%-ELSE%]
139	157	$[%lc_name%]_b64 = [%lc_name%]_b64($cipher_name, $key, 'data buffer');
	158	#or
	159	$[%lc_name%]_b64 = [%lc_name%]_b64($cipher_name, $key, 'any data', 'more data', 'even more data');
140	160	[%-END%]
141	161
142	162	=head2 [%lc_name%]_b64u

145	165
146	166	[%-IF lc_name == 'hmac' %]
147	167	$[%lc_name%]_b64url = [%lc_name%]_b64u($hash_name, $key, 'data buffer');
	168	#or
	169	$[%lc_name%]_b64url = [%lc_name%]_b64u($hash_name, $key, 'any data', 'more data', 'even more data');
148	170
149	171	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
150	172	# $key ......... the key (octets/bytes, not Base64url!)
151	173	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
152	174	$[%lc_name%]_b64url = [%lc_name%]_b64u($size, $key, 'data buffer');
	175	#or
	176	$[%lc_name%]_b64url = [%lc_name%]_b64u($size, $key, 'any data', 'more data', 'even more data');
153	177	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
154	178	$[%lc_name%]_b64url = [%lc_name%]_b64u($key, 'data buffer');
	179	#or
	180	$[%lc_name%]_b64url = [%lc_name%]_b64u($key, 'any data', 'more data', 'even more data');
155	181	[%-ELSE%]
156	182	$[%lc_name%]_b64url = [%lc_name%]_b64u($cipher_name, $key, 'data buffer');
	183	#or
	184	$[%lc_name%]_b64url = [%lc_name%]_b64u($cipher_name, $key, 'any data', 'more data', 'even more data');
157	185	[%-END%]
158	186
159	187	=head1 METHODS

184	212	=head2 add
185	213
186	214	$d->add('any data');
	215	#or
	216	$d->add('any data', 'more data', 'even more data');
187	217
188	218	=head2 addfile
189	219

+10

-1

_generators/Mac.t.tt less more

3	3	use warnings;
4	4
5	5	[%- IF t_strings_count %]
6		use Test::More tests => [%t_strings_count * 6%];
	6	use Test::More tests => [%t_strings_count * 6%] + 8;
7	7	[%- ELSE %]
8	8	use Test::More tests => 0;
9	9	[%- END %]

18	18	is( [%lc_name%]_b64([%v.args%],[%v.data%]), '[%v.b64mac%]', '[%orig_name%]/func+b64/[%loop.count%]');
19	19	is( [%lc_name%]_b64u([%v.args%],[%v.data%]), '[%v.b64umac%]', '[%orig_name%]/func+b64u/[%loop.count%]');
20	20	[%- END %]
	21
	22	is( unpack('H*', Crypt::Mac::[%orig_name%]->new([%tripple_A.args%])->add("A","A","A")->mac), '[%tripple_A.hexmac%]', '[%orig_name%]/oo+raw/tripple_A');
	23	is( unpack('H*', Crypt::Mac::[%orig_name%]->new([%tripple_A.args%])->add("A")->add("A")->add("A")->mac), '[%tripple_A.hexmac%]', '[%orig_name%]/oo3+raw/tripple_A');
	24	is( Crypt::Mac::[%orig_name%]->new([%tripple_A.args%])->add("A","A","A")->hexmac, '[%tripple_A.hexmac%]', '[%orig_name%]/oo+hex/tripple_A');
	25	is( Crypt::Mac::[%orig_name%]->new([%tripple_A.args%])->add("A")->add("A")->add("A")->hexmac, '[%tripple_A.hexmac%]', '[%orig_name%]/oo3+hex/tripple_A');
	26	is( unpack('H*', [%lc_name%]([%tripple_A.args%],"A","A","A")), '[%tripple_A.hexmac%]', '[%orig_name%]/func+raw/tripple_A');
	27	is( [%lc_name%]_hex ([%tripple_A.args%],"A","A","A"), '[%tripple_A.hexmac%]', '[%orig_name%]/func+hex/tripple_A');
	28	is( [%lc_name%]_b64 ([%tripple_A.args%],"A","A","A"), '[%tripple_A.b64mac%]', '[%orig_name%]/func+b64/tripple_A');
	29	is( [%lc_name%]_b64u([%tripple_A.args%],"A","A","A"), '[%tripple_A.b64umac%]', '[%orig_name%]/func+b64u/tripple_A');

+134

-257

_generators/Mac.xs.inc.tt less more

66	66	RETVAL
67	67
68	68	void
69		_add_single(Crypt::Mac::[%orig_name%] self, SV * data)
70		CODE:
71		{
72		int rv;
	69	add(Crypt::Mac::[%orig_name%] self, ...)
	70	PPCODE:
	71	{
	72	int rv, i;
73	73	STRLEN in_data_len;
74	74	unsigned char *in_data;
75	75
76		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
77		if (in_data_len>0) {
	76	for(i = 1; i < items; i++) {
	77	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	78	if (in_data_len > 0) {
78	79	[%-IF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
79		rv = [%lc_name%]mac_process(&self->state, in_data, (unsigned long)in_data_len);
80		[%-ELSE%]
81		rv = [%lc_name%]_process(&self->state, in_data, (unsigned long)in_data_len);
82		[%-END%]
83		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
84		}
	80	rv = [%lc_name%]mac_process(&self->state, in_data, (unsigned long)in_data_len);
	81	[%-ELSE%]
	82	rv = [%lc_name%]_process(&self->state, in_data, (unsigned long)in_data_len);
	83	[%-END%]
	84	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
	85	}
	86	}
	87	XPUSHs(ST(0)); /* return self */
85	88	}
86	89
87	90	SV *
88	91	mac(Crypt::Mac::[%orig_name%] self)
89		CODE:
90		{
91		char mac[MAXBLOCKSIZE];
92		unsigned long maclen;
93		int rv;
94
95		[%-IF lc_name == 'pelican' %]
96		maclen = 16;
97		rv = [%lc_name%]_done(&self->state, (unsigned char*)mac);
98		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
99		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
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		}
110		OUTPUT:
111		RETVAL
112
113		SV *
114		b64mac(Crypt::Mac::[%orig_name%] self)
115		CODE:
116		{
117		unsigned char mac[MAXBLOCKSIZE];
118		unsigned long maclen;
119		int rv;
120		unsigned long outlen;
121		char out[MAXBLOCKSIZE*2];
122
123		[%-IF lc_name == 'pelican' %]
124		maclen = 16;
125		rv = [%lc_name%]_done(&self->state, mac);
126		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
127		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
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		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
139		RETVAL = newSVpvn(out, outlen);
140		}
141		OUTPUT:
142		RETVAL
143
144		SV *
145		b64umac(Crypt::Mac::[%orig_name%] self)
146		CODE:
147		{
148		unsigned char mac[MAXBLOCKSIZE];
149		unsigned long maclen;
150		int rv;
151		unsigned long outlen;
152		char out[MAXBLOCKSIZE*2 + 1];
153
154		[%-IF lc_name == 'pelican' %]
155		maclen = 16;
156		rv = [%lc_name%]_done(&self->state, mac);
157		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
158		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
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		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
170		RETVAL = newSVpvn(out, outlen);
171		}
172		OUTPUT:
173		RETVAL
174
175		SV *
176		hexmac(Crypt::Mac::[%orig_name%] self)
	92	ALIAS:
	93	hexmac = 1
	94	b64mac = 2
	95	b64umac = 3
177	96	CODE:
178	97	{
179	98	unsigned char mac[MAXBLOCKSIZE];

195	114	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
196	115	[%-END%]
197	116	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);
	117	if (ix == 3) {
	118	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	119	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	120	RETVAL = newSVpvn(out, outlen);
	121	}
	122	if (ix == 2) {
	123	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	124	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	125	RETVAL = newSVpvn(out, outlen);
	126	}
	127	if (ix == 1) {
	128	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	129	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	130	RETVAL = newSVpvn(out, outlen);
	131	}
	132	else {
	133	RETVAL = newSVpvn(mac, maclen);
	134	}
201	135	}
202	136	OUTPUT:
203	137	RETVAL
204	138
205	139	SV *
206	140	[%-IF lc_name == 'hmac' %]
207		[%lc_name%](char * hash_name, SV * key, SV * data)
208		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
209		[%lc_name%](unsigned long size, SV * key, SV * data)
	141	[%lc_name%](char * hash_name, SV * key, ...)
	142	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
	143	[%lc_name%](unsigned long size, SV * key, ...)
210	144	[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
211		[%lc_name%](SV * key, SV * data)
212		[%-ELSE%]
213		[%lc_name%](char * cipher_name, SV * key, SV * data)
214		[%-END%]
	145	[%lc_name%](SV * key, ...)
	146	[%-ELSE%]
	147	[%lc_name%](char * cipher_name, SV * key, ...)
	148	[%-END%]
	149	ALIAS:
	150	[%lc_name%]_hex = 1
	151	[%lc_name%]_b64 = 2
	152	[%lc_name%]_b64u = 3
215	153	CODE:
216	154	{
217	155	STRLEN inlen, klen;
218		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	156	unsigned char *in;
219	157	unsigned char k = (unsigned char )SvPVbyte(key, klen);
220		int rv;
221		unsigned char mac[MAXBLOCKSIZE];
222		unsigned long len = sizeof(mac);
223		[%-IF lc_name == 'hmac' %]
224		int id = _find_hash(hash_name);
225		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
226		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
227		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
228		if (size < len) len = size;
229		rv = [%lc_name%]mac_memory(k, klen, in, inlen, mac, &len);
230		[%-ELSIF lc_name == 'pelican' %]
231		len = 16;
232		rv = [%lc_name%]_memory(k, klen, in, inlen, mac);
233		[%-ELSIF lc_name == 'poly1305' %]
234		rv = [%lc_name%]_memory(k, klen, in, inlen, mac, &len);
235		[%-ELSE%]
236		int id = _find_cipher(cipher_name);
237		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
238		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
239		[%-END%]
240		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_memory failed: %s", error_to_string(rv));
241		RETVAL = newSVpvn((char *) mac, len);
242		}
243		OUTPUT:
244		RETVAL
245
246		SV *
247		[%-IF lc_name == 'hmac' %]
248		[%lc_name%]_hex(char * hash_name, SV * key, SV * data)
249		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
250		[%lc_name%]_hex(unsigned long size, SV * key, SV * data)
251		[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
252		[%lc_name%]_hex(SV * key, SV * data)
253		[%-ELSE%]
254		[%lc_name%]_hex(char * cipher_name, SV * key, SV * data)
255		[%-END%]
256		CODE:
257		{
258		STRLEN inlen, klen;
259		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
260		unsigned char k = (unsigned char )SvPVbyte(key, klen);
261		int rv;
	158	int rv, i;
262	159	unsigned char mac[MAXBLOCKSIZE];
263	160	unsigned long len = sizeof(mac), outlen;
264	161	char out[MAXBLOCKSIZE*2];
	162	[%-IF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
	163	[%lc_name%]mac_state st;
	164	[%-ELSE%]
	165	[%lc_name%]_state st;
	166	[%-END%]
	167
265	168	[%-IF lc_name == 'hmac' %]
266	169	int id = _find_hash(hash_name);
267	170	if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
268		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
	171	rv = [%lc_name%]_init(&st, id, k, klen);
	172	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	173	for (i = 2; i < items; i++) {
	174	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	175	if (inlen > 0) {
	176	rv = [%lc_name%]_process(&st, in, inlen);
	177	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
	178	}
	179	}
	180	rv = [%lc_name%]_done(&st, mac, &len);
	181	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
269	182	[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
270	183	if (size < len) len = size;
271		rv = [%lc_name%]mac_memory(k, klen, in, inlen, mac, &len);
	184	rv = [%lc_name%]mac_init(&st, len, k, klen);
	185	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_init failed: %s", error_to_string(rv));
	186	for (i = 2; i < items; i++) {
	187	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	188	if (inlen > 0) {
	189	rv = [%lc_name%]mac_process(&st, in, inlen);
	190	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_process failed: %s", error_to_string(rv));
	191	}
	192	}
	193	rv = [%lc_name%]mac_done(&st, mac, &len);
	194	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]mac_done failed: %s", error_to_string(rv));
272	195	[%-ELSIF lc_name == 'pelican' %]
273	196	len = 16;
274		rv = [%lc_name%]_memory(k, klen, in, inlen, mac);
	197	rv = [%lc_name%]_init(&st, k, klen);
	198	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	199	for (i = 1; i < items; i++) {
	200	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	201	if (inlen > 0) {
	202	rv = [%lc_name%]_process(&st, in, inlen);
	203	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
	204	}
	205	}
	206	rv = [%lc_name%]_done(&st, mac);
	207	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
275	208	[%-ELSIF lc_name == 'poly1305' %]
276		rv = [%lc_name%]_memory(k, klen, in, inlen, mac, &len);
	209	rv = [%lc_name%]_init(&st, k, klen);
	210	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	211	for (i = 1; i < items; i++) {
	212	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	213	if (inlen > 0) {
	214	rv = [%lc_name%]_process(&st, in, inlen);
	215	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
	216	}
	217	}
	218	rv = [%lc_name%]_done(&st, mac, &len);
	219	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
277	220	[%-ELSE%]
278	221	int id = _find_cipher(cipher_name);
279	222	if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
280		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
281		[%-END%]
282		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_memory failed: %s", error_to_string(rv));
	223	rv = [%lc_name%]_init(&st, id, k, klen);
	224	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_init failed: %s", error_to_string(rv));
	225	for (i = 2; i < items; i++) {
	226	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	227	if (inlen > 0) {
	228	rv = [%lc_name%]_process(&st, in, inlen);
	229	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_process failed: %s", error_to_string(rv));
	230	}
	231	}
	232	rv = [%lc_name%]_done(&st, mac, &len);
	233	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_done failed: %s", error_to_string(rv));
	234	[%-END%]
	235
283	236	outlen = sizeof(out);
284		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
285		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
286		RETVAL = newSVpvn((char *) out, outlen);
287		}
288		OUTPUT:
289		RETVAL
290
291		SV *
292		[%-IF lc_name == 'hmac' %]
293		[%lc_name%]_b64(char * hash_name, SV * key, SV * data)
294		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
295		[%lc_name%]_b64(unsigned long size, SV * key, SV * data)
296		[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
297		[%lc_name%]_b64(SV * key, SV * data)
298		[%-ELSE%]
299		[%lc_name%]_b64(char * cipher_name, SV * key, SV * data)
300		[%-END%]
301		CODE:
302		{
303		STRLEN inlen, klen;
304		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
305		unsigned char k = (unsigned char )SvPVbyte(key, klen);
306		int rv;
307		unsigned char mac[MAXBLOCKSIZE];
308		unsigned long len = sizeof(mac), outlen;
309		char out[MAXBLOCKSIZE*2];
310		[%-IF lc_name == 'hmac' %]
311		int id = _find_hash(hash_name);
312		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
313		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
314		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
315		if (size < len) len = size;
316		rv = [%lc_name%]mac_memory(k, klen, in, inlen, mac, &len);
317		[%-ELSIF lc_name == 'pelican' %]
318		len = 16;
319		rv = [%lc_name%]_memory(k, klen, in, inlen, mac);
320		[%-ELSIF lc_name == 'poly1305' %]
321		rv = [%lc_name%]_memory(k, klen, in, inlen, mac, &len);
322		[%-ELSE%]
323		int id = _find_cipher(cipher_name);
324		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
325		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
326		[%-END%]
327		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_memory failed: %s", error_to_string(rv));
328		outlen = sizeof(out);
329		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
330		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
331		RETVAL = newSVpvn((char *) out, outlen);
332
333		}
334		OUTPUT:
335		RETVAL
336
337		SV *
338		[%-IF lc_name == 'hmac' %]
339		[%lc_name%]_b64u(char * hash_name, SV * key, SV * data)
340		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
341		[%lc_name%]_b64u(unsigned long size, SV * key, SV * data)
342		[%-ELSIF lc_name == 'pelican' \|\| lc_name == 'poly1305' %]
343		[%lc_name%]_b64u(SV * key, SV * data)
344		[%-ELSE%]
345		[%lc_name%]_b64u(char * cipher_name, SV * key, SV * data)
346		[%-END%]
347		CODE:
348		{
349		STRLEN inlen, klen;
350		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
351		unsigned char k = (unsigned char )SvPVbyte(key, klen);
352		int rv;
353		unsigned char mac[MAXBLOCKSIZE];
354		unsigned long len = sizeof(mac), outlen;
355		char out[MAXBLOCKSIZE*2];
356		[%-IF lc_name == 'hmac' %]
357		int id = _find_hash(hash_name);
358		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
359		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
360		[%-ELSIF lc_name == 'blake2s' \|\| lc_name == 'blake2b' %]
361		if (size < len) len = size;
362		rv = [%lc_name%]mac_memory(k, klen, in, inlen, mac, &len);
363		[%-ELSIF lc_name == 'pelican' %]
364		len = 16;
365		rv = [%lc_name%]_memory(k, klen, in, inlen, mac);
366		[%-ELSIF lc_name == 'poly1305' %]
367		rv = [%lc_name%]_memory(k, klen, in, inlen, mac, &len);
368		[%-ELSE%]
369		int id = _find_cipher(cipher_name);
370		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
371		rv = [%lc_name%]_memory(id, k, klen, in, inlen, mac, &len);
372		[%-END%]
373		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_memory failed: %s", error_to_string(rv));
374		outlen = sizeof(out);
375		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
376		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
377		RETVAL = newSVpvn((char *) out, outlen);
378		}
379		OUTPUT:
380		RETVAL
	237	if (ix == 3) {
	238	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	239	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	240	RETVAL = newSVpvn((char *) out, outlen);
	241	}
	242	else if (ix == 2) {
	243	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	244	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	245	RETVAL = newSVpvn((char *) out, outlen);
	246	}
	247	else if (ix == 1) {
	248	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	249	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	250	RETVAL = newSVpvn((char *) out, outlen);
	251	}
	252	else {
	253	RETVAL = newSVpvn((char *) mac, len);
	254	}
	255	}
	256	OUTPUT:
	257	RETVAL

+8

-11

_generators/Mode.xs.inc.tt less more

34	34	CODE:
35	35	Safefree(self);
36	36
37		int
38		_get_dir(Crypt::Mode::[%orig_name%] self)
39		CODE:
40		RETVAL = self->direction;
41		OUTPUT:
42		RETVAL
43
44	37	void
45	38	[%-IF lc_name == 'xts' %]
46	39	_start(_XXX_XXX_XXX_)

49	42	[%-ELSIF lc_name == 'lrw' %]
50	43	_start(_XXX_XXX_XXX_)
51	44	[%-ELSE%]
52		_start(Crypt::Mode::[%orig_name%] self, int dir, SV * key, SV * iv)
	45	_start(Crypt::Mode::[%orig_name%] self, SV * key, SV * iv)
53	46	[%-END%]
54		CODE:
	47	ALIAS:
	48	start_encrypt = 1
	49	start_decrypt = 2
	50	PPCODE:
55	51	{
56	52	STRLEN k_len=0;
57	53	unsigned char *k=NULL;

83	79	croak("FATAL: [%lc_name%]_start failed: %s", error_to_string(rv));
84	80	}
85	81
86		self->direction = dir;
	82	self->direction = ix == 1 ? 1 : -1;
	83	XPUSHs(ST(0)); /* return self */
87	84	}
88	85
89	86	SV *

128	125	RETVAL
129	126
130	127	SV *
131		_finish(Crypt::Mode::[%orig_name%] self)
	128	finish(Crypt::Mode::[%orig_name%] self)
132	129	CODE:
133	130	self->direction = 0;
134	131	RETVAL = newSVpvn("", 0);

+183

-208

_generators/Mode_p.xs.inc.tt less more

25	25	CODE:
26	26	Safefree(self);
27	27
28		int
29		_get_dir(Crypt::Mode::[%orig_name%] self)
30		CODE:
31		RETVAL = self->direction;
32		OUTPUT:
33		RETVAL
34
35	28	void
36	29	[%-IF lc_name == 'cbc' %]
37		_start(Crypt::Mode::[%orig_name%] self, int dir, SV * key, SV * iv)
	30	_start(Crypt::Mode::[%orig_name%] self, SV * key, SV * iv)
38	31	[%-ELSIF lc_name == 'ecb' %]
39		_start(Crypt::Mode::[%orig_name%] self, int dir, SV * key)
	32	_start(Crypt::Mode::[%orig_name%] self, SV * key)
40	33	[%-ELSE%]
41	34	_start(_XXX_XXX_XXX_)
42	35	[%-END%]
43		CODE:
	36	ALIAS:
	37	start_encrypt = 1
	38	start_decrypt = 2
	39	PPCODE:
44	40	{
45	41	int rv;
46	42	STRLEN k_len=0;

67	63	croak("FATAL: [%lc_name%]_start failed: %s", error_to_string(rv));
68	64	}
69	65
70		self->direction = dir;
	66	self->direction = ix == 1 ? 1 : -1;
71	67	self->padlen = 0;
	68	XPUSHs(ST(0)); /* return self */
72	69	}
73	70
74	71	SV *
75		_encrypt(Crypt::Mode::[%orig_name%] self, SV * data)
76		CODE:
77		{
78		int rv, has_tmp_block, blen;
79		unsigned long i;
80
81		STRLEN in_data_len, in_data_start;
82		unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
83
84		if (self->direction != 1) croak("FATAL: encrypt error, call start_encrypt first (%d)", self->direction);
85
86		blen = (&self->state)->blocklen;
87		in_data_start = 0;
88		has_tmp_block = 0;
89		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
90		if (in_data_len == 0) {
91		RETVAL = newSVpvn("", 0);
92		}
93		else {
94		if (self->padlen > 0) {
95		i = (blen - self->padlen);
96		if (in_data_len >= i) { /* enough data to fill pad */
97		Copy(in_data, self->pad+self->padlen, i, unsigned char);
98		in_data_len -= i;
99		in_data_start = i;
100		rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
101		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
102		self->padlen = 0;
103		has_tmp_block = 1;
104		}
105		else { /* not enough data to fill pad */
106		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
107		self->padlen += (int)in_data_len;
108		in_data_len = 0;
109		}
110		} /* padlen > 0 */
111
112		i = (unsigned long)(in_data_len % blen);
113		if (in_data_len>0 && i>0) { /* save tail of data into pad */
114		Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
115		self->padlen = i;
116		in_data_len -= i;
117		}
118
119		if (in_data_len > 0) {
120		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
121		RETVAL = NEWSV(0, i);
122		SvPOK_only(RETVAL);
123		SvCUR_set(RETVAL, i);
124		out_data = (unsigned char *)SvPVX(RETVAL);
125		if (has_tmp_block) {
126		Copy(tmp_block, out_data, blen, unsigned char);
127		out_data += blen;
128		}
129		rv = [%lc_name%]_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
130		if (rv != CRYPT_OK) {
131		SvREFCNT_dec(RETVAL);
132		croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
133		}
134		} /* in_data_len>0 */
135		else if (has_tmp_block) {
136		RETVAL = newSVpvn((char*)tmp_block, blen);
137		}
138		else {
139		RETVAL = newSVpvn("", 0);
140		}
141		}
142		}
143		OUTPUT:
144		RETVAL
145
146		SV *
147		_finish_enc(Crypt::Mode::[%orig_name%] self)
148		CODE:
149		{
150		unsigned char tmp_block[MAXBLOCKSIZE];
151		int rv, blen, i, j;
152
153		blen = (&self->state)->blocklen;
154		if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
155
156		if (self->padding_mode == 1) { /* pkcs5\|7 padding */
157		i = blen - self->padlen;
158		if (i == 0) i = blen;
159		for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
160		rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
161		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
162		}
163		else if (self->padding_mode == 2) { /* oneandzeroes padding */
164		self->pad[self->padlen] = 0x80;
165		for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
166		rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
167		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
168		}
169		else {
170		if (self->padlen>0) croak("FATAL: [%lc_name%]_encrypt, input data length not multiple of %d", blen);
171		blen = 0;
172		}
173
174		self->direction = 0;
175		RETVAL = newSVpvn((char*)tmp_block, blen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		_decrypt(Crypt::Mode::[%orig_name%] self, SV * data)
	72	_crypt(Crypt::Mode::[%orig_name%] self, SV * data)
182	73	CODE:
183	74	{
184	75	int rv, has_tmp_block, blen;

186	77	STRLEN in_data_len, in_data_start;
187	78	unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
188	79
189		if (self->direction != -1) croak("FATAL: decrypt error, call start_decryt first (%d)", self->direction);
190
191		blen = (&self->state)->blocklen;
192		in_data_start = 0;
193		has_tmp_block = 0;
194		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
195		if (in_data_len == 0) {
196		RETVAL = newSVpvn("", 0);
197		}
198		else {
199
200		if (self->padlen == blen) {
201		rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
202		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
203		self->padlen = 0;
204		has_tmp_block = 1;
205		} /* padlen == blen */
206		else if (self->padlen > 0) {
207		i = (blen - self->padlen); /* remaining bytes in padding buffer */
208		if (in_data_len >= i) { /* enough data to fill pad */
209		Copy(in_data, self->pad+self->padlen, i, unsigned char);
210		self->padlen += i;
211		in_data_len -= i;
212		in_data_start = i;
213		if (in_data_len>0 \|\| self->padding_mode == 0) {
214		rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
215		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	80	if (self->direction == 1) {
	81	blen = (&self->state)->blocklen;
	82	in_data_start = 0;
	83	has_tmp_block = 0;
	84	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	85	if (in_data_len == 0) {
	86	RETVAL = newSVpvn("", 0);
	87	}
	88	else {
	89	if (self->padlen > 0) {
	90	i = (blen - self->padlen);
	91	if (in_data_len >= i) { /* enough data to fill pad */
	92	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	93	in_data_len -= i;
	94	in_data_start = i;
	95	rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
	96	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
216	97	self->padlen = 0;
217	98	has_tmp_block = 1;
218	99	}
219		}
220		else { /* not enough data to fill pad */
221		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
222		self->padlen += (int)in_data_len;
223		in_data_len = 0;
224		}
225		} /* padlen > 0 */
226
227		/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
228		if (in_data_len>0) {
	100	else { /* not enough data to fill pad */
	101	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	102	self->padlen += (int)in_data_len;
	103	in_data_len = 0;
	104	}
	105	} /* padlen > 0 */
	106
229	107	i = (unsigned long)(in_data_len % blen);
230		if (i>0) { /* save tail of data into pad */
	108	if (in_data_len>0 && i>0) { /* save tail of data into pad */
231	109	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
232	110	self->padlen = i;
233	111	in_data_len -= i;
234	112	}
235		}
236
237		if (in_data_len>0) {
238		if (self->padlen == 0 && self->padding_mode !=0) {
239		/* in case of padding keep full pad if no more data */
240		Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
241		self->padlen = blen;
242		in_data_len -= blen;
243		}
244		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
245		if (i == 0) {
246		RETVAL = newSVpvn("", 0);
247		}
248		else {
	113
	114	if (in_data_len > 0) {
	115	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
249	116	RETVAL = NEWSV(0, i);
250	117	SvPOK_only(RETVAL);
251	118	SvCUR_set(RETVAL, i);

254	121	Copy(tmp_block, out_data, blen, unsigned char);
255	122	out_data += blen;
256	123	}
257		rv = [%lc_name%]_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	124	rv = [%lc_name%]_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
258	125	if (rv != CRYPT_OK) {
259	126	SvREFCNT_dec(RETVAL);
260		croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
261		}
262		}
263		} /* in_data_len>0 */
264		else if (has_tmp_block) {
265		RETVAL = newSVpvn((char*)tmp_block, blen);
266		}
267		else {
	127	croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	128	}
	129	} /* in_data_len>0 */
	130	else if (has_tmp_block) {
	131	RETVAL = newSVpvn((char*)tmp_block, blen);
	132	}
	133	else {
	134	RETVAL = newSVpvn("", 0);
	135	}
	136	}
	137	}
	138	else if (self->direction == -1) {
	139	blen = (&self->state)->blocklen;
	140	in_data_start = 0;
	141	has_tmp_block = 0;
	142	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	143	if (in_data_len == 0) {
268	144	RETVAL = newSVpvn("", 0);
269	145	}
270		}
271
	146	else {
	147
	148	if (self->padlen == blen) {
	149	rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
	150	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	151	self->padlen = 0;
	152	has_tmp_block = 1;
	153	} /* padlen == blen */
	154	else if (self->padlen > 0) {
	155	i = (blen - self->padlen); /* remaining bytes in padding buffer */
	156	if (in_data_len >= i) { /* enough data to fill pad */
	157	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	158	self->padlen += i;
	159	in_data_len -= i;
	160	in_data_start = i;
	161	if (in_data_len>0 \|\| self->padding_mode == 0) {
	162	rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
	163	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	164	self->padlen = 0;
	165	has_tmp_block = 1;
	166	}
	167	}
	168	else { /* not enough data to fill pad */
	169	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	170	self->padlen += (int)in_data_len;
	171	in_data_len = 0;
	172	}
	173	} /* padlen > 0 */
	174
	175	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
	176	if (in_data_len>0) {
	177	i = (unsigned long)(in_data_len % blen);
	178	if (i>0) { /* save tail of data into pad */
	179	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
	180	self->padlen = i;
	181	in_data_len -= i;
	182	}
	183	}
	184
	185	if (in_data_len>0) {
	186	if (self->padlen == 0 && self->padding_mode !=0) {
	187	/* in case of padding keep full pad if no more data */
	188	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
	189	self->padlen = blen;
	190	in_data_len -= blen;
	191	}
	192	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
	193	if (i == 0) {
	194	RETVAL = newSVpvn("", 0);
	195	}
	196	else {
	197	RETVAL = NEWSV(0, i);
	198	SvPOK_only(RETVAL);
	199	SvCUR_set(RETVAL, i);
	200	out_data = (unsigned char *)SvPVX(RETVAL);
	201	if (has_tmp_block) {
	202	Copy(tmp_block, out_data, blen, unsigned char);
	203	out_data += blen;
	204	}
	205	rv = [%lc_name%]_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	206	if (rv != CRYPT_OK) {
	207	SvREFCNT_dec(RETVAL);
	208	croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	209	}
	210	}
	211	} /* in_data_len>0 */
	212	else if (has_tmp_block) {
	213	RETVAL = newSVpvn((char*)tmp_block, blen);
	214	}
	215	else {
	216	RETVAL = newSVpvn("", 0);
	217	}
	218	}
	219	}
	220	else {
	221	croak("FATAL: call start_decryt or start_encrpyt first (%d)", self->direction);
	222	}
272	223	}
273	224	OUTPUT:
274	225	RETVAL
275	226
276	227	SV *
277		_finish_dec(Crypt::Mode::[%orig_name%] self)
278		CODE:
279		{
280		unsigned char tmp_block[MAXBLOCKSIZE];
281		unsigned char i;
282		int rv, rv_len, blen;
283
284		rv_len = 0;
285		if (self->padlen > 0) {
286		blen = (&self->state)->blocklen;
287		if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
288		rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
289		if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
290		if (self->padding_mode == 0) { /* no padding */
291		rv_len = blen;
292		}
293		else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
294		i = tmp_block[blen-1];
295		rv_len = blen - (i>blen ? blen : i);
296		}
297		else if (self->padding_mode == 2) { /* oneandzeroes padding */
298		rv_len = blen;
299		while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
300		if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;
301		if (rv_len<0) rv_len = 0;
302		}
	228	finish(Crypt::Mode::[%orig_name%] self)
	229	CODE:
	230	{
	231	unsigned char tmp_block[MAXBLOCKSIZE], ch;
	232	int i, j, rv, blen = (&self->state)->blocklen;
	233
	234	if (self->direction == 1) {
	235	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
	236	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	237	i = blen - self->padlen;
	238	if (i == 0) i = blen;
	239	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
	240	rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
	241	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	242	}
	243	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	244	self->pad[self->padlen] = 0x80;
	245	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
	246	rv = [%lc_name%]_encrypt(self->pad, tmp_block, blen, &self->state);
	247	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_encrypt failed: %s", error_to_string(rv));
	248	}
	249	else {
	250	if (self->padlen>0) croak("FATAL: [%lc_name%]_encrypt, input data length not multiple of %d", blen);
	251	blen = 0;
	252	}
	253	}
	254	else if (self->direction == -1) {
	255	if (self->padlen > 0) {
	256	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
	257	rv = [%lc_name%]_decrypt(self->pad, tmp_block, blen, &self->state);
	258	if (rv != CRYPT_OK) croak("FATAL: [%lc_name%]_decrypt failed: %s", error_to_string(rv));
	259	if (self->padding_mode == 0) { /* no padding */
	260	/* we already have blen */
	261	}
	262	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	263	ch = tmp_block[blen-1];
	264	blen = blen - (ch > blen ? blen : ch);
	265	}
	266	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	267	while ((unsigned char)tmp_block[blen - 1] == 0x00) blen--;
	268	if ((unsigned char)tmp_block[blen - 1] == 0x80) blen--;
	269	if (blen < 0) blen = 0;
	270	}
	271	}
	272	else {
	273	blen = 0;
	274	}
	275	}
	276	else {
	277	XSRETURN_UNDEF;
303	278	}
304	279
305	280	self->direction = 0;
306		RETVAL = newSVpvn((char*)tmp_block, rv_len);
	281	RETVAL = newSVpvn((char*)tmp_block, blen);
307	282	}
308	283	OUTPUT:
309	284	RETVAL

+5

-0

_generators/tt_digest.pl less more

99	99	$data->{t_files_count} = scalar(@{$data->{t_files}});
100	100	$data->{t_strings_count} = scalar(@{$data->{t_strings}});
101	101	$data->{hashsize} = Crypt::Digest->hashsize($n);
	102	$data->{tripple_A} = {
	103	hex => Crypt::Digest::digest_data_hex($n, "AAA"),
	104	base64 => Crypt::Digest::digest_data_b64($n, "AAA"),
	105	base64url => Crypt::Digest::digest_data_b64u($n, "AAA"),
	106	};
102	107
103	108	my $t_out = catfile($outdir_t, "digest_".lc($n).".t");
104	109	my $t_tt = Template->new(ABSOLUTE=>1) \|\| die $Template::ERROR, "\n";

+25

-0

_generators/tt_mac.pl less more

92	92	$_->{b64umac} = encode_base64url(pack("H*", $_->{mac}),'') for (@{$data->{t_strings}});
93	93	$data->{t_strings_count} = defined $data->{t_strings} ? scalar(@{$data->{t_strings}}) : 0;
94	94
	95	# tripple_A
	96	if ($n eq 'HMAC') {
	97	$data->{tripple_A}{mac} = Crypt::Mac::HMAC->new('SHA1', 'secretkey')->add("AAA")->mac;
	98	$data->{tripple_A}{args} = "'SHA1', 'secretkey'";
	99	}
	100	elsif ($n eq 'Pelican') {
	101	$data->{tripple_A}{mac} = Crypt::Mac::Pelican->new('1234567890123456')->add("AAA")->mac;
	102	$data->{tripple_A}{args} = "'1234567890123456'";
	103	}
	104	elsif ($n eq 'Poly1305') {
	105	$data->{tripple_A}{mac} = Crypt::Mac::Poly1305->new('12345678901234561234567890123456')->add("AAA")->mac;
	106	$data->{tripple_A}{args} = "'12345678901234561234567890123456'";
	107	}
	108	elsif ($n =~ /BLAKE2(s\|b)/) {
	109	$data->{tripple_A}{mac} = "Crypt::Mac::$n"->new(32, '12345678901234561234567890123456')->add("AAA")->mac;
	110	$data->{tripple_A}{args} = "32, '12345678901234561234567890123456'";
	111	}
	112	else {
	113	$data->{tripple_A}{mac} = "Crypt::Mac::$n"->new('AES', '1234567890123456')->add("AAA")->mac;
	114	$data->{tripple_A}{args} = "'AES', '1234567890123456'";
	115	}
	116	$data->{tripple_A}{hexmac} = unpack('H*', $data->{tripple_A}{mac});
	117	$data->{tripple_A}{b64mac} = encode_base64($data->{tripple_A}{mac},'');
	118	$data->{tripple_A}{b64umac} = encode_base64url($data->{tripple_A}{mac},'');
	119
95	120	my $t_out = catfile($outdir_t, "mac_".lc($n).".t");
96	121	my $t_tt = Template->new(ABSOLUTE=>1) \|\| die $Template::ERROR, "\n";
97	122	$t_tt->process("$FindBin::Bin/Mac.t.tt", $data, "$t_out.$$", {binmode=>1}) \|\| die $t_tt->error(), "\n";

+67

-136

inc/CryptX_Digest.xs.inc less more

56	56	int rv, i;
57	57	unsigned char *in;
58	58
59		for(i=1; i<items; i++) {
	59	for(i = 1; i < items; i++) {
60	60	in = (unsigned char *)SvPVbyte(ST(i), inlen);
61		if (inlen>0) {
	61	if (inlen > 0) {
62	62	rv = self->desc->process(&self->state, in, (unsigned long)inlen);
63	63	if (rv != CRYPT_OK) croak("FATAL: digest process failed: %s", error_to_string(rv));
64	64	}

68	68
69	69	SV *
70	70	digest(Crypt::Digest self)
71		CODE:
72		{
73		unsigned char hash[MAXBLOCKSIZE];
74		int rv;
75
76		rv = self->desc->done(&self->state, hash);
77		if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
78		RETVAL = newSVpvn((char *) hash, self->desc->hashsize);
79		}
80		OUTPUT:
81		RETVAL
82
83		SV *
84		hexdigest(Crypt::Digest self)
	71	ALIAS:
	72	hexdigest = 1
	73	b64digest = 2
	74	b64udigest = 3
85	75	CODE:
86	76	{
87	77	int rv;

93	83	if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
94	84
95	85	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);
	86	if (ix == 3) {
	87	rv = base64url_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
	88	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	89	RETVAL = newSVpvn(out, outlen);
	90	}
	91	else if (ix == 2) {
	92	rv = base64_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
	93	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	94	RETVAL = newSVpvn(out, outlen);
	95	}
	96	else if (ix == 1) {
	97	rv = _base16_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
	98	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	99	RETVAL = newSVpvn(out, outlen);
	100	}
	101	else {
	102	RETVAL = newSVpvn((char *) hash, self->desc->hashsize);
	103	}
99	104	}
100	105	OUTPUT:
101	106	RETVAL
102	107
103	108	SV *
104		b64digest(Crypt::Digest self)
	109	digest_data(char * digest_name, ...)
	110	ALIAS:
	111	digest_data_hex = 1
	112	digest_data_b64 = 2
	113	digest_data_b64u = 3
105	114	CODE:
106	115	{
107		int rv;
108		unsigned long outlen;
109		unsigned char hash[MAXBLOCKSIZE];
	116	STRLEN inlen;
	117	int rv, id, i;
	118	unsigned char *in, hash[MAXBLOCKSIZE];
	119	unsigned long len = sizeof(hash), outlen;
110	120	char out[MAXBLOCKSIZE*2];
	121	hash_state md;
111	122
112		rv = self->desc->done(&self->state, hash);
	123	id = _find_hash(digest_name);
	124	if (id == -1) croak("FATAL: find_digest failed for '%s'", digest_name);
	125
	126	/* digest_data("SHA1", $data1, $data2, $data3); */
	127	len = hash_descriptor[id].hashsize;
	128	rv = hash_descriptor[id].init(&md);
	129	if (rv != CRYPT_OK) croak("FATAL: digest init failed: %s", error_to_string(rv));
	130	for (i = 1; i < items; i++) {
	131	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	132	if (inlen > 0) {
	133	rv = hash_descriptor[id].process(&md, in, (unsigned long)inlen);
	134	if (rv != CRYPT_OK) croak("FATAL: digest process failed: %s", error_to_string(rv));
	135	}
	136	}
	137	rv = hash_descriptor[id].done(&md, hash);
113	138	if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
114	139
115	140	outlen = sizeof(out);
116		rv = base64_encode(hash, self->desc->hashsize, (unsigned char *)out, &outlen);
117		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
118		RETVAL = newSVpvn(out, outlen);
119		}
120		OUTPUT:
121		RETVAL
122
123		SV *
124		b64udigest(Crypt::Digest self)
125		CODE:
126		{
127		int rv;
128		unsigned long outlen;
129		unsigned char hash[MAXBLOCKSIZE];
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);
137		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
138		RETVAL = newSVpvn(out, outlen);
	141	if (ix == 3) {
	142	rv = base64url_encode(hash, len, (unsigned char *)out, &outlen);
	143	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	144	RETVAL = newSVpvn((char *) out, outlen);
	145	}
	146	else if (ix == 2) {
	147	rv = base64_encode(hash, len, (unsigned char *)out, &outlen);
	148	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	149	RETVAL = newSVpvn((char *) out, outlen);
	150	}
	151	else if (ix == 1) {
	152	rv = _base16_encode(hash, len, (unsigned char *)out, &outlen);
	153	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	154	RETVAL = newSVpvn((char *) out, outlen);
	155	}
	156	else {
	157	RETVAL = newSVpvn((char *) hash, len);
	158	}
139	159	}
140	160	OUTPUT:
141	161	RETVAL

162	182	}
163	183	OUTPUT:
164	184	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

+74

-142

inc/CryptX_Mac_BLAKE2b.xs.inc less more

39	39	RETVAL
40	40
41	41	void
42		_add_single(Crypt::Mac::BLAKE2b self, SV * data)
43		CODE:
	42	add(Crypt::Mac::BLAKE2b self, ...)
	43	PPCODE:
44	44	{
45		int rv;
	45	int rv, i;
46	46	STRLEN in_data_len;
47	47	unsigned char *in_data;
48	48
49		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
50		if (in_data_len>0) {
51		rv = blake2bmac_process(&self->state, in_data, (unsigned long)in_data_len);
52		if (rv != CRYPT_OK) croak("FATAL: blake2b_process failed: %s", error_to_string(rv));
	49	for(i = 1; i < items; i++) {
	50	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	51	if (in_data_len > 0) {
	52	rv = blake2bmac_process(&self->state, in_data, (unsigned long)in_data_len);
	53	if (rv != CRYPT_OK) croak("FATAL: blake2b_process failed: %s", error_to_string(rv));
	54	}
53	55	}
	56	XPUSHs(ST(0)); /* return self */
54	57	}
55	58
56	59	SV *
57	60	mac(Crypt::Mac::BLAKE2b self)
58		CODE:
59		{
60		char mac[MAXBLOCKSIZE];
61		unsigned long maclen;
62		int rv;
63
64		maclen = sizeof(mac);
65		rv = blake2bmac_done(&self->state, (unsigned char*)mac, &maclen);
66		if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, maclen);
68		}
69		OUTPUT:
70		RETVAL
71
72		SV *
73		b64mac(Crypt::Mac::BLAKE2b self)
74		CODE:
75		{
76		unsigned char mac[MAXBLOCKSIZE];
77		unsigned long maclen;
78		int rv;
79		unsigned long outlen;
80		char out[MAXBLOCKSIZE*2];
81
82		maclen = sizeof(mac);
83		rv = blake2bmac_done(&self->state, mac, &maclen);
84		if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
85		outlen = sizeof(out);
86		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(out, outlen);
89		}
90		OUTPUT:
91		RETVAL
92
93		SV *
94		b64umac(Crypt::Mac::BLAKE2b self)
95		CODE:
96		{
97		unsigned char mac[MAXBLOCKSIZE];
98		unsigned long maclen;
99		int rv;
100		unsigned long outlen;
101		char out[MAXBLOCKSIZE*2 + 1];
102
103		maclen = sizeof(mac);
104		rv = blake2bmac_done(&self->state, mac, &maclen);
105		if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
106		outlen = sizeof(out);
107		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(out, outlen);
110		}
111		OUTPUT:
112		RETVAL
113
114		SV *
115		hexmac(Crypt::Mac::BLAKE2b self)
	61	ALIAS:
	62	hexmac = 1
	63	b64mac = 2
	64	b64umac = 3
116	65	CODE:
117	66	{
118	67	unsigned char mac[MAXBLOCKSIZE];

124	73	rv = blake2bmac_done(&self->state, mac, &maclen);
125	74	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
126	75	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);
	76	if (ix == 3) {
	77	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	78	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	79	RETVAL = newSVpvn(out, outlen);
	80	}
	81	if (ix == 2) {
	82	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	83	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	84	RETVAL = newSVpvn(out, outlen);
	85	}
	86	if (ix == 1) {
	87	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	88	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	89	RETVAL = newSVpvn(out, outlen);
	90	}
	91	else {
	92	RETVAL = newSVpvn(mac, maclen);
	93	}
130	94	}
131	95	OUTPUT:
132	96	RETVAL
133	97
134	98	SV *
135		blake2b(unsigned long size, SV * key, SV * data)
	99	blake2b(unsigned long size, SV * key, ...)
	100	ALIAS:
	101	blake2b_hex = 1
	102	blake2b_b64 = 2
	103	blake2b_b64u = 3
136	104	CODE:
137	105	{
138	106	STRLEN inlen, klen;
139		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	107	unsigned char *in;
140	108	unsigned char k = (unsigned char )SvPVbyte(key, klen);
141		int rv;
	109	int rv, i;
142	110	unsigned char mac[MAXBLOCKSIZE];
143		unsigned long len = sizeof(mac);
	111	unsigned long len = sizeof(mac), outlen;
	112	char out[MAXBLOCKSIZE*2];
	113	blake2bmac_state st;
	114
144	115	if (size < len) len = size;
145		rv = blake2bmac_memory(k, klen, in, inlen, mac, &len);
146		if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv));
147		RETVAL = newSVpvn((char *) mac, len);
	116	rv = blake2bmac_init(&st, len, k, klen);
	117	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_init failed: %s", error_to_string(rv));
	118	for (i = 2; i < items; i++) {
	119	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	120	if (inlen > 0) {
	121	rv = blake2bmac_process(&st, in, inlen);
	122	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_process failed: %s", error_to_string(rv));
	123	}
	124	}
	125	rv = blake2bmac_done(&st, mac, &len);
	126	if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
	127
	128	outlen = sizeof(out);
	129	if (ix == 3) {
	130	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	131	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	132	RETVAL = newSVpvn((char *) out, outlen);
	133	}
	134	else if (ix == 2) {
	135	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 1) {
	140	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else {
	145	RETVAL = newSVpvn((char *) mac, len);
	146	}
148	147	}
149	148	OUTPUT:
150	149	RETVAL
151
152		SV *
153		blake2b_hex(unsigned long size, SV * key, SV * data)
154		CODE:
155		{
156		STRLEN inlen, klen;
157		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
158		unsigned char k = (unsigned char )SvPVbyte(key, klen);
159		int rv;
160		unsigned char mac[MAXBLOCKSIZE];
161		unsigned long len = sizeof(mac), outlen;
162		char out[MAXBLOCKSIZE*2];
163		if (size < len) len = size;
164		rv = blake2bmac_memory(k, klen, in, inlen, mac, &len);
165		if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv));
166		outlen = sizeof(out);
167		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
168		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
169		RETVAL = newSVpvn((char *) out, outlen);
170		}
171		OUTPUT:
172		RETVAL
173
174		SV *
175		blake2b_b64(unsigned long size, SV * key, SV * data)
176		CODE:
177		{
178		STRLEN inlen, klen;
179		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
180		unsigned char k = (unsigned char )SvPVbyte(key, klen);
181		int rv;
182		unsigned char mac[MAXBLOCKSIZE];
183		unsigned long len = sizeof(mac), outlen;
184		char out[MAXBLOCKSIZE*2];
185		if (size < len) len = size;
186		rv = blake2bmac_memory(k, klen, in, inlen, mac, &len);
187		if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv));
188		outlen = sizeof(out);
189		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
190		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
191		RETVAL = newSVpvn((char *) out, outlen);
192
193		}
194		OUTPUT:
195		RETVAL
196
197		SV *
198		blake2b_b64u(unsigned long size, SV * key, SV * data)
199		CODE:
200		{
201		STRLEN inlen, klen;
202		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
203		unsigned char k = (unsigned char )SvPVbyte(key, klen);
204		int rv;
205		unsigned char mac[MAXBLOCKSIZE];
206		unsigned long len = sizeof(mac), outlen;
207		char out[MAXBLOCKSIZE*2];
208		if (size < len) len = size;
209		rv = blake2bmac_memory(k, klen, in, inlen, mac, &len);
210		if (rv != CRYPT_OK) croak("FATAL: blake2b_memory failed: %s", error_to_string(rv));
211		outlen = sizeof(out);
212		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
213		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
214		RETVAL = newSVpvn((char *) out, outlen);
215		}
216		OUTPUT:
217		RETVAL

+74

-142

inc/CryptX_Mac_BLAKE2s.xs.inc less more

39	39	RETVAL
40	40
41	41	void
42		_add_single(Crypt::Mac::BLAKE2s self, SV * data)
43		CODE:
	42	add(Crypt::Mac::BLAKE2s self, ...)
	43	PPCODE:
44	44	{
45		int rv;
	45	int rv, i;
46	46	STRLEN in_data_len;
47	47	unsigned char *in_data;
48	48
49		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
50		if (in_data_len>0) {
51		rv = blake2smac_process(&self->state, in_data, (unsigned long)in_data_len);
52		if (rv != CRYPT_OK) croak("FATAL: blake2s_process failed: %s", error_to_string(rv));
	49	for(i = 1; i < items; i++) {
	50	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	51	if (in_data_len > 0) {
	52	rv = blake2smac_process(&self->state, in_data, (unsigned long)in_data_len);
	53	if (rv != CRYPT_OK) croak("FATAL: blake2s_process failed: %s", error_to_string(rv));
	54	}
53	55	}
	56	XPUSHs(ST(0)); /* return self */
54	57	}
55	58
56	59	SV *
57	60	mac(Crypt::Mac::BLAKE2s self)
58		CODE:
59		{
60		char mac[MAXBLOCKSIZE];
61		unsigned long maclen;
62		int rv;
63
64		maclen = sizeof(mac);
65		rv = blake2smac_done(&self->state, (unsigned char*)mac, &maclen);
66		if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, maclen);
68		}
69		OUTPUT:
70		RETVAL
71
72		SV *
73		b64mac(Crypt::Mac::BLAKE2s self)
74		CODE:
75		{
76		unsigned char mac[MAXBLOCKSIZE];
77		unsigned long maclen;
78		int rv;
79		unsigned long outlen;
80		char out[MAXBLOCKSIZE*2];
81
82		maclen = sizeof(mac);
83		rv = blake2smac_done(&self->state, mac, &maclen);
84		if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
85		outlen = sizeof(out);
86		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(out, outlen);
89		}
90		OUTPUT:
91		RETVAL
92
93		SV *
94		b64umac(Crypt::Mac::BLAKE2s self)
95		CODE:
96		{
97		unsigned char mac[MAXBLOCKSIZE];
98		unsigned long maclen;
99		int rv;
100		unsigned long outlen;
101		char out[MAXBLOCKSIZE*2 + 1];
102
103		maclen = sizeof(mac);
104		rv = blake2smac_done(&self->state, mac, &maclen);
105		if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
106		outlen = sizeof(out);
107		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(out, outlen);
110		}
111		OUTPUT:
112		RETVAL
113
114		SV *
115		hexmac(Crypt::Mac::BLAKE2s self)
	61	ALIAS:
	62	hexmac = 1
	63	b64mac = 2
	64	b64umac = 3
116	65	CODE:
117	66	{
118	67	unsigned char mac[MAXBLOCKSIZE];

124	73	rv = blake2smac_done(&self->state, mac, &maclen);
125	74	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
126	75	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);
	76	if (ix == 3) {
	77	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	78	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	79	RETVAL = newSVpvn(out, outlen);
	80	}
	81	if (ix == 2) {
	82	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	83	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	84	RETVAL = newSVpvn(out, outlen);
	85	}
	86	if (ix == 1) {
	87	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	88	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	89	RETVAL = newSVpvn(out, outlen);
	90	}
	91	else {
	92	RETVAL = newSVpvn(mac, maclen);
	93	}
130	94	}
131	95	OUTPUT:
132	96	RETVAL
133	97
134	98	SV *
135		blake2s(unsigned long size, SV * key, SV * data)
	99	blake2s(unsigned long size, SV * key, ...)
	100	ALIAS:
	101	blake2s_hex = 1
	102	blake2s_b64 = 2
	103	blake2s_b64u = 3
136	104	CODE:
137	105	{
138	106	STRLEN inlen, klen;
139		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	107	unsigned char *in;
140	108	unsigned char k = (unsigned char )SvPVbyte(key, klen);
141		int rv;
	109	int rv, i;
142	110	unsigned char mac[MAXBLOCKSIZE];
143		unsigned long len = sizeof(mac);
	111	unsigned long len = sizeof(mac), outlen;
	112	char out[MAXBLOCKSIZE*2];
	113	blake2smac_state st;
	114
144	115	if (size < len) len = size;
145		rv = blake2smac_memory(k, klen, in, inlen, mac, &len);
146		if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv));
147		RETVAL = newSVpvn((char *) mac, len);
	116	rv = blake2smac_init(&st, len, k, klen);
	117	if (rv != CRYPT_OK) croak("FATAL: blake2smac_init failed: %s", error_to_string(rv));
	118	for (i = 2; i < items; i++) {
	119	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	120	if (inlen > 0) {
	121	rv = blake2smac_process(&st, in, inlen);
	122	if (rv != CRYPT_OK) croak("FATAL: blake2smac_process failed: %s", error_to_string(rv));
	123	}
	124	}
	125	rv = blake2smac_done(&st, mac, &len);
	126	if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
	127
	128	outlen = sizeof(out);
	129	if (ix == 3) {
	130	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	131	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	132	RETVAL = newSVpvn((char *) out, outlen);
	133	}
	134	else if (ix == 2) {
	135	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 1) {
	140	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else {
	145	RETVAL = newSVpvn((char *) mac, len);
	146	}
148	147	}
149	148	OUTPUT:
150	149	RETVAL
151
152		SV *
153		blake2s_hex(unsigned long size, SV * key, SV * data)
154		CODE:
155		{
156		STRLEN inlen, klen;
157		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
158		unsigned char k = (unsigned char )SvPVbyte(key, klen);
159		int rv;
160		unsigned char mac[MAXBLOCKSIZE];
161		unsigned long len = sizeof(mac), outlen;
162		char out[MAXBLOCKSIZE*2];
163		if (size < len) len = size;
164		rv = blake2smac_memory(k, klen, in, inlen, mac, &len);
165		if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv));
166		outlen = sizeof(out);
167		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
168		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
169		RETVAL = newSVpvn((char *) out, outlen);
170		}
171		OUTPUT:
172		RETVAL
173
174		SV *
175		blake2s_b64(unsigned long size, SV * key, SV * data)
176		CODE:
177		{
178		STRLEN inlen, klen;
179		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
180		unsigned char k = (unsigned char )SvPVbyte(key, klen);
181		int rv;
182		unsigned char mac[MAXBLOCKSIZE];
183		unsigned long len = sizeof(mac), outlen;
184		char out[MAXBLOCKSIZE*2];
185		if (size < len) len = size;
186		rv = blake2smac_memory(k, klen, in, inlen, mac, &len);
187		if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv));
188		outlen = sizeof(out);
189		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
190		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
191		RETVAL = newSVpvn((char *) out, outlen);
192
193		}
194		OUTPUT:
195		RETVAL
196
197		SV *
198		blake2s_b64u(unsigned long size, SV * key, SV * data)
199		CODE:
200		{
201		STRLEN inlen, klen;
202		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
203		unsigned char k = (unsigned char )SvPVbyte(key, klen);
204		int rv;
205		unsigned char mac[MAXBLOCKSIZE];
206		unsigned long len = sizeof(mac), outlen;
207		char out[MAXBLOCKSIZE*2];
208		if (size < len) len = size;
209		rv = blake2smac_memory(k, klen, in, inlen, mac, &len);
210		if (rv != CRYPT_OK) croak("FATAL: blake2s_memory failed: %s", error_to_string(rv));
211		outlen = sizeof(out);
212		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
213		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
214		RETVAL = newSVpvn((char *) out, outlen);
215		}
216		OUTPUT:
217		RETVAL

+74

-145

inc/CryptX_Mac_F9.xs.inc less more

43	43	RETVAL
44	44
45	45	void
46		_add_single(Crypt::Mac::F9 self, SV * data)
47		CODE:
	46	add(Crypt::Mac::F9 self, ...)
	47	PPCODE:
48	48	{
49		int rv;
	49	int rv, i;
50	50	STRLEN in_data_len;
51	51	unsigned char *in_data;
52	52
53		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
54		if (in_data_len>0) {
55		rv = f9_process(&self->state, in_data, (unsigned long)in_data_len);
56		if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv));
	53	for(i = 1; i < items; i++) {
	54	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	55	if (in_data_len > 0) {
	56	rv = f9_process(&self->state, in_data, (unsigned long)in_data_len);
	57	if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv));
	58	}
57	59	}
	60	XPUSHs(ST(0)); /* return self */
58	61	}
59	62
60	63	SV *
61	64	mac(Crypt::Mac::F9 self)
62		CODE:
63		{
64		char mac[MAXBLOCKSIZE];
65		unsigned long maclen;
66		int rv;
67
68		maclen = sizeof(mac);
69		rv = f9_done(&self->state, (unsigned char*)mac, &maclen);
70		if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, maclen);
72		}
73		OUTPUT:
74		RETVAL
75
76		SV *
77		b64mac(Crypt::Mac::F9 self)
78		CODE:
79		{
80		unsigned char mac[MAXBLOCKSIZE];
81		unsigned long maclen;
82		int rv;
83		unsigned long outlen;
84		char out[MAXBLOCKSIZE*2];
85
86		maclen = sizeof(mac);
87		rv = f9_done(&self->state, mac, &maclen);
88		if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
89		outlen = sizeof(out);
90		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(out, outlen);
93		}
94		OUTPUT:
95		RETVAL
96
97		SV *
98		b64umac(Crypt::Mac::F9 self)
99		CODE:
100		{
101		unsigned char mac[MAXBLOCKSIZE];
102		unsigned long maclen;
103		int rv;
104		unsigned long outlen;
105		char out[MAXBLOCKSIZE*2 + 1];
106
107		maclen = sizeof(mac);
108		rv = f9_done(&self->state, mac, &maclen);
109		if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
110		outlen = sizeof(out);
111		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(out, outlen);
114		}
115		OUTPUT:
116		RETVAL
117
118		SV *
119		hexmac(Crypt::Mac::F9 self)
	65	ALIAS:
	66	hexmac = 1
	67	b64mac = 2
	68	b64umac = 3
120	69	CODE:
121	70	{
122	71	unsigned char mac[MAXBLOCKSIZE];

128	77	rv = f9_done(&self->state, mac, &maclen);
129	78	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
130	79	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);
	80	if (ix == 3) {
	81	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	82	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	83	RETVAL = newSVpvn(out, outlen);
	84	}
	85	if (ix == 2) {
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	88	RETVAL = newSVpvn(out, outlen);
	89	}
	90	if (ix == 1) {
	91	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	92	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	93	RETVAL = newSVpvn(out, outlen);
	94	}
	95	else {
	96	RETVAL = newSVpvn(mac, maclen);
	97	}
134	98	}
135	99	OUTPUT:
136	100	RETVAL
137	101
138	102	SV *
139		f9(char * cipher_name, SV * key, SV * data)
	103	f9(char * cipher_name, SV * key, ...)
	104	ALIAS:
	105	f9_hex = 1
	106	f9_b64 = 2
	107	f9_b64u = 3
140	108	CODE:
141	109	{
142	110	STRLEN inlen, klen;
143		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	111	unsigned char *in;
144	112	unsigned char k = (unsigned char )SvPVbyte(key, klen);
145		int rv;
	113	int rv, i;
146	114	unsigned char mac[MAXBLOCKSIZE];
147		unsigned long len = sizeof(mac);
	115	unsigned long len = sizeof(mac), outlen;
	116	char out[MAXBLOCKSIZE*2];
	117	f9_state st;
	118
148	119	int id = _find_cipher(cipher_name);
149	120	if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
150		rv = f9_memory(id, k, klen, in, inlen, mac, &len);
151		if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv));
152		RETVAL = newSVpvn((char *) mac, len);
	121	rv = f9_init(&st, id, k, klen);
	122	if (rv != CRYPT_OK) croak("FATAL: f9_init failed: %s", error_to_string(rv));
	123	for (i = 2; i < items; i++) {
	124	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	125	if (inlen > 0) {
	126	rv = f9_process(&st, in, inlen);
	127	if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv));
	128	}
	129	}
	130	rv = f9_done(&st, mac, &len);
	131	if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
	132
	133	outlen = sizeof(out);
	134	if (ix == 3) {
	135	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 2) {
	140	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else if (ix == 1) {
	145	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	146	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	147	RETVAL = newSVpvn((char *) out, outlen);
	148	}
	149	else {
	150	RETVAL = newSVpvn((char *) mac, len);
	151	}
153	152	}
154	153	OUTPUT:
155	154	RETVAL
156
157		SV *
158		f9_hex(char * cipher_name, SV * key, SV * data)
159		CODE:
160		{
161		STRLEN inlen, klen;
162		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
163		unsigned char k = (unsigned char )SvPVbyte(key, klen);
164		int rv;
165		unsigned char mac[MAXBLOCKSIZE];
166		unsigned long len = sizeof(mac), outlen;
167		char out[MAXBLOCKSIZE*2];
168		int id = _find_cipher(cipher_name);
169		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
170		rv = f9_memory(id, k, klen, in, inlen, mac, &len);
171		if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv));
172		outlen = sizeof(out);
173		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
174		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
175		RETVAL = newSVpvn((char *) out, outlen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		f9_b64(char * cipher_name, SV * key, SV * data)
182		CODE:
183		{
184		STRLEN inlen, klen;
185		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
186		unsigned char k = (unsigned char )SvPVbyte(key, klen);
187		int rv;
188		unsigned char mac[MAXBLOCKSIZE];
189		unsigned long len = sizeof(mac), outlen;
190		char out[MAXBLOCKSIZE*2];
191		int id = _find_cipher(cipher_name);
192		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
193		rv = f9_memory(id, k, klen, in, inlen, mac, &len);
194		if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv));
195		outlen = sizeof(out);
196		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
197		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
198		RETVAL = newSVpvn((char *) out, outlen);
199
200		}
201		OUTPUT:
202		RETVAL
203
204		SV *
205		f9_b64u(char * cipher_name, SV * key, SV * data)
206		CODE:
207		{
208		STRLEN inlen, klen;
209		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
210		unsigned char k = (unsigned char )SvPVbyte(key, klen);
211		int rv;
212		unsigned char mac[MAXBLOCKSIZE];
213		unsigned long len = sizeof(mac), outlen;
214		char out[MAXBLOCKSIZE*2];
215		int id = _find_cipher(cipher_name);
216		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
217		rv = f9_memory(id, k, klen, in, inlen, mac, &len);
218		if (rv != CRYPT_OK) croak("FATAL: f9_memory failed: %s", error_to_string(rv));
219		outlen = sizeof(out);
220		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
221		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
222		RETVAL = newSVpvn((char *) out, outlen);
223		}
224		OUTPUT:
225		RETVAL

+74

-145

inc/CryptX_Mac_HMAC.xs.inc less more

43	43	RETVAL
44	44
45	45	void
46		_add_single(Crypt::Mac::HMAC self, SV * data)
47		CODE:
	46	add(Crypt::Mac::HMAC self, ...)
	47	PPCODE:
48	48	{
49		int rv;
	49	int rv, i;
50	50	STRLEN in_data_len;
51	51	unsigned char *in_data;
52	52
53		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
54		if (in_data_len>0) {
55		rv = hmac_process(&self->state, in_data, (unsigned long)in_data_len);
56		if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv));
	53	for(i = 1; i < items; i++) {
	54	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	55	if (in_data_len > 0) {
	56	rv = hmac_process(&self->state, in_data, (unsigned long)in_data_len);
	57	if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv));
	58	}
57	59	}
	60	XPUSHs(ST(0)); /* return self */
58	61	}
59	62
60	63	SV *
61	64	mac(Crypt::Mac::HMAC self)
62		CODE:
63		{
64		char mac[MAXBLOCKSIZE];
65		unsigned long maclen;
66		int rv;
67
68		maclen = sizeof(mac);
69		rv = hmac_done(&self->state, (unsigned char*)mac, &maclen);
70		if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, maclen);
72		}
73		OUTPUT:
74		RETVAL
75
76		SV *
77		b64mac(Crypt::Mac::HMAC self)
78		CODE:
79		{
80		unsigned char mac[MAXBLOCKSIZE];
81		unsigned long maclen;
82		int rv;
83		unsigned long outlen;
84		char out[MAXBLOCKSIZE*2];
85
86		maclen = sizeof(mac);
87		rv = hmac_done(&self->state, mac, &maclen);
88		if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(out);
90		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(out, outlen);
93		}
94		OUTPUT:
95		RETVAL
96
97		SV *
98		b64umac(Crypt::Mac::HMAC self)
99		CODE:
100		{
101		unsigned char mac[MAXBLOCKSIZE];
102		unsigned long maclen;
103		int rv;
104		unsigned long outlen;
105		char out[MAXBLOCKSIZE*2 + 1];
106
107		maclen = sizeof(mac);
108		rv = hmac_done(&self->state, mac, &maclen);
109		if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(out);
111		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(out, outlen);
114		}
115		OUTPUT:
116		RETVAL
117
118		SV *
119		hexmac(Crypt::Mac::HMAC self)
	65	ALIAS:
	66	hexmac = 1
	67	b64mac = 2
	68	b64umac = 3
120	69	CODE:
121	70	{
122	71	unsigned char mac[MAXBLOCKSIZE];

128	77	rv = hmac_done(&self->state, mac, &maclen);
129	78	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
130	79	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);
	80	if (ix == 3) {
	81	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	82	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	83	RETVAL = newSVpvn(out, outlen);
	84	}
	85	if (ix == 2) {
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	88	RETVAL = newSVpvn(out, outlen);
	89	}
	90	if (ix == 1) {
	91	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	92	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	93	RETVAL = newSVpvn(out, outlen);
	94	}
	95	else {
	96	RETVAL = newSVpvn(mac, maclen);
	97	}
134	98	}
135	99	OUTPUT:
136	100	RETVAL
137	101
138	102	SV *
139		hmac(char * hash_name, SV * key, SV * data)
	103	hmac(char * hash_name, SV * key, ...)
	104	ALIAS:
	105	hmac_hex = 1
	106	hmac_b64 = 2
	107	hmac_b64u = 3
140	108	CODE:
141	109	{
142	110	STRLEN inlen, klen;
143		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	111	unsigned char *in;
144	112	unsigned char k = (unsigned char )SvPVbyte(key, klen);
145		int rv;
	113	int rv, i;
146	114	unsigned char mac[MAXBLOCKSIZE];
147		unsigned long len = sizeof(mac);
	115	unsigned long len = sizeof(mac), outlen;
	116	char out[MAXBLOCKSIZE*2];
	117	hmac_state st;
	118
148	119	int id = _find_hash(hash_name);
149	120	if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
150		rv = hmac_memory(id, k, klen, in, inlen, mac, &len);
151		if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv));
152		RETVAL = newSVpvn((char *) mac, len);
	121	rv = hmac_init(&st, id, k, klen);
	122	if (rv != CRYPT_OK) croak("FATAL: hmac_init failed: %s", error_to_string(rv));
	123	for (i = 2; i < items; i++) {
	124	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	125	if (inlen > 0) {
	126	rv = hmac_process(&st, in, inlen);
	127	if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv));
	128	}
	129	}
	130	rv = hmac_done(&st, mac, &len);
	131	if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
	132
	133	outlen = sizeof(out);
	134	if (ix == 3) {
	135	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 2) {
	140	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else if (ix == 1) {
	145	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	146	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	147	RETVAL = newSVpvn((char *) out, outlen);
	148	}
	149	else {
	150	RETVAL = newSVpvn((char *) mac, len);
	151	}
153	152	}
154	153	OUTPUT:
155	154	RETVAL
156
157		SV *
158		hmac_hex(char * hash_name, SV * key, SV * data)
159		CODE:
160		{
161		STRLEN inlen, klen;
162		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
163		unsigned char k = (unsigned char )SvPVbyte(key, klen);
164		int rv;
165		unsigned char mac[MAXBLOCKSIZE];
166		unsigned long len = sizeof(mac), outlen;
167		char out[MAXBLOCKSIZE*2];
168		int id = _find_hash(hash_name);
169		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
170		rv = hmac_memory(id, k, klen, in, inlen, mac, &len);
171		if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv));
172		outlen = sizeof(out);
173		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
174		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
175		RETVAL = newSVpvn((char *) out, outlen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		hmac_b64(char * hash_name, SV * key, SV * data)
182		CODE:
183		{
184		STRLEN inlen, klen;
185		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
186		unsigned char k = (unsigned char )SvPVbyte(key, klen);
187		int rv;
188		unsigned char mac[MAXBLOCKSIZE];
189		unsigned long len = sizeof(mac), outlen;
190		char out[MAXBLOCKSIZE*2];
191		int id = _find_hash(hash_name);
192		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
193		rv = hmac_memory(id, k, klen, in, inlen, mac, &len);
194		if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv));
195		outlen = sizeof(out);
196		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
197		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
198		RETVAL = newSVpvn((char *) out, outlen);
199
200		}
201		OUTPUT:
202		RETVAL
203
204		SV *
205		hmac_b64u(char * hash_name, SV * key, SV * data)
206		CODE:
207		{
208		STRLEN inlen, klen;
209		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
210		unsigned char k = (unsigned char )SvPVbyte(key, klen);
211		int rv;
212		unsigned char mac[MAXBLOCKSIZE];
213		unsigned long len = sizeof(mac), outlen;
214		char out[MAXBLOCKSIZE*2];
215		int id = _find_hash(hash_name);
216		if (id == -1) croak("FATAL: find_digest failed for '%s'", hash_name);
217		rv = hmac_memory(id, k, klen, in, inlen, mac, &len);
218		if (rv != CRYPT_OK) croak("FATAL: hmac_memory failed: %s", error_to_string(rv));
219		outlen = sizeof(out);
220		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
221		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
222		RETVAL = newSVpvn((char *) out, outlen);
223		}
224		OUTPUT:
225		RETVAL

+74

-145

inc/CryptX_Mac_OMAC.xs.inc less more

43	43	RETVAL
44	44
45	45	void
46		_add_single(Crypt::Mac::OMAC self, SV * data)
47		CODE:
	46	add(Crypt::Mac::OMAC self, ...)
	47	PPCODE:
48	48	{
49		int rv;
	49	int rv, i;
50	50	STRLEN in_data_len;
51	51	unsigned char *in_data;
52	52
53		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
54		if (in_data_len>0) {
55		rv = omac_process(&self->state, in_data, (unsigned long)in_data_len);
56		if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv));
	53	for(i = 1; i < items; i++) {
	54	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	55	if (in_data_len > 0) {
	56	rv = omac_process(&self->state, in_data, (unsigned long)in_data_len);
	57	if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv));
	58	}
57	59	}
	60	XPUSHs(ST(0)); /* return self */
58	61	}
59	62
60	63	SV *
61	64	mac(Crypt::Mac::OMAC self)
62		CODE:
63		{
64		char mac[MAXBLOCKSIZE];
65		unsigned long maclen;
66		int rv;
67
68		maclen = sizeof(mac);
69		rv = omac_done(&self->state, (unsigned char*)mac, &maclen);
70		if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, maclen);
72		}
73		OUTPUT:
74		RETVAL
75
76		SV *
77		b64mac(Crypt::Mac::OMAC self)
78		CODE:
79		{
80		unsigned char mac[MAXBLOCKSIZE];
81		unsigned long maclen;
82		int rv;
83		unsigned long outlen;
84		char out[MAXBLOCKSIZE*2];
85
86		maclen = sizeof(mac);
87		rv = omac_done(&self->state, mac, &maclen);
88		if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(out);
90		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(out, outlen);
93		}
94		OUTPUT:
95		RETVAL
96
97		SV *
98		b64umac(Crypt::Mac::OMAC self)
99		CODE:
100		{
101		unsigned char mac[MAXBLOCKSIZE];
102		unsigned long maclen;
103		int rv;
104		unsigned long outlen;
105		char out[MAXBLOCKSIZE*2 + 1];
106
107		maclen = sizeof(mac);
108		rv = omac_done(&self->state, mac, &maclen);
109		if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(out);
111		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(out, outlen);
114		}
115		OUTPUT:
116		RETVAL
117
118		SV *
119		hexmac(Crypt::Mac::OMAC self)
	65	ALIAS:
	66	hexmac = 1
	67	b64mac = 2
	68	b64umac = 3
120	69	CODE:
121	70	{
122	71	unsigned char mac[MAXBLOCKSIZE];

128	77	rv = omac_done(&self->state, mac, &maclen);
129	78	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
130	79	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);
	80	if (ix == 3) {
	81	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	82	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	83	RETVAL = newSVpvn(out, outlen);
	84	}
	85	if (ix == 2) {
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	88	RETVAL = newSVpvn(out, outlen);
	89	}
	90	if (ix == 1) {
	91	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	92	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	93	RETVAL = newSVpvn(out, outlen);
	94	}
	95	else {
	96	RETVAL = newSVpvn(mac, maclen);
	97	}
134	98	}
135	99	OUTPUT:
136	100	RETVAL
137	101
138	102	SV *
139		omac(char * cipher_name, SV * key, SV * data)
	103	omac(char * cipher_name, SV * key, ...)
	104	ALIAS:
	105	omac_hex = 1
	106	omac_b64 = 2
	107	omac_b64u = 3
140	108	CODE:
141	109	{
142	110	STRLEN inlen, klen;
143		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	111	unsigned char *in;
144	112	unsigned char k = (unsigned char )SvPVbyte(key, klen);
145		int rv;
	113	int rv, i;
146	114	unsigned char mac[MAXBLOCKSIZE];
147		unsigned long len = sizeof(mac);
	115	unsigned long len = sizeof(mac), outlen;
	116	char out[MAXBLOCKSIZE*2];
	117	omac_state st;
	118
148	119	int id = _find_cipher(cipher_name);
149	120	if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
150		rv = omac_memory(id, k, klen, in, inlen, mac, &len);
151		if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv));
152		RETVAL = newSVpvn((char *) mac, len);
	121	rv = omac_init(&st, id, k, klen);
	122	if (rv != CRYPT_OK) croak("FATAL: omac_init failed: %s", error_to_string(rv));
	123	for (i = 2; i < items; i++) {
	124	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	125	if (inlen > 0) {
	126	rv = omac_process(&st, in, inlen);
	127	if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv));
	128	}
	129	}
	130	rv = omac_done(&st, mac, &len);
	131	if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
	132
	133	outlen = sizeof(out);
	134	if (ix == 3) {
	135	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 2) {
	140	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else if (ix == 1) {
	145	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	146	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	147	RETVAL = newSVpvn((char *) out, outlen);
	148	}
	149	else {
	150	RETVAL = newSVpvn((char *) mac, len);
	151	}
153	152	}
154	153	OUTPUT:
155	154	RETVAL
156
157		SV *
158		omac_hex(char * cipher_name, SV * key, SV * data)
159		CODE:
160		{
161		STRLEN inlen, klen;
162		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
163		unsigned char k = (unsigned char )SvPVbyte(key, klen);
164		int rv;
165		unsigned char mac[MAXBLOCKSIZE];
166		unsigned long len = sizeof(mac), outlen;
167		char out[MAXBLOCKSIZE*2];
168		int id = _find_cipher(cipher_name);
169		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
170		rv = omac_memory(id, k, klen, in, inlen, mac, &len);
171		if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv));
172		outlen = sizeof(out);
173		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
174		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
175		RETVAL = newSVpvn((char *) out, outlen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		omac_b64(char * cipher_name, SV * key, SV * data)
182		CODE:
183		{
184		STRLEN inlen, klen;
185		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
186		unsigned char k = (unsigned char )SvPVbyte(key, klen);
187		int rv;
188		unsigned char mac[MAXBLOCKSIZE];
189		unsigned long len = sizeof(mac), outlen;
190		char out[MAXBLOCKSIZE*2];
191		int id = _find_cipher(cipher_name);
192		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
193		rv = omac_memory(id, k, klen, in, inlen, mac, &len);
194		if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv));
195		outlen = sizeof(out);
196		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
197		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
198		RETVAL = newSVpvn((char *) out, outlen);
199
200		}
201		OUTPUT:
202		RETVAL
203
204		SV *
205		omac_b64u(char * cipher_name, SV * key, SV * data)
206		CODE:
207		{
208		STRLEN inlen, klen;
209		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
210		unsigned char k = (unsigned char )SvPVbyte(key, klen);
211		int rv;
212		unsigned char mac[MAXBLOCKSIZE];
213		unsigned long len = sizeof(mac), outlen;
214		char out[MAXBLOCKSIZE*2];
215		int id = _find_cipher(cipher_name);
216		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
217		rv = omac_memory(id, k, klen, in, inlen, mac, &len);
218		if (rv != CRYPT_OK) croak("FATAL: omac_memory failed: %s", error_to_string(rv));
219		outlen = sizeof(out);
220		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
221		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
222		RETVAL = newSVpvn((char *) out, outlen);
223		}
224		OUTPUT:
225		RETVAL

+74

-145

inc/CryptX_Mac_PMAC.xs.inc less more

43	43	RETVAL
44	44
45	45	void
46		_add_single(Crypt::Mac::PMAC self, SV * data)
47		CODE:
	46	add(Crypt::Mac::PMAC self, ...)
	47	PPCODE:
48	48	{
49		int rv;
	49	int rv, i;
50	50	STRLEN in_data_len;
51	51	unsigned char *in_data;
52	52
53		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
54		if (in_data_len>0) {
55		rv = pmac_process(&self->state, in_data, (unsigned long)in_data_len);
56		if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv));
	53	for(i = 1; i < items; i++) {
	54	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	55	if (in_data_len > 0) {
	56	rv = pmac_process(&self->state, in_data, (unsigned long)in_data_len);
	57	if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv));
	58	}
57	59	}
	60	XPUSHs(ST(0)); /* return self */
58	61	}
59	62
60	63	SV *
61	64	mac(Crypt::Mac::PMAC self)
62		CODE:
63		{
64		char mac[MAXBLOCKSIZE];
65		unsigned long maclen;
66		int rv;
67
68		maclen = sizeof(mac);
69		rv = pmac_done(&self->state, (unsigned char*)mac, &maclen);
70		if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, maclen);
72		}
73		OUTPUT:
74		RETVAL
75
76		SV *
77		b64mac(Crypt::Mac::PMAC self)
78		CODE:
79		{
80		unsigned char mac[MAXBLOCKSIZE];
81		unsigned long maclen;
82		int rv;
83		unsigned long outlen;
84		char out[MAXBLOCKSIZE*2];
85
86		maclen = sizeof(mac);
87		rv = pmac_done(&self->state, mac, &maclen);
88		if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
89		outlen = sizeof(out);
90		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(out, outlen);
93		}
94		OUTPUT:
95		RETVAL
96
97		SV *
98		b64umac(Crypt::Mac::PMAC self)
99		CODE:
100		{
101		unsigned char mac[MAXBLOCKSIZE];
102		unsigned long maclen;
103		int rv;
104		unsigned long outlen;
105		char out[MAXBLOCKSIZE*2 + 1];
106
107		maclen = sizeof(mac);
108		rv = pmac_done(&self->state, mac, &maclen);
109		if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
110		outlen = sizeof(out);
111		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(out, outlen);
114		}
115		OUTPUT:
116		RETVAL
117
118		SV *
119		hexmac(Crypt::Mac::PMAC self)
	65	ALIAS:
	66	hexmac = 1
	67	b64mac = 2
	68	b64umac = 3
120	69	CODE:
121	70	{
122	71	unsigned char mac[MAXBLOCKSIZE];

128	77	rv = pmac_done(&self->state, mac, &maclen);
129	78	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
130	79	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);
	80	if (ix == 3) {
	81	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	82	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	83	RETVAL = newSVpvn(out, outlen);
	84	}
	85	if (ix == 2) {
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	88	RETVAL = newSVpvn(out, outlen);
	89	}
	90	if (ix == 1) {
	91	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	92	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	93	RETVAL = newSVpvn(out, outlen);
	94	}
	95	else {
	96	RETVAL = newSVpvn(mac, maclen);
	97	}
134	98	}
135	99	OUTPUT:
136	100	RETVAL
137	101
138	102	SV *
139		pmac(char * cipher_name, SV * key, SV * data)
	103	pmac(char * cipher_name, SV * key, ...)
	104	ALIAS:
	105	pmac_hex = 1
	106	pmac_b64 = 2
	107	pmac_b64u = 3
140	108	CODE:
141	109	{
142	110	STRLEN inlen, klen;
143		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	111	unsigned char *in;
144	112	unsigned char k = (unsigned char )SvPVbyte(key, klen);
145		int rv;
	113	int rv, i;
146	114	unsigned char mac[MAXBLOCKSIZE];
147		unsigned long len = sizeof(mac);
	115	unsigned long len = sizeof(mac), outlen;
	116	char out[MAXBLOCKSIZE*2];
	117	pmac_state st;
	118
148	119	int id = _find_cipher(cipher_name);
149	120	if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
150		rv = pmac_memory(id, k, klen, in, inlen, mac, &len);
151		if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv));
152		RETVAL = newSVpvn((char *) mac, len);
	121	rv = pmac_init(&st, id, k, klen);
	122	if (rv != CRYPT_OK) croak("FATAL: pmac_init failed: %s", error_to_string(rv));
	123	for (i = 2; i < items; i++) {
	124	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	125	if (inlen > 0) {
	126	rv = pmac_process(&st, in, inlen);
	127	if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv));
	128	}
	129	}
	130	rv = pmac_done(&st, mac, &len);
	131	if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
	132
	133	outlen = sizeof(out);
	134	if (ix == 3) {
	135	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 2) {
	140	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else if (ix == 1) {
	145	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	146	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	147	RETVAL = newSVpvn((char *) out, outlen);
	148	}
	149	else {
	150	RETVAL = newSVpvn((char *) mac, len);
	151	}
153	152	}
154	153	OUTPUT:
155	154	RETVAL
156
157		SV *
158		pmac_hex(char * cipher_name, SV * key, SV * data)
159		CODE:
160		{
161		STRLEN inlen, klen;
162		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
163		unsigned char k = (unsigned char )SvPVbyte(key, klen);
164		int rv;
165		unsigned char mac[MAXBLOCKSIZE];
166		unsigned long len = sizeof(mac), outlen;
167		char out[MAXBLOCKSIZE*2];
168		int id = _find_cipher(cipher_name);
169		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
170		rv = pmac_memory(id, k, klen, in, inlen, mac, &len);
171		if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv));
172		outlen = sizeof(out);
173		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
174		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
175		RETVAL = newSVpvn((char *) out, outlen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		pmac_b64(char * cipher_name, SV * key, SV * data)
182		CODE:
183		{
184		STRLEN inlen, klen;
185		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
186		unsigned char k = (unsigned char )SvPVbyte(key, klen);
187		int rv;
188		unsigned char mac[MAXBLOCKSIZE];
189		unsigned long len = sizeof(mac), outlen;
190		char out[MAXBLOCKSIZE*2];
191		int id = _find_cipher(cipher_name);
192		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
193		rv = pmac_memory(id, k, klen, in, inlen, mac, &len);
194		if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv));
195		outlen = sizeof(out);
196		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
197		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
198		RETVAL = newSVpvn((char *) out, outlen);
199
200		}
201		OUTPUT:
202		RETVAL
203
204		SV *
205		pmac_b64u(char * cipher_name, SV * key, SV * data)
206		CODE:
207		{
208		STRLEN inlen, klen;
209		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
210		unsigned char k = (unsigned char )SvPVbyte(key, klen);
211		int rv;
212		unsigned char mac[MAXBLOCKSIZE];
213		unsigned long len = sizeof(mac), outlen;
214		char out[MAXBLOCKSIZE*2];
215		int id = _find_cipher(cipher_name);
216		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
217		rv = pmac_memory(id, k, klen, in, inlen, mac, &len);
218		if (rv != CRYPT_OK) croak("FATAL: pmac_memory failed: %s", error_to_string(rv));
219		outlen = sizeof(out);
220		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
221		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
222		RETVAL = newSVpvn((char *) out, outlen);
223		}
224		OUTPUT:
225		RETVAL

+74

-142

inc/CryptX_Mac_Pelican.xs.inc less more

39	39	RETVAL
40	40
41	41	void
42		_add_single(Crypt::Mac::Pelican self, SV * data)
43		CODE:
	42	add(Crypt::Mac::Pelican self, ...)
	43	PPCODE:
44	44	{
45		int rv;
	45	int rv, i;
46	46	STRLEN in_data_len;
47	47	unsigned char *in_data;
48	48
49		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
50		if (in_data_len>0) {
51		rv = pelican_process(&self->state, in_data, (unsigned long)in_data_len);
52		if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv));
	49	for(i = 1; i < items; i++) {
	50	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	51	if (in_data_len > 0) {
	52	rv = pelican_process(&self->state, in_data, (unsigned long)in_data_len);
	53	if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv));
	54	}
53	55	}
	56	XPUSHs(ST(0)); /* return self */
54	57	}
55	58
56	59	SV *
57	60	mac(Crypt::Mac::Pelican self)
58		CODE:
59		{
60		char mac[MAXBLOCKSIZE];
61		unsigned long maclen;
62		int rv;
63
64		maclen = 16;
65		rv = pelican_done(&self->state, (unsigned char*)mac);
66		if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, maclen);
68		}
69		OUTPUT:
70		RETVAL
71
72		SV *
73		b64mac(Crypt::Mac::Pelican self)
74		CODE:
75		{
76		unsigned char mac[MAXBLOCKSIZE];
77		unsigned long maclen;
78		int rv;
79		unsigned long outlen;
80		char out[MAXBLOCKSIZE*2];
81
82		maclen = 16;
83		rv = pelican_done(&self->state, mac);
84		if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
85		outlen = sizeof(out);
86		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(out, outlen);
89		}
90		OUTPUT:
91		RETVAL
92
93		SV *
94		b64umac(Crypt::Mac::Pelican self)
95		CODE:
96		{
97		unsigned char mac[MAXBLOCKSIZE];
98		unsigned long maclen;
99		int rv;
100		unsigned long outlen;
101		char out[MAXBLOCKSIZE*2 + 1];
102
103		maclen = 16;
104		rv = pelican_done(&self->state, mac);
105		if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
106		outlen = sizeof(out);
107		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(out, outlen);
110		}
111		OUTPUT:
112		RETVAL
113
114		SV *
115		hexmac(Crypt::Mac::Pelican self)
	61	ALIAS:
	62	hexmac = 1
	63	b64mac = 2
	64	b64umac = 3
116	65	CODE:
117	66	{
118	67	unsigned char mac[MAXBLOCKSIZE];

124	73	rv = pelican_done(&self->state, mac);
125	74	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
126	75	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);
	76	if (ix == 3) {
	77	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	78	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	79	RETVAL = newSVpvn(out, outlen);
	80	}
	81	if (ix == 2) {
	82	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	83	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	84	RETVAL = newSVpvn(out, outlen);
	85	}
	86	if (ix == 1) {
	87	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	88	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	89	RETVAL = newSVpvn(out, outlen);
	90	}
	91	else {
	92	RETVAL = newSVpvn(mac, maclen);
	93	}
130	94	}
131	95	OUTPUT:
132	96	RETVAL
133	97
134	98	SV *
135		pelican(SV * key, SV * data)
	99	pelican(SV * key, ...)
	100	ALIAS:
	101	pelican_hex = 1
	102	pelican_b64 = 2
	103	pelican_b64u = 3
136	104	CODE:
137	105	{
138	106	STRLEN inlen, klen;
139		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	107	unsigned char *in;
140	108	unsigned char k = (unsigned char )SvPVbyte(key, klen);
141		int rv;
	109	int rv, i;
142	110	unsigned char mac[MAXBLOCKSIZE];
143		unsigned long len = sizeof(mac);
	111	unsigned long len = sizeof(mac), outlen;
	112	char out[MAXBLOCKSIZE*2];
	113	pelican_state st;
	114
144	115	len = 16;
145		rv = pelican_memory(k, klen, in, inlen, mac);
146		if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv));
147		RETVAL = newSVpvn((char *) mac, len);
	116	rv = pelican_init(&st, k, klen);
	117	if (rv != CRYPT_OK) croak("FATAL: pelican_init failed: %s", error_to_string(rv));
	118	for (i = 1; i < items; i++) {
	119	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	120	if (inlen > 0) {
	121	rv = pelican_process(&st, in, inlen);
	122	if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv));
	123	}
	124	}
	125	rv = pelican_done(&st, mac);
	126	if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
	127
	128	outlen = sizeof(out);
	129	if (ix == 3) {
	130	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	131	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	132	RETVAL = newSVpvn((char *) out, outlen);
	133	}
	134	else if (ix == 2) {
	135	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 1) {
	140	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else {
	145	RETVAL = newSVpvn((char *) mac, len);
	146	}
148	147	}
149	148	OUTPUT:
150	149	RETVAL
151
152		SV *
153		pelican_hex(SV * key, SV * data)
154		CODE:
155		{
156		STRLEN inlen, klen;
157		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
158		unsigned char k = (unsigned char )SvPVbyte(key, klen);
159		int rv;
160		unsigned char mac[MAXBLOCKSIZE];
161		unsigned long len = sizeof(mac), outlen;
162		char out[MAXBLOCKSIZE*2];
163		len = 16;
164		rv = pelican_memory(k, klen, in, inlen, mac);
165		if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv));
166		outlen = sizeof(out);
167		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
168		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
169		RETVAL = newSVpvn((char *) out, outlen);
170		}
171		OUTPUT:
172		RETVAL
173
174		SV *
175		pelican_b64(SV * key, SV * data)
176		CODE:
177		{
178		STRLEN inlen, klen;
179		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
180		unsigned char k = (unsigned char )SvPVbyte(key, klen);
181		int rv;
182		unsigned char mac[MAXBLOCKSIZE];
183		unsigned long len = sizeof(mac), outlen;
184		char out[MAXBLOCKSIZE*2];
185		len = 16;
186		rv = pelican_memory(k, klen, in, inlen, mac);
187		if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv));
188		outlen = sizeof(out);
189		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
190		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
191		RETVAL = newSVpvn((char *) out, outlen);
192
193		}
194		OUTPUT:
195		RETVAL
196
197		SV *
198		pelican_b64u(SV * key, SV * data)
199		CODE:
200		{
201		STRLEN inlen, klen;
202		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
203		unsigned char k = (unsigned char )SvPVbyte(key, klen);
204		int rv;
205		unsigned char mac[MAXBLOCKSIZE];
206		unsigned long len = sizeof(mac), outlen;
207		char out[MAXBLOCKSIZE*2];
208		len = 16;
209		rv = pelican_memory(k, klen, in, inlen, mac);
210		if (rv != CRYPT_OK) croak("FATAL: pelican_memory failed: %s", error_to_string(rv));
211		outlen = sizeof(out);
212		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
213		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
214		RETVAL = newSVpvn((char *) out, outlen);
215		}
216		OUTPUT:
217		RETVAL

+74

-139

inc/CryptX_Mac_Poly1305.xs.inc less more

39	39	RETVAL
40	40
41	41	void
42		_add_single(Crypt::Mac::Poly1305 self, SV * data)
43		CODE:
	42	add(Crypt::Mac::Poly1305 self, ...)
	43	PPCODE:
44	44	{
45		int rv;
	45	int rv, i;
46	46	STRLEN in_data_len;
47	47	unsigned char *in_data;
48	48
49		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
50		if (in_data_len>0) {
51		rv = poly1305_process(&self->state, in_data, (unsigned long)in_data_len);
52		if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv));
	49	for(i = 1; i < items; i++) {
	50	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	51	if (in_data_len > 0) {
	52	rv = poly1305_process(&self->state, in_data, (unsigned long)in_data_len);
	53	if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv));
	54	}
53	55	}
	56	XPUSHs(ST(0)); /* return self */
54	57	}
55	58
56	59	SV *
57	60	mac(Crypt::Mac::Poly1305 self)
58		CODE:
59		{
60		char mac[MAXBLOCKSIZE];
61		unsigned long maclen;
62		int rv;
63
64		maclen = sizeof(mac);
65		rv = poly1305_done(&self->state, (unsigned char*)mac, &maclen);
66		if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
67		RETVAL = newSVpvn(mac, maclen);
68		}
69		OUTPUT:
70		RETVAL
71
72		SV *
73		b64mac(Crypt::Mac::Poly1305 self)
74		CODE:
75		{
76		unsigned char mac[MAXBLOCKSIZE];
77		unsigned long maclen;
78		int rv;
79		unsigned long outlen;
80		char out[MAXBLOCKSIZE*2];
81
82		maclen = sizeof(mac);
83		rv = poly1305_done(&self->state, mac, &maclen);
84		if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
85		outlen = sizeof(out);
86		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
87		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
88		RETVAL = newSVpvn(out, outlen);
89		}
90		OUTPUT:
91		RETVAL
92
93		SV *
94		b64umac(Crypt::Mac::Poly1305 self)
95		CODE:
96		{
97		unsigned char mac[MAXBLOCKSIZE];
98		unsigned long maclen;
99		int rv;
100		unsigned long outlen;
101		char out[MAXBLOCKSIZE*2 + 1];
102
103		maclen = sizeof(mac);
104		rv = poly1305_done(&self->state, mac, &maclen);
105		if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
106		outlen = sizeof(out);
107		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
108		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
109		RETVAL = newSVpvn(out, outlen);
110		}
111		OUTPUT:
112		RETVAL
113
114		SV *
115		hexmac(Crypt::Mac::Poly1305 self)
	61	ALIAS:
	62	hexmac = 1
	63	b64mac = 2
	64	b64umac = 3
116	65	CODE:
117	66	{
118	67	unsigned char mac[MAXBLOCKSIZE];

124	73	rv = poly1305_done(&self->state, mac, &maclen);
125	74	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
126	75	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);
	76	if (ix == 3) {
	77	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	78	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	79	RETVAL = newSVpvn(out, outlen);
	80	}
	81	if (ix == 2) {
	82	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	83	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	84	RETVAL = newSVpvn(out, outlen);
	85	}
	86	if (ix == 1) {
	87	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	88	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	89	RETVAL = newSVpvn(out, outlen);
	90	}
	91	else {
	92	RETVAL = newSVpvn(mac, maclen);
	93	}
130	94	}
131	95	OUTPUT:
132	96	RETVAL
133	97
134	98	SV *
135		poly1305(SV * key, SV * data)
	99	poly1305(SV * key, ...)
	100	ALIAS:
	101	poly1305_hex = 1
	102	poly1305_b64 = 2
	103	poly1305_b64u = 3
136	104	CODE:
137	105	{
138	106	STRLEN inlen, klen;
139		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	107	unsigned char *in;
140	108	unsigned char k = (unsigned char )SvPVbyte(key, klen);
141		int rv;
	109	int rv, i;
142	110	unsigned char mac[MAXBLOCKSIZE];
143		unsigned long len = sizeof(mac);
144		rv = poly1305_memory(k, klen, in, inlen, mac, &len);
145		if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv));
146		RETVAL = newSVpvn((char *) mac, len);
	111	unsigned long len = sizeof(mac), outlen;
	112	char out[MAXBLOCKSIZE*2];
	113	poly1305_state st;
	114
	115	rv = poly1305_init(&st, k, klen);
	116	if (rv != CRYPT_OK) croak("FATAL: poly1305_init failed: %s", error_to_string(rv));
	117	for (i = 1; i < items; i++) {
	118	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	119	if (inlen > 0) {
	120	rv = poly1305_process(&st, in, inlen);
	121	if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv));
	122	}
	123	}
	124	rv = poly1305_done(&st, mac, &len);
	125	if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
	126
	127	outlen = sizeof(out);
	128	if (ix == 3) {
	129	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	130	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	131	RETVAL = newSVpvn((char *) out, outlen);
	132	}
	133	else if (ix == 2) {
	134	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	135	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	136	RETVAL = newSVpvn((char *) out, outlen);
	137	}
	138	else if (ix == 1) {
	139	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	140	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	141	RETVAL = newSVpvn((char *) out, outlen);
	142	}
	143	else {
	144	RETVAL = newSVpvn((char *) mac, len);
	145	}
147	146	}
148	147	OUTPUT:
149	148	RETVAL
150
151		SV *
152		poly1305_hex(SV * key, SV * data)
153		CODE:
154		{
155		STRLEN inlen, klen;
156		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
157		unsigned char k = (unsigned char )SvPVbyte(key, klen);
158		int rv;
159		unsigned char mac[MAXBLOCKSIZE];
160		unsigned long len = sizeof(mac), outlen;
161		char out[MAXBLOCKSIZE*2];
162		rv = poly1305_memory(k, klen, in, inlen, mac, &len);
163		if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv));
164		outlen = sizeof(out);
165		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
166		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
167		RETVAL = newSVpvn((char *) out, outlen);
168		}
169		OUTPUT:
170		RETVAL
171
172		SV *
173		poly1305_b64(SV * key, SV * data)
174		CODE:
175		{
176		STRLEN inlen, klen;
177		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
178		unsigned char k = (unsigned char )SvPVbyte(key, klen);
179		int rv;
180		unsigned char mac[MAXBLOCKSIZE];
181		unsigned long len = sizeof(mac), outlen;
182		char out[MAXBLOCKSIZE*2];
183		rv = poly1305_memory(k, klen, in, inlen, mac, &len);
184		if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv));
185		outlen = sizeof(out);
186		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
187		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
188		RETVAL = newSVpvn((char *) out, outlen);
189
190		}
191		OUTPUT:
192		RETVAL
193
194		SV *
195		poly1305_b64u(SV * key, SV * data)
196		CODE:
197		{
198		STRLEN inlen, klen;
199		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
200		unsigned char k = (unsigned char )SvPVbyte(key, klen);
201		int rv;
202		unsigned char mac[MAXBLOCKSIZE];
203		unsigned long len = sizeof(mac), outlen;
204		char out[MAXBLOCKSIZE*2];
205		rv = poly1305_memory(k, klen, in, inlen, mac, &len);
206		if (rv != CRYPT_OK) croak("FATAL: poly1305_memory failed: %s", error_to_string(rv));
207		outlen = sizeof(out);
208		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
209		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
210		RETVAL = newSVpvn((char *) out, outlen);
211		}
212		OUTPUT:
213		RETVAL

+74

-145

inc/CryptX_Mac_XCBC.xs.inc less more

43	43	RETVAL
44	44
45	45	void
46		_add_single(Crypt::Mac::XCBC self, SV * data)
47		CODE:
	46	add(Crypt::Mac::XCBC self, ...)
	47	PPCODE:
48	48	{
49		int rv;
	49	int rv, i;
50	50	STRLEN in_data_len;
51	51	unsigned char *in_data;
52	52
53		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
54		if (in_data_len>0) {
55		rv = xcbc_process(&self->state, in_data, (unsigned long)in_data_len);
56		if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv));
	53	for(i = 1; i < items; i++) {
	54	in_data = (unsigned char *)SvPVbyte(ST(i), in_data_len);
	55	if (in_data_len > 0) {
	56	rv = xcbc_process(&self->state, in_data, (unsigned long)in_data_len);
	57	if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv));
	58	}
57	59	}
	60	XPUSHs(ST(0)); /* return self */
58	61	}
59	62
60	63	SV *
61	64	mac(Crypt::Mac::XCBC self)
62		CODE:
63		{
64		char mac[MAXBLOCKSIZE];
65		unsigned long maclen;
66		int rv;
67
68		maclen = sizeof(mac);
69		rv = xcbc_done(&self->state, (unsigned char*)mac, &maclen);
70		if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
71		RETVAL = newSVpvn(mac, maclen);
72		}
73		OUTPUT:
74		RETVAL
75
76		SV *
77		b64mac(Crypt::Mac::XCBC self)
78		CODE:
79		{
80		unsigned char mac[MAXBLOCKSIZE];
81		unsigned long maclen;
82		int rv;
83		unsigned long outlen;
84		char out[MAXBLOCKSIZE*2];
85
86		maclen = sizeof(mac);
87		rv = xcbc_done(&self->state, mac, &maclen);
88		if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
89		outlen = sizeof(out);
90		rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
91		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
92		RETVAL = newSVpvn(out, outlen);
93		}
94		OUTPUT:
95		RETVAL
96
97		SV *
98		b64umac(Crypt::Mac::XCBC self)
99		CODE:
100		{
101		unsigned char mac[MAXBLOCKSIZE];
102		unsigned long maclen;
103		int rv;
104		unsigned long outlen;
105		char out[MAXBLOCKSIZE*2 + 1];
106
107		maclen = sizeof(mac);
108		rv = xcbc_done(&self->state, mac, &maclen);
109		if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
110		outlen = sizeof(out);
111		rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
112		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
113		RETVAL = newSVpvn(out, outlen);
114		}
115		OUTPUT:
116		RETVAL
117
118		SV *
119		hexmac(Crypt::Mac::XCBC self)
	65	ALIAS:
	66	hexmac = 1
	67	b64mac = 2
	68	b64umac = 3
120	69	CODE:
121	70	{
122	71	unsigned char mac[MAXBLOCKSIZE];

128	77	rv = xcbc_done(&self->state, mac, &maclen);
129	78	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
130	79	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);
	80	if (ix == 3) {
	81	rv = base64url_encode(mac, maclen, (unsigned char*)out, &outlen);
	82	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	83	RETVAL = newSVpvn(out, outlen);
	84	}
	85	if (ix == 2) {
	86	rv = base64_encode(mac, maclen, (unsigned char*)out, &outlen);
	87	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	88	RETVAL = newSVpvn(out, outlen);
	89	}
	90	if (ix == 1) {
	91	rv = _base16_encode(mac, maclen, (unsigned char *)out, &outlen);
	92	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	93	RETVAL = newSVpvn(out, outlen);
	94	}
	95	else {
	96	RETVAL = newSVpvn(mac, maclen);
	97	}
134	98	}
135	99	OUTPUT:
136	100	RETVAL
137	101
138	102	SV *
139		xcbc(char * cipher_name, SV * key, SV * data)
	103	xcbc(char * cipher_name, SV * key, ...)
	104	ALIAS:
	105	xcbc_hex = 1
	106	xcbc_b64 = 2
	107	xcbc_b64u = 3
140	108	CODE:
141	109	{
142	110	STRLEN inlen, klen;
143		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
	111	unsigned char *in;
144	112	unsigned char k = (unsigned char )SvPVbyte(key, klen);
145		int rv;
	113	int rv, i;
146	114	unsigned char mac[MAXBLOCKSIZE];
147		unsigned long len = sizeof(mac);
	115	unsigned long len = sizeof(mac), outlen;
	116	char out[MAXBLOCKSIZE*2];
	117	xcbc_state st;
	118
148	119	int id = _find_cipher(cipher_name);
149	120	if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
150		rv = xcbc_memory(id, k, klen, in, inlen, mac, &len);
151		if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv));
152		RETVAL = newSVpvn((char *) mac, len);
	121	rv = xcbc_init(&st, id, k, klen);
	122	if (rv != CRYPT_OK) croak("FATAL: xcbc_init failed: %s", error_to_string(rv));
	123	for (i = 2; i < items; i++) {
	124	in = (unsigned char *)SvPVbyte(ST(i), inlen);
	125	if (inlen > 0) {
	126	rv = xcbc_process(&st, in, inlen);
	127	if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv));
	128	}
	129	}
	130	rv = xcbc_done(&st, mac, &len);
	131	if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
	132
	133	outlen = sizeof(out);
	134	if (ix == 3) {
	135	rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
	136	if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
	137	RETVAL = newSVpvn((char *) out, outlen);
	138	}
	139	else if (ix == 2) {
	140	rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
	141	if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
	142	RETVAL = newSVpvn((char *) out, outlen);
	143	}
	144	else if (ix == 1) {
	145	rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
	146	if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
	147	RETVAL = newSVpvn((char *) out, outlen);
	148	}
	149	else {
	150	RETVAL = newSVpvn((char *) mac, len);
	151	}
153	152	}
154	153	OUTPUT:
155	154	RETVAL
156
157		SV *
158		xcbc_hex(char * cipher_name, SV * key, SV * data)
159		CODE:
160		{
161		STRLEN inlen, klen;
162		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
163		unsigned char k = (unsigned char )SvPVbyte(key, klen);
164		int rv;
165		unsigned char mac[MAXBLOCKSIZE];
166		unsigned long len = sizeof(mac), outlen;
167		char out[MAXBLOCKSIZE*2];
168		int id = _find_cipher(cipher_name);
169		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
170		rv = xcbc_memory(id, k, klen, in, inlen, mac, &len);
171		if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv));
172		outlen = sizeof(out);
173		rv = _base16_encode(mac, len, (unsigned char *)out, &outlen);
174		if (rv != CRYPT_OK) croak("FATAL: base16_encode failed: %s", error_to_string(rv));
175		RETVAL = newSVpvn((char *) out, outlen);
176		}
177		OUTPUT:
178		RETVAL
179
180		SV *
181		xcbc_b64(char * cipher_name, SV * key, SV * data)
182		CODE:
183		{
184		STRLEN inlen, klen;
185		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
186		unsigned char k = (unsigned char )SvPVbyte(key, klen);
187		int rv;
188		unsigned char mac[MAXBLOCKSIZE];
189		unsigned long len = sizeof(mac), outlen;
190		char out[MAXBLOCKSIZE*2];
191		int id = _find_cipher(cipher_name);
192		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
193		rv = xcbc_memory(id, k, klen, in, inlen, mac, &len);
194		if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv));
195		outlen = sizeof(out);
196		rv = base64_encode(mac, len, (unsigned char *)out, &outlen);
197		if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
198		RETVAL = newSVpvn((char *) out, outlen);
199
200		}
201		OUTPUT:
202		RETVAL
203
204		SV *
205		xcbc_b64u(char * cipher_name, SV * key, SV * data)
206		CODE:
207		{
208		STRLEN inlen, klen;
209		unsigned char in = (unsigned char )SvPVbyte(data, inlen);
210		unsigned char k = (unsigned char )SvPVbyte(key, klen);
211		int rv;
212		unsigned char mac[MAXBLOCKSIZE];
213		unsigned long len = sizeof(mac), outlen;
214		char out[MAXBLOCKSIZE*2];
215		int id = _find_cipher(cipher_name);
216		if (id == -1) croak("FATAL: find_cipher failed for '%s'", cipher_name);
217		rv = xcbc_memory(id, k, klen, in, inlen, mac, &len);
218		if (rv != CRYPT_OK) croak("FATAL: xcbc_memory failed: %s", error_to_string(rv));
219		outlen = sizeof(out);
220		rv = base64url_encode(mac, len, (unsigned char *)out, &outlen);
221		if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
222		RETVAL = newSVpvn((char *) out, outlen);
223		}
224		OUTPUT:
225		RETVAL

+182

-207

inc/CryptX_Mode_CBC.xs.inc less more

25	25	CODE:
26	26	Safefree(self);
27	27
28		int
29		_get_dir(Crypt::Mode::CBC self)
30		CODE:
31		RETVAL = self->direction;
32		OUTPUT:
33		RETVAL
34
35	28	void
36		_start(Crypt::Mode::CBC self, int dir, SV * key, SV * iv)
37		CODE:
	29	_start(Crypt::Mode::CBC self, SV * key, SV * iv)
	30	ALIAS:
	31	start_encrypt = 1
	32	start_decrypt = 2
	33	PPCODE:
38	34	{
39	35	int rv;
40	36	STRLEN k_len=0;

55	51	croak("FATAL: cbc_start failed: %s", error_to_string(rv));
56	52	}
57	53
58		self->direction = dir;
	54	self->direction = ix == 1 ? 1 : -1;
59	55	self->padlen = 0;
	56	XPUSHs(ST(0)); /* return self */
60	57	}
61	58
62	59	SV *
63		_encrypt(Crypt::Mode::CBC self, SV * data)
64		CODE:
65		{
66		int rv, has_tmp_block, blen;
67		unsigned long i;
68
69		STRLEN in_data_len, in_data_start;
70		unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
71
72		if (self->direction != 1) croak("FATAL: encrypt error, call start_encrypt first (%d)", self->direction);
73
74		blen = (&self->state)->blocklen;
75		in_data_start = 0;
76		has_tmp_block = 0;
77		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
78		if (in_data_len == 0) {
79		RETVAL = newSVpvn("", 0);
80		}
81		else {
82		if (self->padlen > 0) {
83		i = (blen - self->padlen);
84		if (in_data_len >= i) { /* enough data to fill pad */
85		Copy(in_data, self->pad+self->padlen, i, unsigned char);
86		in_data_len -= i;
87		in_data_start = i;
88		rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
89		if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
90		self->padlen = 0;
91		has_tmp_block = 1;
92		}
93		else { /* not enough data to fill pad */
94		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
95		self->padlen += (int)in_data_len;
96		in_data_len = 0;
97		}
98		} /* padlen > 0 */
99
100		i = (unsigned long)(in_data_len % blen);
101		if (in_data_len>0 && i>0) { /* save tail of data into pad */
102		Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
103		self->padlen = i;
104		in_data_len -= i;
105		}
106
107		if (in_data_len > 0) {
108		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
109		RETVAL = NEWSV(0, i);
110		SvPOK_only(RETVAL);
111		SvCUR_set(RETVAL, i);
112		out_data = (unsigned char *)SvPVX(RETVAL);
113		if (has_tmp_block) {
114		Copy(tmp_block, out_data, blen, unsigned char);
115		out_data += blen;
116		}
117		rv = cbc_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
118		if (rv != CRYPT_OK) {
119		SvREFCNT_dec(RETVAL);
120		croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
121		}
122		} /* in_data_len>0 */
123		else if (has_tmp_block) {
124		RETVAL = newSVpvn((char*)tmp_block, blen);
125		}
126		else {
127		RETVAL = newSVpvn("", 0);
128		}
129		}
130		}
131		OUTPUT:
132		RETVAL
133
134		SV *
135		_finish_enc(Crypt::Mode::CBC self)
136		CODE:
137		{
138		unsigned char tmp_block[MAXBLOCKSIZE];
139		int rv, blen, i, j;
140
141		blen = (&self->state)->blocklen;
142		if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
143
144		if (self->padding_mode == 1) { /* pkcs5\|7 padding */
145		i = blen - self->padlen;
146		if (i == 0) i = blen;
147		for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
148		rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
149		if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
150		}
151		else if (self->padding_mode == 2) { /* oneandzeroes padding */
152		self->pad[self->padlen] = 0x80;
153		for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
154		rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
155		if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
156		}
157		else {
158		if (self->padlen>0) croak("FATAL: cbc_encrypt, input data length not multiple of %d", blen);
159		blen = 0;
160		}
161
162		self->direction = 0;
163		RETVAL = newSVpvn((char*)tmp_block, blen);
164		}
165		OUTPUT:
166		RETVAL
167
168		SV *
169		_decrypt(Crypt::Mode::CBC self, SV * data)
	60	_crypt(Crypt::Mode::CBC self, SV * data)
170	61	CODE:
171	62	{
172	63	int rv, has_tmp_block, blen;

174	65	STRLEN in_data_len, in_data_start;
175	66	unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
176	67
177		if (self->direction != -1) croak("FATAL: decrypt error, call start_decryt first (%d)", self->direction);
178
179		blen = (&self->state)->blocklen;
180		in_data_start = 0;
181		has_tmp_block = 0;
182		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
183		if (in_data_len == 0) {
184		RETVAL = newSVpvn("", 0);
185		}
186		else {
187
188		if (self->padlen == blen) {
189		rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
190		if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
191		self->padlen = 0;
192		has_tmp_block = 1;
193		} /* padlen == blen */
194		else if (self->padlen > 0) {
195		i = (blen - self->padlen); /* remaining bytes in padding buffer */
196		if (in_data_len >= i) { /* enough data to fill pad */
197		Copy(in_data, self->pad+self->padlen, i, unsigned char);
198		self->padlen += i;
199		in_data_len -= i;
200		in_data_start = i;
201		if (in_data_len>0 \|\| self->padding_mode == 0) {
202		rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
203		if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	68	if (self->direction == 1) {
	69	blen = (&self->state)->blocklen;
	70	in_data_start = 0;
	71	has_tmp_block = 0;
	72	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	73	if (in_data_len == 0) {
	74	RETVAL = newSVpvn("", 0);
	75	}
	76	else {
	77	if (self->padlen > 0) {
	78	i = (blen - self->padlen);
	79	if (in_data_len >= i) { /* enough data to fill pad */
	80	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	81	in_data_len -= i;
	82	in_data_start = i;
	83	rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
	84	if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
204	85	self->padlen = 0;
205	86	has_tmp_block = 1;
206	87	}
207		}
208		else { /* not enough data to fill pad */
209		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
210		self->padlen += (int)in_data_len;
211		in_data_len = 0;
212		}
213		} /* padlen > 0 */
214
215		/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
216		if (in_data_len>0) {
	88	else { /* not enough data to fill pad */
	89	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	90	self->padlen += (int)in_data_len;
	91	in_data_len = 0;
	92	}
	93	} /* padlen > 0 */
	94
217	95	i = (unsigned long)(in_data_len % blen);
218		if (i>0) { /* save tail of data into pad */
	96	if (in_data_len>0 && i>0) { /* save tail of data into pad */
219	97	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
220	98	self->padlen = i;
221	99	in_data_len -= i;
222	100	}
223		}
224
225		if (in_data_len>0) {
226		if (self->padlen == 0 && self->padding_mode !=0) {
227		/* in case of padding keep full pad if no more data */
228		Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
229		self->padlen = blen;
230		in_data_len -= blen;
231		}
232		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
233		if (i == 0) {
234		RETVAL = newSVpvn("", 0);
235		}
236		else {
	101
	102	if (in_data_len > 0) {
	103	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
237	104	RETVAL = NEWSV(0, i);
238	105	SvPOK_only(RETVAL);
239	106	SvCUR_set(RETVAL, i);

242	109	Copy(tmp_block, out_data, blen, unsigned char);
243	110	out_data += blen;
244	111	}
245		rv = cbc_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	112	rv = cbc_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
246	113	if (rv != CRYPT_OK) {
247	114	SvREFCNT_dec(RETVAL);
248		croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
249		}
250		}
251		} /* in_data_len>0 */
252		else if (has_tmp_block) {
253		RETVAL = newSVpvn((char*)tmp_block, blen);
254		}
255		else {
	115	croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
	116	}
	117	} /* in_data_len>0 */
	118	else if (has_tmp_block) {
	119	RETVAL = newSVpvn((char*)tmp_block, blen);
	120	}
	121	else {
	122	RETVAL = newSVpvn("", 0);
	123	}
	124	}
	125	}
	126	else if (self->direction == -1) {
	127	blen = (&self->state)->blocklen;
	128	in_data_start = 0;
	129	has_tmp_block = 0;
	130	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	131	if (in_data_len == 0) {
256	132	RETVAL = newSVpvn("", 0);
257	133	}
258		}
259
	134	else {
	135
	136	if (self->padlen == blen) {
	137	rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
	138	if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	139	self->padlen = 0;
	140	has_tmp_block = 1;
	141	} /* padlen == blen */
	142	else if (self->padlen > 0) {
	143	i = (blen - self->padlen); /* remaining bytes in padding buffer */
	144	if (in_data_len >= i) { /* enough data to fill pad */
	145	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	146	self->padlen += i;
	147	in_data_len -= i;
	148	in_data_start = i;
	149	if (in_data_len>0 \|\| self->padding_mode == 0) {
	150	rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
	151	if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	152	self->padlen = 0;
	153	has_tmp_block = 1;
	154	}
	155	}
	156	else { /* not enough data to fill pad */
	157	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	158	self->padlen += (int)in_data_len;
	159	in_data_len = 0;
	160	}
	161	} /* padlen > 0 */
	162
	163	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
	164	if (in_data_len>0) {
	165	i = (unsigned long)(in_data_len % blen);
	166	if (i>0) { /* save tail of data into pad */
	167	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
	168	self->padlen = i;
	169	in_data_len -= i;
	170	}
	171	}
	172
	173	if (in_data_len>0) {
	174	if (self->padlen == 0 && self->padding_mode !=0) {
	175	/* in case of padding keep full pad if no more data */
	176	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
	177	self->padlen = blen;
	178	in_data_len -= blen;
	179	}
	180	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
	181	if (i == 0) {
	182	RETVAL = newSVpvn("", 0);
	183	}
	184	else {
	185	RETVAL = NEWSV(0, i);
	186	SvPOK_only(RETVAL);
	187	SvCUR_set(RETVAL, i);
	188	out_data = (unsigned char *)SvPVX(RETVAL);
	189	if (has_tmp_block) {
	190	Copy(tmp_block, out_data, blen, unsigned char);
	191	out_data += blen;
	192	}
	193	rv = cbc_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	194	if (rv != CRYPT_OK) {
	195	SvREFCNT_dec(RETVAL);
	196	croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	197	}
	198	}
	199	} /* in_data_len>0 */
	200	else if (has_tmp_block) {
	201	RETVAL = newSVpvn((char*)tmp_block, blen);
	202	}
	203	else {
	204	RETVAL = newSVpvn("", 0);
	205	}
	206	}
	207	}
	208	else {
	209	croak("FATAL: call start_decryt or start_encrpyt first (%d)", self->direction);
	210	}
260	211	}
261	212	OUTPUT:
262	213	RETVAL
263	214
264	215	SV *
265		_finish_dec(Crypt::Mode::CBC self)
266		CODE:
267		{
268		unsigned char tmp_block[MAXBLOCKSIZE];
269		unsigned char i;
270		int rv, rv_len, blen;
271
272		rv_len = 0;
273		if (self->padlen > 0) {
274		blen = (&self->state)->blocklen;
275		if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
276		rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
277		if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
278		if (self->padding_mode == 0) { /* no padding */
279		rv_len = blen;
280		}
281		else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
282		i = tmp_block[blen-1];
283		rv_len = blen - (i>blen ? blen : i);
284		}
285		else if (self->padding_mode == 2) { /* oneandzeroes padding */
286		rv_len = blen;
287		while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
288		if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;
289		if (rv_len<0) rv_len = 0;
290		}
	216	finish(Crypt::Mode::CBC self)
	217	CODE:
	218	{
	219	unsigned char tmp_block[MAXBLOCKSIZE], ch;
	220	int i, j, rv, blen = (&self->state)->blocklen;
	221
	222	if (self->direction == 1) {
	223	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
	224	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	225	i = blen - self->padlen;
	226	if (i == 0) i = blen;
	227	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
	228	rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
	229	if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
	230	}
	231	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	232	self->pad[self->padlen] = 0x80;
	233	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
	234	rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
	235	if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
	236	}
	237	else {
	238	if (self->padlen>0) croak("FATAL: cbc_encrypt, input data length not multiple of %d", blen);
	239	blen = 0;
	240	}
	241	}
	242	else if (self->direction == -1) {
	243	if (self->padlen > 0) {
	244	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
	245	rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
	246	if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
	247	if (self->padding_mode == 0) { /* no padding */
	248	/* we already have blen */
	249	}
	250	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	251	ch = tmp_block[blen-1];
	252	blen = blen - (ch > blen ? blen : ch);
	253	}
	254	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	255	while ((unsigned char)tmp_block[blen - 1] == 0x00) blen--;
	256	if ((unsigned char)tmp_block[blen - 1] == 0x80) blen--;
	257	if (blen < 0) blen = 0;
	258	}
	259	}
	260	else {
	261	blen = 0;
	262	}
	263	}
	264	else {
	265	XSRETURN_UNDEF;
291	266	}
292	267
293	268	self->direction = 0;
294		RETVAL = newSVpvn((char*)tmp_block, rv_len);
	269	RETVAL = newSVpvn((char*)tmp_block, blen);
295	270	}
296	271	OUTPUT:
297	272	RETVAL

+8

-11

inc/CryptX_Mode_CFB.xs.inc less more

23	23	CODE:
24	24	Safefree(self);
25	25
26		int
27		_get_dir(Crypt::Mode::CFB self)
28		CODE:
29		RETVAL = self->direction;
30		OUTPUT:
31		RETVAL
32
33	26	void
34		_start(Crypt::Mode::CFB self, int dir, SV * key, SV * iv)
35		CODE:
	27	_start(Crypt::Mode::CFB self, SV * key, SV * iv)
	28	ALIAS:
	29	start_encrypt = 1
	30	start_decrypt = 2
	31	PPCODE:
36	32	{
37	33	STRLEN k_len=0;
38	34	unsigned char *k=NULL;

54	50	croak("FATAL: cfb_start failed: %s", error_to_string(rv));
55	51	}
56	52
57		self->direction = dir;
	53	self->direction = ix == 1 ? 1 : -1;
	54	XPUSHs(ST(0)); /* return self */
58	55	}
59	56
60	57	SV *

99	96	RETVAL
100	97
101	98	SV *
102		_finish(Crypt::Mode::CFB self)
	99	finish(Crypt::Mode::CFB self)
103	100	CODE:
104	101	self->direction = 0;
105	102	RETVAL = newSVpvn("", 0);

+8

-11

inc/CryptX_Mode_CTR.xs.inc less more

28	28	CODE:
29	29	Safefree(self);
30	30
31		int
32		_get_dir(Crypt::Mode::CTR self)
33		CODE:
34		RETVAL = self->direction;
35		OUTPUT:
36		RETVAL
37
38	31	void
39		_start(Crypt::Mode::CTR self, int dir, SV * key, SV * iv)
40		CODE:
	32	_start(Crypt::Mode::CTR self, SV * key, SV * iv)
	33	ALIAS:
	34	start_encrypt = 1
	35	start_decrypt = 2
	36	PPCODE:
41	37	{
42	38	STRLEN k_len=0;
43	39	unsigned char *k=NULL;

59	55	croak("FATAL: ctr_start failed: %s", error_to_string(rv));
60	56	}
61	57
62		self->direction = dir;
	58	self->direction = ix == 1 ? 1 : -1;
	59	XPUSHs(ST(0)); /* return self */
63	60	}
64	61
65	62	SV *

104	101	RETVAL
105	102
106	103	SV *
107		_finish(Crypt::Mode::CTR self)
	104	finish(Crypt::Mode::CTR self)
108	105	CODE:
109	106	self->direction = 0;
110	107	RETVAL = newSVpvn("", 0);

+182

-207

inc/CryptX_Mode_ECB.xs.inc less more

25	25	CODE:
26	26	Safefree(self);
27	27
28		int
29		_get_dir(Crypt::Mode::ECB self)
30		CODE:
31		RETVAL = self->direction;
32		OUTPUT:
33		RETVAL
34
35	28	void
36		_start(Crypt::Mode::ECB self, int dir, SV * key)
37		CODE:
	29	_start(Crypt::Mode::ECB self, SV * key)
	30	ALIAS:
	31	start_encrypt = 1
	32	start_decrypt = 2
	33	PPCODE:
38	34	{
39	35	int rv;
40	36	STRLEN k_len=0;

48	44	croak("FATAL: ecb_start failed: %s", error_to_string(rv));
49	45	}
50	46
51		self->direction = dir;
	47	self->direction = ix == 1 ? 1 : -1;
52	48	self->padlen = 0;
	49	XPUSHs(ST(0)); /* return self */
53	50	}
54	51
55	52	SV *
56		_encrypt(Crypt::Mode::ECB self, SV * data)
57		CODE:
58		{
59		int rv, has_tmp_block, blen;
60		unsigned long i;
61
62		STRLEN in_data_len, in_data_start;
63		unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
64
65		if (self->direction != 1) croak("FATAL: encrypt error, call start_encrypt first (%d)", self->direction);
66
67		blen = (&self->state)->blocklen;
68		in_data_start = 0;
69		has_tmp_block = 0;
70		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
71		if (in_data_len == 0) {
72		RETVAL = newSVpvn("", 0);
73		}
74		else {
75		if (self->padlen > 0) {
76		i = (blen - self->padlen);
77		if (in_data_len >= i) { /* enough data to fill pad */
78		Copy(in_data, self->pad+self->padlen, i, unsigned char);
79		in_data_len -= i;
80		in_data_start = i;
81		rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
82		if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
83		self->padlen = 0;
84		has_tmp_block = 1;
85		}
86		else { /* not enough data to fill pad */
87		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
88		self->padlen += (int)in_data_len;
89		in_data_len = 0;
90		}
91		} /* padlen > 0 */
92
93		i = (unsigned long)(in_data_len % blen);
94		if (in_data_len>0 && i>0) { /* save tail of data into pad */
95		Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
96		self->padlen = i;
97		in_data_len -= i;
98		}
99
100		if (in_data_len > 0) {
101		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
102		RETVAL = NEWSV(0, i);
103		SvPOK_only(RETVAL);
104		SvCUR_set(RETVAL, i);
105		out_data = (unsigned char *)SvPVX(RETVAL);
106		if (has_tmp_block) {
107		Copy(tmp_block, out_data, blen, unsigned char);
108		out_data += blen;
109		}
110		rv = ecb_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
111		if (rv != CRYPT_OK) {
112		SvREFCNT_dec(RETVAL);
113		croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
114		}
115		} /* in_data_len>0 */
116		else if (has_tmp_block) {
117		RETVAL = newSVpvn((char*)tmp_block, blen);
118		}
119		else {
120		RETVAL = newSVpvn("", 0);
121		}
122		}
123		}
124		OUTPUT:
125		RETVAL
126
127		SV *
128		_finish_enc(Crypt::Mode::ECB self)
129		CODE:
130		{
131		unsigned char tmp_block[MAXBLOCKSIZE];
132		int rv, blen, i, j;
133
134		blen = (&self->state)->blocklen;
135		if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
136
137		if (self->padding_mode == 1) { /* pkcs5\|7 padding */
138		i = blen - self->padlen;
139		if (i == 0) i = blen;
140		for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
141		rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
142		if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
143		}
144		else if (self->padding_mode == 2) { /* oneandzeroes padding */
145		self->pad[self->padlen] = 0x80;
146		for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
147		rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
148		if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
149		}
150		else {
151		if (self->padlen>0) croak("FATAL: ecb_encrypt, input data length not multiple of %d", blen);
152		blen = 0;
153		}
154
155		self->direction = 0;
156		RETVAL = newSVpvn((char*)tmp_block, blen);
157		}
158		OUTPUT:
159		RETVAL
160
161		SV *
162		_decrypt(Crypt::Mode::ECB self, SV * data)
	53	_crypt(Crypt::Mode::ECB self, SV * data)
163	54	CODE:
164	55	{
165	56	int rv, has_tmp_block, blen;

167	58	STRLEN in_data_len, in_data_start;
168	59	unsigned char in_data, out_data, tmp_block[MAXBLOCKSIZE];
169	60
170		if (self->direction != -1) croak("FATAL: decrypt error, call start_decryt first (%d)", self->direction);
171
172		blen = (&self->state)->blocklen;
173		in_data_start = 0;
174		has_tmp_block = 0;
175		in_data = (unsigned char *)SvPVbyte(data, in_data_len);
176		if (in_data_len == 0) {
177		RETVAL = newSVpvn("", 0);
178		}
179		else {
180
181		if (self->padlen == blen) {
182		rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
183		if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
184		self->padlen = 0;
185		has_tmp_block = 1;
186		} /* padlen == blen */
187		else if (self->padlen > 0) {
188		i = (blen - self->padlen); /* remaining bytes in padding buffer */
189		if (in_data_len >= i) { /* enough data to fill pad */
190		Copy(in_data, self->pad+self->padlen, i, unsigned char);
191		self->padlen += i;
192		in_data_len -= i;
193		in_data_start = i;
194		if (in_data_len>0 \|\| self->padding_mode == 0) {
195		rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
196		if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	61	if (self->direction == 1) {
	62	blen = (&self->state)->blocklen;
	63	in_data_start = 0;
	64	has_tmp_block = 0;
	65	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	66	if (in_data_len == 0) {
	67	RETVAL = newSVpvn("", 0);
	68	}
	69	else {
	70	if (self->padlen > 0) {
	71	i = (blen - self->padlen);
	72	if (in_data_len >= i) { /* enough data to fill pad */
	73	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	74	in_data_len -= i;
	75	in_data_start = i;
	76	rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
	77	if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
197	78	self->padlen = 0;
198	79	has_tmp_block = 1;
199	80	}
200		}
201		else { /* not enough data to fill pad */
202		Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
203		self->padlen += (int)in_data_len;
204		in_data_len = 0;
205		}
206		} /* padlen > 0 */
207
208		/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
209		if (in_data_len>0) {
	81	else { /* not enough data to fill pad */
	82	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	83	self->padlen += (int)in_data_len;
	84	in_data_len = 0;
	85	}
	86	} /* padlen > 0 */
	87
210	88	i = (unsigned long)(in_data_len % blen);
211		if (i>0) { /* save tail of data into pad */
	89	if (in_data_len>0 && i>0) { /* save tail of data into pad */
212	90	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
213	91	self->padlen = i;
214	92	in_data_len -= i;
215	93	}
216		}
217
218		if (in_data_len>0) {
219		if (self->padlen == 0 && self->padding_mode !=0) {
220		/* in case of padding keep full pad if no more data */
221		Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
222		self->padlen = blen;
223		in_data_len -= blen;
224		}
225		i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
226		if (i == 0) {
227		RETVAL = newSVpvn("", 0);
228		}
229		else {
	94
	95	if (in_data_len > 0) {
	96	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
230	97	RETVAL = NEWSV(0, i);
231	98	SvPOK_only(RETVAL);
232	99	SvCUR_set(RETVAL, i);

235	102	Copy(tmp_block, out_data, blen, unsigned char);
236	103	out_data += blen;
237	104	}
238		rv = ecb_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	105	rv = ecb_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
239	106	if (rv != CRYPT_OK) {
240	107	SvREFCNT_dec(RETVAL);
241		croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
242		}
243		}
244		} /* in_data_len>0 */
245		else if (has_tmp_block) {
246		RETVAL = newSVpvn((char*)tmp_block, blen);
247		}
248		else {
	108	croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
	109	}
	110	} /* in_data_len>0 */
	111	else if (has_tmp_block) {
	112	RETVAL = newSVpvn((char*)tmp_block, blen);
	113	}
	114	else {
	115	RETVAL = newSVpvn("", 0);
	116	}
	117	}
	118	}
	119	else if (self->direction == -1) {
	120	blen = (&self->state)->blocklen;
	121	in_data_start = 0;
	122	has_tmp_block = 0;
	123	in_data = (unsigned char *)SvPVbyte(data, in_data_len);
	124	if (in_data_len == 0) {
249	125	RETVAL = newSVpvn("", 0);
250	126	}
251		}
252
	127	else {
	128
	129	if (self->padlen == blen) {
	130	rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
	131	if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	132	self->padlen = 0;
	133	has_tmp_block = 1;
	134	} /* padlen == blen */
	135	else if (self->padlen > 0) {
	136	i = (blen - self->padlen); /* remaining bytes in padding buffer */
	137	if (in_data_len >= i) { /* enough data to fill pad */
	138	Copy(in_data, self->pad+self->padlen, i, unsigned char);
	139	self->padlen += i;
	140	in_data_len -= i;
	141	in_data_start = i;
	142	if (in_data_len>0 \|\| self->padding_mode == 0) {
	143	rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
	144	if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	145	self->padlen = 0;
	146	has_tmp_block = 1;
	147	}
	148	}
	149	else { /* not enough data to fill pad */
	150	Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
	151	self->padlen += (int)in_data_len;
	152	in_data_len = 0;
	153	}
	154	} /* padlen > 0 */
	155
	156	/* here: a/ padlen == 1..16 && in_data_len == 0; b/ padlen == 0 && in_data_len > 0 */
	157	if (in_data_len>0) {
	158	i = (unsigned long)(in_data_len % blen);
	159	if (i>0) { /* save tail of data into pad */
	160	Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
	161	self->padlen = i;
	162	in_data_len -= i;
	163	}
	164	}
	165
	166	if (in_data_len>0) {
	167	if (self->padlen == 0 && self->padding_mode !=0) {
	168	/* in case of padding keep full pad if no more data */
	169	Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
	170	self->padlen = blen;
	171	in_data_len -= blen;
	172	}
	173	i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
	174	if (i == 0) {
	175	RETVAL = newSVpvn("", 0);
	176	}
	177	else {
	178	RETVAL = NEWSV(0, i);
	179	SvPOK_only(RETVAL);
	180	SvCUR_set(RETVAL, i);
	181	out_data = (unsigned char *)SvPVX(RETVAL);
	182	if (has_tmp_block) {
	183	Copy(tmp_block, out_data, blen, unsigned char);
	184	out_data += blen;
	185	}
	186	rv = ecb_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
	187	if (rv != CRYPT_OK) {
	188	SvREFCNT_dec(RETVAL);
	189	croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	190	}
	191	}
	192	} /* in_data_len>0 */
	193	else if (has_tmp_block) {
	194	RETVAL = newSVpvn((char*)tmp_block, blen);
	195	}
	196	else {
	197	RETVAL = newSVpvn("", 0);
	198	}
	199	}
	200	}
	201	else {
	202	croak("FATAL: call start_decryt or start_encrpyt first (%d)", self->direction);
	203	}
253	204	}
254	205	OUTPUT:
255	206	RETVAL
256	207
257	208	SV *
258		_finish_dec(Crypt::Mode::ECB self)
259		CODE:
260		{
261		unsigned char tmp_block[MAXBLOCKSIZE];
262		unsigned char i;
263		int rv, rv_len, blen;
264
265		rv_len = 0;
266		if (self->padlen > 0) {
267		blen = (&self->state)->blocklen;
268		if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
269		rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
270		if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
271		if (self->padding_mode == 0) { /* no padding */
272		rv_len = blen;
273		}
274		else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
275		i = tmp_block[blen-1];
276		rv_len = blen - (i>blen ? blen : i);
277		}
278		else if (self->padding_mode == 2) { /* oneandzeroes padding */
279		rv_len = blen;
280		while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
281		if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;
282		if (rv_len<0) rv_len = 0;
283		}
	209	finish(Crypt::Mode::ECB self)
	210	CODE:
	211	{
	212	unsigned char tmp_block[MAXBLOCKSIZE], ch;
	213	int i, j, rv, blen = (&self->state)->blocklen;
	214
	215	if (self->direction == 1) {
	216	if (self->padlen<0 \|\| self->padlen>=blen) croak("FATAL: invalid padlen");
	217	if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	218	i = blen - self->padlen;
	219	if (i == 0) i = blen;
	220	for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
	221	rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
	222	if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
	223	}
	224	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	225	self->pad[self->padlen] = 0x80;
	226	for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
	227	rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
	228	if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
	229	}
	230	else {
	231	if (self->padlen>0) croak("FATAL: ecb_encrypt, input data length not multiple of %d", blen);
	232	blen = 0;
	233	}
	234	}
	235	else if (self->direction == -1) {
	236	if (self->padlen > 0) {
	237	if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
	238	rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
	239	if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
	240	if (self->padding_mode == 0) { /* no padding */
	241	/* we already have blen */
	242	}
	243	else if (self->padding_mode == 1) { /* pkcs5\|7 padding */
	244	ch = tmp_block[blen-1];
	245	blen = blen - (ch > blen ? blen : ch);
	246	}
	247	else if (self->padding_mode == 2) { /* oneandzeroes padding */
	248	while ((unsigned char)tmp_block[blen - 1] == 0x00) blen--;
	249	if ((unsigned char)tmp_block[blen - 1] == 0x80) blen--;
	250	if (blen < 0) blen = 0;
	251	}
	252	}
	253	else {
	254	blen = 0;
	255	}
	256	}
	257	else {
	258	XSRETURN_UNDEF;
284	259	}
285	260
286	261	self->direction = 0;
287		RETVAL = newSVpvn((char*)tmp_block, rv_len);
	262	RETVAL = newSVpvn((char*)tmp_block, blen);
288	263	}
289	264	OUTPUT:
290	265	RETVAL

+8

-11

inc/CryptX_Mode_OFB.xs.inc less more

23	23	CODE:
24	24	Safefree(self);
25	25
26		int
27		_get_dir(Crypt::Mode::OFB self)
28		CODE:
29		RETVAL = self->direction;
30		OUTPUT:
31		RETVAL
32
33	26	void
34		_start(Crypt::Mode::OFB self, int dir, SV * key, SV * iv)
35		CODE:
	27	_start(Crypt::Mode::OFB self, SV * key, SV * iv)
	28	ALIAS:
	29	start_encrypt = 1
	30	start_decrypt = 2
	31	PPCODE:
36	32	{
37	33	STRLEN k_len=0;
38	34	unsigned char *k=NULL;

54	50	croak("FATAL: ofb_start failed: %s", error_to_string(rv));
55	51	}
56	52
57		self->direction = dir;
	53	self->direction = ix == 1 ? 1 : -1;
	54	XPUSHs(ST(0)); /* return self */
58	55	}
59	56
60	57	SV *

99	96	RETVAL
100	97
101	98	SV *
102		_finish(Crypt::Mode::OFB self)
	99	finish(Crypt::Mode::OFB self)
103	100	CODE:
104	101	self->direction = 0;
105	102	RETVAL = newSVpvn("", 0);

+75

-140

inc/CryptX_PRNG.xs.inc less more

95	95
96	96	SV *
97	97	bytes(Crypt::PRNG self, STRLEN output_len)
98		CODE:
99		{
100		IV curpid = (IV)PerlProc_getpid();
101		int rv_len;
102		unsigned char *rdata;
	98	ALIAS:
	99	bytes_hex = 1
	100	bytes_b64 = 2
	101	bytes_b64u = 3
	102	CODE:
	103	{
	104	IV curpid = (IV)PerlProc_getpid();
	105	int rv_len, rv;
	106	unsigned long len;
	107	unsigned char rdata, tmp;
103	108	unsigned char entropy_buf[40];
104	109
105	110	if (self->last_pid != curpid) {

108	113	self->desc->ready(&self->state);
109	114	self->last_pid = curpid;
110	115	}
111
112		RETVAL = NEWSV(0, output_len);
113		SvPOK_only(RETVAL);
114		SvCUR_set(RETVAL, output_len);
115		rdata = (unsigned char *)SvPVX(RETVAL);
116		rv_len = (self->desc->read)(rdata, (unsigned long)output_len, &self->state);
117		if ((UV)rv_len != output_len) {
118		SvREFCNT_dec(RETVAL);
119		croak("FATAL: PRNG_read failed");
120		}
121		}
122		OUTPUT:
123		RETVAL
124
125		SV *
126		bytes_hex(Crypt::PRNG self, STRLEN output_len)
127		CODE:
128		{
129		IV curpid = (IV)PerlProc_getpid();
130		int rv_len, rv;
131		unsigned long len;
132		unsigned char rdata, tmp;
	116
	117	if (ix == 1) {
	118	/* HEX */
	119	Newz(0, tmp, output_len, unsigned char);
	120	if (tmp == NULL) croak("FATAL: Newz failed");
	121	rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state);
	122	if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
	123	RETVAL = NEWSV(0, output_len * 2);
	124	SvPOK_only(RETVAL);
	125	SvCUR_set(RETVAL, output_len * 2);
	126	rdata = (unsigned char *)SvPVX(RETVAL);
	127	len = output_len * 2;
	128	rv = _base16_encode(tmp, output_len, rdata, &len);
	129	Safefree(tmp);
	130	if (rv != CRYPT_OK) {
	131	SvREFCNT_dec(RETVAL);
	132	croak("FATAL: base16_encode failed");
	133	}
	134	}
	135	else if (ix == 2 \|\| ix == 3) {
	136	/* BASE64 or BASE64URL */
	137	Newz(0, tmp, output_len, unsigned char);
	138	if (tmp == NULL) croak("FATAL: Newz failed");
	139	rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state);
	140	if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
	141	RETVAL = NEWSV(0, output_len * 2);
	142	SvPOK_only(RETVAL);
	143	SvCUR_set(RETVAL, output_len * 2);
	144	rdata = (unsigned char *)SvPVX(RETVAL);
	145	len = output_len * 2;
	146	rv = ix == 3 ? base64url_encode(tmp, output_len, rdata, &len) :
	147	base64_encode(tmp, output_len, rdata, &len);
	148	SvCUR_set(RETVAL, len);
	149	Safefree(tmp);
	150	if (rv != CRYPT_OK) {
	151	SvREFCNT_dec(RETVAL);
	152	croak(ix == 3 ? "FATAL: base64url_encode failed" : "FATAL: base64_encode failed");
	153	}
	154	}
	155	else {
	156	/* RAW BYTES */
	157	RETVAL = NEWSV(0, output_len);
	158	SvPOK_only(RETVAL);
	159	SvCUR_set(RETVAL, output_len);
	160	rdata = (unsigned char *)SvPVX(RETVAL);
	161	rv_len = (self->desc->read)(rdata, (unsigned long)output_len, &self->state);
	162	if ((UV)rv_len != output_len) {
	163	SvREFCNT_dec(RETVAL);
	164	croak("FATAL: PRNG_read failed");
	165	}
	166	}
	167	}
	168	OUTPUT:
	169	RETVAL
	170
	171	UV
	172	int32(Crypt::PRNG self)
	173	CODE:
	174	{
	175	IV curpid = (IV)PerlProc_getpid();
	176	int i;
	177	unsigned char rdata[4];
133	178	unsigned char entropy_buf[40];
134	179
135	180	if (self->last_pid != curpid) {

139	184	self->last_pid = curpid;
140	185	}
141	186
142		Newz(0, tmp, output_len, unsigned char);
143		if (tmp == NULL) croak("FATAL: Newz failed");
144		rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state);
145		if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
146		RETVAL = NEWSV(0, output_len * 2);
147		SvPOK_only(RETVAL);
148		SvCUR_set(RETVAL, output_len * 2);
149		rdata = (unsigned char *)SvPVX(RETVAL);
150		len = output_len * 2;
151		rv = _base16_encode(tmp, output_len, rdata, &len);
152		Safefree(tmp);
153		if (rv != CRYPT_OK) {
154		SvREFCNT_dec(RETVAL);
155		croak("FATAL: base16_encode failed");
156		}
157		}
158		OUTPUT:
159		RETVAL
160
161		SV *
162		bytes_b64(Crypt::PRNG self, STRLEN output_len)
163		CODE:
164		{
165		IV curpid = (IV)PerlProc_getpid();
166		int rv_len, rv;
167		unsigned long len;
168		unsigned char rdata, tmp;
169		unsigned char entropy_buf[40];
170
171		if (self->last_pid != curpid) {
172		if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed");
173		self->desc->add_entropy(entropy_buf, 40, &self->state);
174		self->desc->ready(&self->state);
175		self->last_pid = curpid;
176		}
177
178		Newz(0, tmp, output_len, unsigned char);
179		if (tmp == NULL) croak("FATAL: Newz failed");
180		rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state);
181		if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
182		RETVAL = NEWSV(0, output_len * 2);
183		SvPOK_only(RETVAL);
184		SvCUR_set(RETVAL, output_len * 2);
185		rdata = (unsigned char *)SvPVX(RETVAL);
186		len = output_len * 2;
187		rv = base64_encode(tmp, output_len, rdata, &len);
188		SvCUR_set(RETVAL, len);
189		Safefree(tmp);
190		if (rv != CRYPT_OK) {
191		SvREFCNT_dec(RETVAL);
192		croak("FATAL: base64_encode failed");
193		}
194		}
195		OUTPUT:
196		RETVAL
197
198		SV *
199		bytes_b64u(Crypt::PRNG self, STRLEN output_len)
200		CODE:
201		{
202		IV curpid = (IV)PerlProc_getpid();
203		int rv_len, rv;
204		unsigned long len;
205		unsigned char rdata, tmp;
206		unsigned char entropy_buf[40];
207
208		if (self->last_pid != curpid) {
209		if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed");
210		self->desc->add_entropy(entropy_buf, 40, &self->state);
211		self->desc->ready(&self->state);
212		self->last_pid = curpid;
213		}
214
215		Newz(0, tmp, output_len, unsigned char);
216		if (tmp == NULL) croak("FATAL: Newz failed");
217		rv_len = (self->desc->read)(tmp, (unsigned long)output_len, &self->state);
218		if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
219		RETVAL = NEWSV(0, output_len * 2);
220		SvPOK_only(RETVAL);
221		SvCUR_set(RETVAL, output_len * 2);
222		rdata = (unsigned char *)SvPVX(RETVAL);
223		len = output_len * 2;
224		rv = base64url_encode(tmp, output_len, rdata, &len);
225		SvCUR_set(RETVAL, len);
226		Safefree(tmp);
227		if (rv != CRYPT_OK) {
228		SvREFCNT_dec(RETVAL);
229		croak("FATAL: base64url_encode failed");
230		}
231		}
232		OUTPUT:
233		RETVAL
234
235		UV
236		int32(Crypt::PRNG self)
237		CODE:
238		{
239		IV curpid = (IV)PerlProc_getpid();
240		int i;
241		unsigned char rdata[4];
242		unsigned char entropy_buf[40];
243
244		if (self->last_pid != curpid) {
245		if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed");
246		self->desc->add_entropy(entropy_buf, 40, &self->state);
247		self->desc->ready(&self->state);
248		self->last_pid = curpid;
249		}
250
251	187	i = (self->desc->read)(rdata, 4, &self->state);
252	188	if (i != 4) croak("FATAL: PRNG_read failed");
253	189	RETVAL = ((UV)(rdata[0])<<24) + ((UV)(rdata[1])<<16) + ((UV)(rdata[2])<<8) + ((UV)(rdata[3]));

256	192	RETVAL
257	193
258	194	NV
259		double(Crypt::PRNG self, ...)
	195	double(Crypt::PRNG self, SV * limit_sv = NULL)
260	196	CODE:
261	197	{
262	198	IV curpid = (IV)PerlProc_getpid();

264	200	unsigned long a, b; /* 32bit is enough */
265	201	unsigned char rdata[7]; /* for double we need 53 bits */
266	202	unsigned char entropy_buf[40];
267		NV limit;
268	203
269	204	if (self->last_pid != curpid) {
270	205	if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed");

278	213	a = (((unsigned long)(rdata[0])<<16) + ((unsigned long)(rdata[1])<<8) + ((unsigned long)(rdata[2]))) & 0x1FFFFF; /* 21 bits */
279	214	b = ((unsigned long)(rdata[3])<<24) + ((unsigned long)(rdata[4])<<16) + ((unsigned long)(rdata[5])<<8) + ((unsigned long)(rdata[6])); /* 32 bits */
280	215	RETVAL = ( (NV)a * 4294967296.0 + (NV)b ) / 9007199254740992.0; /* (a * 2^32 + b) / 2^53 */
281		if (items > 1 && SvOK(ST(1))) {
282		limit = SvNV(ST(1));
	216	if (limit_sv && SvOK(limit_sv)) {
	217	NV limit = SvNV(limit_sv);
283	218	if (limit > 0 \|\| limit < 0) RETVAL = RETVAL * limit;
284	219	}
285	220	}

+0

-1

lib/Crypt/AuthEnc/CCM.pm less more

11	11	use Carp;
12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14		use Crypt::Cipher;
15	14
16	15	sub ccm_encrypt_authenticate {
17	16	my $cipher_name = shift;

+0

-1

lib/Crypt/AuthEnc/EAX.pm less more

11	11	use Carp;
12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14		use Crypt::Cipher;
15	14
16	15	### the following methods/functions are implemented in XS:
17	16	# - new

+0

-1

lib/Crypt/AuthEnc/GCM.pm less more

11	11	use Carp;
12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14		use Crypt::Cipher;
15	14
16	15	sub gcm_encrypt_authenticate {
17	16	my $cipher_name = shift;

+0

-1

lib/Crypt/AuthEnc/OCB.pm less more

11	11	use Carp;
12	12	$Carp::Internal{(__PACKAGE__)}++;
13	13	use CryptX;
14		use Crypt::Cipher;
15	14
16	15	sub ocb_encrypt_authenticate {
17	16	my $cipher_name = shift;

+6

-7

lib/Crypt/Cipher/AES.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('AES') }
	11	sub keysize { Crypt::Cipher::keysize('AES') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('AES') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('AES') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('AES') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Anubis.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Anubis') }
	11	sub keysize { Crypt::Cipher::keysize('Anubis') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Anubis') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Anubis') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Anubis') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Blowfish.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Blowfish') }
	11	sub keysize { Crypt::Cipher::keysize('Blowfish') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Blowfish') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Blowfish') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Blowfish') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/CAST5.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('CAST5') }
	11	sub keysize { Crypt::Cipher::keysize('CAST5') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('CAST5') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('CAST5') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('CAST5') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Camellia.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Camellia') }
	11	sub keysize { Crypt::Cipher::keysize('Camellia') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Camellia') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Camellia') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Camellia') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/DES.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('DES') }
	11	sub keysize { Crypt::Cipher::keysize('DES') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('DES') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('DES') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('DES') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/DES_EDE.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('DES_EDE') }
	11	sub keysize { Crypt::Cipher::keysize('DES_EDE') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('DES_EDE') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('DES_EDE') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('DES_EDE') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/IDEA.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('IDEA') }
	11	sub keysize { Crypt::Cipher::keysize('IDEA') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('IDEA') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('IDEA') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('IDEA') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/KASUMI.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('KASUMI') }
	11	sub keysize { Crypt::Cipher::keysize('KASUMI') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('KASUMI') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('KASUMI') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('KASUMI') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Khazad.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Khazad') }
	11	sub keysize { Crypt::Cipher::keysize('Khazad') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Khazad') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Khazad') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Khazad') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/MULTI2.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('MULTI2') }
	11	sub keysize { Crypt::Cipher::keysize('MULTI2') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('MULTI2') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('MULTI2') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('MULTI2') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Noekeon.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Noekeon') }
	11	sub keysize { Crypt::Cipher::keysize('Noekeon') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Noekeon') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Noekeon') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Noekeon') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/RC2.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('RC2') }
	11	sub keysize { Crypt::Cipher::keysize('RC2') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('RC2') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('RC2') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('RC2') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/RC5.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('RC5') }
	11	sub keysize { Crypt::Cipher::keysize('RC5') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('RC5') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('RC5') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('RC5') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/RC6.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('RC6') }
	11	sub keysize { Crypt::Cipher::keysize('RC6') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('RC6') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('RC6') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('RC6') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SAFERP.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SAFERP') }
	11	sub keysize { Crypt::Cipher::keysize('SAFERP') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SAFERP') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SAFERP') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SAFERP') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SAFER_K128.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SAFER_K128') }
	11	sub keysize { Crypt::Cipher::keysize('SAFER_K128') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SAFER_K128') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SAFER_K128') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SAFER_K128') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SAFER_K64.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SAFER_K64') }
	11	sub keysize { Crypt::Cipher::keysize('SAFER_K64') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SAFER_K64') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SAFER_K64') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SAFER_K64') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SAFER_SK128.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SAFER_SK128') }
	11	sub keysize { Crypt::Cipher::keysize('SAFER_SK128') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SAFER_SK128') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SAFER_SK128') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SAFER_SK128') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SAFER_SK64.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SAFER_SK64') }
	11	sub keysize { Crypt::Cipher::keysize('SAFER_SK64') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SAFER_SK64') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SAFER_SK64') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SAFER_SK64') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/SEED.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('SEED') }
	11	sub keysize { Crypt::Cipher::keysize('SEED') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('SEED') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('SEED') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('SEED') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Serpent.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Serpent') }
	11	sub keysize { Crypt::Cipher::keysize('Serpent') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Serpent') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Serpent') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Serpent') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Skipjack.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Skipjack') }
	11	sub keysize { Crypt::Cipher::keysize('Skipjack') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Skipjack') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Skipjack') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Skipjack') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/Twofish.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('Twofish') }
	11	sub keysize { Crypt::Cipher::keysize('Twofish') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('Twofish') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('Twofish') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('Twofish') }
16	15
17	16	1;
18	17

+6

-7

lib/Crypt/Cipher/XTEA.pm less more

5	5	use warnings;
6	6	our $VERSION = '0.056_001';
7	7
8		use CryptX;
9		use base 'Crypt::Cipher';
	8	use base qw(Crypt::Cipher);
10	9
11		sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
12		sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
13		sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
14		sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
15		sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
	10	sub blocksize { Crypt::Cipher::blocksize('XTEA') }
	11	sub keysize { Crypt::Cipher::keysize('XTEA') }
	12	sub max_keysize { Crypt::Cipher::max_keysize('XTEA') }
	13	sub min_keysize { Crypt::Cipher::min_keysize('XTEA') }
	14	sub default_rounds { Crypt::Cipher::default_rounds('XTEA') }
16	15
17	16	1;
18	17

+11

-13

lib/Crypt/Digest/BLAKE2b_160.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2b_160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2b_160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2b_160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2b_160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2b_160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2b_160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2b_160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2b_160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2b_160') }
	18	sub blake2b_160 { Crypt::Digest::digest_data('BLAKE2b_160', @_) }
	19	sub blake2b_160_hex { Crypt::Digest::digest_data_hex('BLAKE2b_160', @_) }
	20	sub blake2b_160_b64 { Crypt::Digest::digest_data_b64('BLAKE2b_160', @_) }
	21	sub blake2b_160_b64u { Crypt::Digest::digest_data_b64u('BLAKE2b_160', @_) }
	22	sub blake2b_160_file { Crypt::Digest::digest_file('BLAKE2b_160', @_) }
	23	sub blake2b_160_file_hex { Crypt::Digest::digest_file_hex('BLAKE2b_160', @_) }
	24	sub blake2b_160_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2b_160', @_) }
	25	sub blake2b_160_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2b_160', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2b_256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2b_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2b_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2b_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2b_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2b_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2b_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2b_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2b_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2b_256') }
	18	sub blake2b_256 { Crypt::Digest::digest_data('BLAKE2b_256', @_) }
	19	sub blake2b_256_hex { Crypt::Digest::digest_data_hex('BLAKE2b_256', @_) }
	20	sub blake2b_256_b64 { Crypt::Digest::digest_data_b64('BLAKE2b_256', @_) }
	21	sub blake2b_256_b64u { Crypt::Digest::digest_data_b64u('BLAKE2b_256', @_) }
	22	sub blake2b_256_file { Crypt::Digest::digest_file('BLAKE2b_256', @_) }
	23	sub blake2b_256_file_hex { Crypt::Digest::digest_file_hex('BLAKE2b_256', @_) }
	24	sub blake2b_256_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2b_256', @_) }
	25	sub blake2b_256_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2b_256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2b_384.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2b_384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2b_384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2b_384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2b_384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2b_384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2b_384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2b_384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2b_384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2b_384') }
	18	sub blake2b_384 { Crypt::Digest::digest_data('BLAKE2b_384', @_) }
	19	sub blake2b_384_hex { Crypt::Digest::digest_data_hex('BLAKE2b_384', @_) }
	20	sub blake2b_384_b64 { Crypt::Digest::digest_data_b64('BLAKE2b_384', @_) }
	21	sub blake2b_384_b64u { Crypt::Digest::digest_data_b64u('BLAKE2b_384', @_) }
	22	sub blake2b_384_file { Crypt::Digest::digest_file('BLAKE2b_384', @_) }
	23	sub blake2b_384_file_hex { Crypt::Digest::digest_file_hex('BLAKE2b_384', @_) }
	24	sub blake2b_384_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2b_384', @_) }
	25	sub blake2b_384_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2b_384', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2b_512.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2b_512 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2b_512_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2b_512_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2b_512_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2b_512_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2b_512_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2b_512_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2b_512_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2b_512') }
	18	sub blake2b_512 { Crypt::Digest::digest_data('BLAKE2b_512', @_) }
	19	sub blake2b_512_hex { Crypt::Digest::digest_data_hex('BLAKE2b_512', @_) }
	20	sub blake2b_512_b64 { Crypt::Digest::digest_data_b64('BLAKE2b_512', @_) }
	21	sub blake2b_512_b64u { Crypt::Digest::digest_data_b64u('BLAKE2b_512', @_) }
	22	sub blake2b_512_file { Crypt::Digest::digest_file('BLAKE2b_512', @_) }
	23	sub blake2b_512_file_hex { Crypt::Digest::digest_file_hex('BLAKE2b_512', @_) }
	24	sub blake2b_512_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2b_512', @_) }
	25	sub blake2b_512_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2b_512', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2s_128.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2s_128 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2s_128_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2s_128_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2s_128_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2s_128_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2s_128_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2s_128_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2s_128_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2s_128') }
	18	sub blake2s_128 { Crypt::Digest::digest_data('BLAKE2s_128', @_) }
	19	sub blake2s_128_hex { Crypt::Digest::digest_data_hex('BLAKE2s_128', @_) }
	20	sub blake2s_128_b64 { Crypt::Digest::digest_data_b64('BLAKE2s_128', @_) }
	21	sub blake2s_128_b64u { Crypt::Digest::digest_data_b64u('BLAKE2s_128', @_) }
	22	sub blake2s_128_file { Crypt::Digest::digest_file('BLAKE2s_128', @_) }
	23	sub blake2s_128_file_hex { Crypt::Digest::digest_file_hex('BLAKE2s_128', @_) }
	24	sub blake2s_128_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2s_128', @_) }
	25	sub blake2s_128_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2s_128', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2s_160.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2s_160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2s_160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2s_160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2s_160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2s_160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2s_160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2s_160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2s_160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2s_160') }
	18	sub blake2s_160 { Crypt::Digest::digest_data('BLAKE2s_160', @_) }
	19	sub blake2s_160_hex { Crypt::Digest::digest_data_hex('BLAKE2s_160', @_) }
	20	sub blake2s_160_b64 { Crypt::Digest::digest_data_b64('BLAKE2s_160', @_) }
	21	sub blake2s_160_b64u { Crypt::Digest::digest_data_b64u('BLAKE2s_160', @_) }
	22	sub blake2s_160_file { Crypt::Digest::digest_file('BLAKE2s_160', @_) }
	23	sub blake2s_160_file_hex { Crypt::Digest::digest_file_hex('BLAKE2s_160', @_) }
	24	sub blake2s_160_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2s_160', @_) }
	25	sub blake2s_160_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2s_160', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2s_224.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2s_224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2s_224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2s_224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2s_224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2s_224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2s_224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2s_224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2s_224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2s_224') }
	18	sub blake2s_224 { Crypt::Digest::digest_data('BLAKE2s_224', @_) }
	19	sub blake2s_224_hex { Crypt::Digest::digest_data_hex('BLAKE2s_224', @_) }
	20	sub blake2s_224_b64 { Crypt::Digest::digest_data_b64('BLAKE2s_224', @_) }
	21	sub blake2s_224_b64u { Crypt::Digest::digest_data_b64u('BLAKE2s_224', @_) }
	22	sub blake2s_224_file { Crypt::Digest::digest_file('BLAKE2s_224', @_) }
	23	sub blake2s_224_file_hex { Crypt::Digest::digest_file_hex('BLAKE2s_224', @_) }
	24	sub blake2s_224_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2s_224', @_) }
	25	sub blake2s_224_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2s_224', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/BLAKE2s_256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub blake2s_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub blake2s_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub blake2s_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub blake2s_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub blake2s_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub blake2s_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub blake2s_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub blake2s_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('BLAKE2s_256') }
	18	sub blake2s_256 { Crypt::Digest::digest_data('BLAKE2s_256', @_) }
	19	sub blake2s_256_hex { Crypt::Digest::digest_data_hex('BLAKE2s_256', @_) }
	20	sub blake2s_256_b64 { Crypt::Digest::digest_data_b64('BLAKE2s_256', @_) }
	21	sub blake2s_256_b64u { Crypt::Digest::digest_data_b64u('BLAKE2s_256', @_) }
	22	sub blake2s_256_file { Crypt::Digest::digest_file('BLAKE2s_256', @_) }
	23	sub blake2s_256_file_hex { Crypt::Digest::digest_file_hex('BLAKE2s_256', @_) }
	24	sub blake2s_256_file_b64 { Crypt::Digest::digest_file_b64('BLAKE2s_256', @_) }
	25	sub blake2s_256_file_b64u { Crypt::Digest::digest_file_b64u('BLAKE2s_256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/CHAES.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub chaes { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub chaes_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub chaes_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub chaes_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub chaes_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub chaes_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub chaes_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub chaes_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('CHAES') }
	18	sub chaes { Crypt::Digest::digest_data('CHAES', @_) }
	19	sub chaes_hex { Crypt::Digest::digest_data_hex('CHAES', @_) }
	20	sub chaes_b64 { Crypt::Digest::digest_data_b64('CHAES', @_) }
	21	sub chaes_b64u { Crypt::Digest::digest_data_b64u('CHAES', @_) }
	22	sub chaes_file { Crypt::Digest::digest_file('CHAES', @_) }
	23	sub chaes_file_hex { Crypt::Digest::digest_file_hex('CHAES', @_) }
	24	sub chaes_file_b64 { Crypt::Digest::digest_file_b64('CHAES', @_) }
	25	sub chaes_file_b64u { Crypt::Digest::digest_file_b64u('CHAES', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/MD2.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub md2 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub md2_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub md2_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub md2_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub md2_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub md2_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub md2_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub md2_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('MD2') }
	18	sub md2 { Crypt::Digest::digest_data('MD2', @_) }
	19	sub md2_hex { Crypt::Digest::digest_data_hex('MD2', @_) }
	20	sub md2_b64 { Crypt::Digest::digest_data_b64('MD2', @_) }
	21	sub md2_b64u { Crypt::Digest::digest_data_b64u('MD2', @_) }
	22	sub md2_file { Crypt::Digest::digest_file('MD2', @_) }
	23	sub md2_file_hex { Crypt::Digest::digest_file_hex('MD2', @_) }
	24	sub md2_file_b64 { Crypt::Digest::digest_file_b64('MD2', @_) }
	25	sub md2_file_b64u { Crypt::Digest::digest_file_b64u('MD2', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/MD4.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub md4 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub md4_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub md4_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub md4_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub md4_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub md4_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub md4_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub md4_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('MD4') }
	18	sub md4 { Crypt::Digest::digest_data('MD4', @_) }
	19	sub md4_hex { Crypt::Digest::digest_data_hex('MD4', @_) }
	20	sub md4_b64 { Crypt::Digest::digest_data_b64('MD4', @_) }
	21	sub md4_b64u { Crypt::Digest::digest_data_b64u('MD4', @_) }
	22	sub md4_file { Crypt::Digest::digest_file('MD4', @_) }
	23	sub md4_file_hex { Crypt::Digest::digest_file_hex('MD4', @_) }
	24	sub md4_file_b64 { Crypt::Digest::digest_file_b64('MD4', @_) }
	25	sub md4_file_b64u { Crypt::Digest::digest_file_b64u('MD4', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/MD5.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub md5 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub md5_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub md5_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub md5_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub md5_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub md5_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub md5_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub md5_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('MD5') }
	18	sub md5 { Crypt::Digest::digest_data('MD5', @_) }
	19	sub md5_hex { Crypt::Digest::digest_data_hex('MD5', @_) }
	20	sub md5_b64 { Crypt::Digest::digest_data_b64('MD5', @_) }
	21	sub md5_b64u { Crypt::Digest::digest_data_b64u('MD5', @_) }
	22	sub md5_file { Crypt::Digest::digest_file('MD5', @_) }
	23	sub md5_file_hex { Crypt::Digest::digest_file_hex('MD5', @_) }
	24	sub md5_file_b64 { Crypt::Digest::digest_file_b64('MD5', @_) }
	25	sub md5_file_b64u { Crypt::Digest::digest_file_b64u('MD5', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/RIPEMD128.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub ripemd128 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub ripemd128_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub ripemd128_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub ripemd128_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub ripemd128_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub ripemd128_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub ripemd128_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub ripemd128_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('RIPEMD128') }
	18	sub ripemd128 { Crypt::Digest::digest_data('RIPEMD128', @_) }
	19	sub ripemd128_hex { Crypt::Digest::digest_data_hex('RIPEMD128', @_) }
	20	sub ripemd128_b64 { Crypt::Digest::digest_data_b64('RIPEMD128', @_) }
	21	sub ripemd128_b64u { Crypt::Digest::digest_data_b64u('RIPEMD128', @_) }
	22	sub ripemd128_file { Crypt::Digest::digest_file('RIPEMD128', @_) }
	23	sub ripemd128_file_hex { Crypt::Digest::digest_file_hex('RIPEMD128', @_) }
	24	sub ripemd128_file_b64 { Crypt::Digest::digest_file_b64('RIPEMD128', @_) }
	25	sub ripemd128_file_b64u { Crypt::Digest::digest_file_b64u('RIPEMD128', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/RIPEMD160.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub ripemd160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub ripemd160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub ripemd160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub ripemd160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub ripemd160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub ripemd160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub ripemd160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub ripemd160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('RIPEMD160') }
	18	sub ripemd160 { Crypt::Digest::digest_data('RIPEMD160', @_) }
	19	sub ripemd160_hex { Crypt::Digest::digest_data_hex('RIPEMD160', @_) }
	20	sub ripemd160_b64 { Crypt::Digest::digest_data_b64('RIPEMD160', @_) }
	21	sub ripemd160_b64u { Crypt::Digest::digest_data_b64u('RIPEMD160', @_) }
	22	sub ripemd160_file { Crypt::Digest::digest_file('RIPEMD160', @_) }
	23	sub ripemd160_file_hex { Crypt::Digest::digest_file_hex('RIPEMD160', @_) }
	24	sub ripemd160_file_b64 { Crypt::Digest::digest_file_b64('RIPEMD160', @_) }
	25	sub ripemd160_file_b64u { Crypt::Digest::digest_file_b64u('RIPEMD160', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/RIPEMD256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub ripemd256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub ripemd256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub ripemd256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub ripemd256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub ripemd256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub ripemd256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub ripemd256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub ripemd256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('RIPEMD256') }
	18	sub ripemd256 { Crypt::Digest::digest_data('RIPEMD256', @_) }
	19	sub ripemd256_hex { Crypt::Digest::digest_data_hex('RIPEMD256', @_) }
	20	sub ripemd256_b64 { Crypt::Digest::digest_data_b64('RIPEMD256', @_) }
	21	sub ripemd256_b64u { Crypt::Digest::digest_data_b64u('RIPEMD256', @_) }
	22	sub ripemd256_file { Crypt::Digest::digest_file('RIPEMD256', @_) }
	23	sub ripemd256_file_hex { Crypt::Digest::digest_file_hex('RIPEMD256', @_) }
	24	sub ripemd256_file_b64 { Crypt::Digest::digest_file_b64('RIPEMD256', @_) }
	25	sub ripemd256_file_b64u { Crypt::Digest::digest_file_b64u('RIPEMD256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/RIPEMD320.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub ripemd320 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub ripemd320_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub ripemd320_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub ripemd320_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub ripemd320_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub ripemd320_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub ripemd320_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub ripemd320_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('RIPEMD320') }
	18	sub ripemd320 { Crypt::Digest::digest_data('RIPEMD320', @_) }
	19	sub ripemd320_hex { Crypt::Digest::digest_data_hex('RIPEMD320', @_) }
	20	sub ripemd320_b64 { Crypt::Digest::digest_data_b64('RIPEMD320', @_) }
	21	sub ripemd320_b64u { Crypt::Digest::digest_data_b64u('RIPEMD320', @_) }
	22	sub ripemd320_file { Crypt::Digest::digest_file('RIPEMD320', @_) }
	23	sub ripemd320_file_hex { Crypt::Digest::digest_file_hex('RIPEMD320', @_) }
	24	sub ripemd320_file_b64 { Crypt::Digest::digest_file_b64('RIPEMD320', @_) }
	25	sub ripemd320_file_b64u { Crypt::Digest::digest_file_b64u('RIPEMD320', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA1.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha1 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha1_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha1_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha1_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha1_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha1_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha1_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha1_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA1') }
	18	sub sha1 { Crypt::Digest::digest_data('SHA1', @_) }
	19	sub sha1_hex { Crypt::Digest::digest_data_hex('SHA1', @_) }
	20	sub sha1_b64 { Crypt::Digest::digest_data_b64('SHA1', @_) }
	21	sub sha1_b64u { Crypt::Digest::digest_data_b64u('SHA1', @_) }
	22	sub sha1_file { Crypt::Digest::digest_file('SHA1', @_) }
	23	sub sha1_file_hex { Crypt::Digest::digest_file_hex('SHA1', @_) }
	24	sub sha1_file_b64 { Crypt::Digest::digest_file_b64('SHA1', @_) }
	25	sub sha1_file_b64u { Crypt::Digest::digest_file_b64u('SHA1', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA224.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA224') }
	18	sub sha224 { Crypt::Digest::digest_data('SHA224', @_) }
	19	sub sha224_hex { Crypt::Digest::digest_data_hex('SHA224', @_) }
	20	sub sha224_b64 { Crypt::Digest::digest_data_b64('SHA224', @_) }
	21	sub sha224_b64u { Crypt::Digest::digest_data_b64u('SHA224', @_) }
	22	sub sha224_file { Crypt::Digest::digest_file('SHA224', @_) }
	23	sub sha224_file_hex { Crypt::Digest::digest_file_hex('SHA224', @_) }
	24	sub sha224_file_b64 { Crypt::Digest::digest_file_b64('SHA224', @_) }
	25	sub sha224_file_b64u { Crypt::Digest::digest_file_b64u('SHA224', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA256') }
	18	sub sha256 { Crypt::Digest::digest_data('SHA256', @_) }
	19	sub sha256_hex { Crypt::Digest::digest_data_hex('SHA256', @_) }
	20	sub sha256_b64 { Crypt::Digest::digest_data_b64('SHA256', @_) }
	21	sub sha256_b64u { Crypt::Digest::digest_data_b64u('SHA256', @_) }
	22	sub sha256_file { Crypt::Digest::digest_file('SHA256', @_) }
	23	sub sha256_file_hex { Crypt::Digest::digest_file_hex('SHA256', @_) }
	24	sub sha256_file_b64 { Crypt::Digest::digest_file_b64('SHA256', @_) }
	25	sub sha256_file_b64u { Crypt::Digest::digest_file_b64u('SHA256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA384.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA384') }
	18	sub sha384 { Crypt::Digest::digest_data('SHA384', @_) }
	19	sub sha384_hex { Crypt::Digest::digest_data_hex('SHA384', @_) }
	20	sub sha384_b64 { Crypt::Digest::digest_data_b64('SHA384', @_) }
	21	sub sha384_b64u { Crypt::Digest::digest_data_b64u('SHA384', @_) }
	22	sub sha384_file { Crypt::Digest::digest_file('SHA384', @_) }
	23	sub sha384_file_hex { Crypt::Digest::digest_file_hex('SHA384', @_) }
	24	sub sha384_file_b64 { Crypt::Digest::digest_file_b64('SHA384', @_) }
	25	sub sha384_file_b64u { Crypt::Digest::digest_file_b64u('SHA384', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA3_224.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha3_224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha3_224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha3_224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha3_224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha3_224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha3_224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha3_224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha3_224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA3_224') }
	18	sub sha3_224 { Crypt::Digest::digest_data('SHA3_224', @_) }
	19	sub sha3_224_hex { Crypt::Digest::digest_data_hex('SHA3_224', @_) }
	20	sub sha3_224_b64 { Crypt::Digest::digest_data_b64('SHA3_224', @_) }
	21	sub sha3_224_b64u { Crypt::Digest::digest_data_b64u('SHA3_224', @_) }
	22	sub sha3_224_file { Crypt::Digest::digest_file('SHA3_224', @_) }
	23	sub sha3_224_file_hex { Crypt::Digest::digest_file_hex('SHA3_224', @_) }
	24	sub sha3_224_file_b64 { Crypt::Digest::digest_file_b64('SHA3_224', @_) }
	25	sub sha3_224_file_b64u { Crypt::Digest::digest_file_b64u('SHA3_224', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA3_256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha3_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha3_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha3_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha3_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha3_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha3_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha3_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha3_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA3_256') }
	18	sub sha3_256 { Crypt::Digest::digest_data('SHA3_256', @_) }
	19	sub sha3_256_hex { Crypt::Digest::digest_data_hex('SHA3_256', @_) }
	20	sub sha3_256_b64 { Crypt::Digest::digest_data_b64('SHA3_256', @_) }
	21	sub sha3_256_b64u { Crypt::Digest::digest_data_b64u('SHA3_256', @_) }
	22	sub sha3_256_file { Crypt::Digest::digest_file('SHA3_256', @_) }
	23	sub sha3_256_file_hex { Crypt::Digest::digest_file_hex('SHA3_256', @_) }
	24	sub sha3_256_file_b64 { Crypt::Digest::digest_file_b64('SHA3_256', @_) }
	25	sub sha3_256_file_b64u { Crypt::Digest::digest_file_b64u('SHA3_256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA3_384.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha3_384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha3_384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha3_384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha3_384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha3_384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha3_384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha3_384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha3_384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA3_384') }
	18	sub sha3_384 { Crypt::Digest::digest_data('SHA3_384', @_) }
	19	sub sha3_384_hex { Crypt::Digest::digest_data_hex('SHA3_384', @_) }
	20	sub sha3_384_b64 { Crypt::Digest::digest_data_b64('SHA3_384', @_) }
	21	sub sha3_384_b64u { Crypt::Digest::digest_data_b64u('SHA3_384', @_) }
	22	sub sha3_384_file { Crypt::Digest::digest_file('SHA3_384', @_) }
	23	sub sha3_384_file_hex { Crypt::Digest::digest_file_hex('SHA3_384', @_) }
	24	sub sha3_384_file_b64 { Crypt::Digest::digest_file_b64('SHA3_384', @_) }
	25	sub sha3_384_file_b64u { Crypt::Digest::digest_file_b64u('SHA3_384', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA3_512.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha3_512 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha3_512_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha3_512_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha3_512_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha3_512_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha3_512_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha3_512_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha3_512_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA3_512') }
	18	sub sha3_512 { Crypt::Digest::digest_data('SHA3_512', @_) }
	19	sub sha3_512_hex { Crypt::Digest::digest_data_hex('SHA3_512', @_) }
	20	sub sha3_512_b64 { Crypt::Digest::digest_data_b64('SHA3_512', @_) }
	21	sub sha3_512_b64u { Crypt::Digest::digest_data_b64u('SHA3_512', @_) }
	22	sub sha3_512_file { Crypt::Digest::digest_file('SHA3_512', @_) }
	23	sub sha3_512_file_hex { Crypt::Digest::digest_file_hex('SHA3_512', @_) }
	24	sub sha3_512_file_b64 { Crypt::Digest::digest_file_b64('SHA3_512', @_) }
	25	sub sha3_512_file_b64u { Crypt::Digest::digest_file_b64u('SHA3_512', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA512.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha512 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha512_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha512_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha512_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha512_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha512_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha512_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha512_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA512') }
	18	sub sha512 { Crypt::Digest::digest_data('SHA512', @_) }
	19	sub sha512_hex { Crypt::Digest::digest_data_hex('SHA512', @_) }
	20	sub sha512_b64 { Crypt::Digest::digest_data_b64('SHA512', @_) }
	21	sub sha512_b64u { Crypt::Digest::digest_data_b64u('SHA512', @_) }
	22	sub sha512_file { Crypt::Digest::digest_file('SHA512', @_) }
	23	sub sha512_file_hex { Crypt::Digest::digest_file_hex('SHA512', @_) }
	24	sub sha512_file_b64 { Crypt::Digest::digest_file_b64('SHA512', @_) }
	25	sub sha512_file_b64u { Crypt::Digest::digest_file_b64u('SHA512', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA512_224.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha512_224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha512_224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha512_224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha512_224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha512_224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha512_224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha512_224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha512_224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA512_224') }
	18	sub sha512_224 { Crypt::Digest::digest_data('SHA512_224', @_) }
	19	sub sha512_224_hex { Crypt::Digest::digest_data_hex('SHA512_224', @_) }
	20	sub sha512_224_b64 { Crypt::Digest::digest_data_b64('SHA512_224', @_) }
	21	sub sha512_224_b64u { Crypt::Digest::digest_data_b64u('SHA512_224', @_) }
	22	sub sha512_224_file { Crypt::Digest::digest_file('SHA512_224', @_) }
	23	sub sha512_224_file_hex { Crypt::Digest::digest_file_hex('SHA512_224', @_) }
	24	sub sha512_224_file_b64 { Crypt::Digest::digest_file_b64('SHA512_224', @_) }
	25	sub sha512_224_file_b64u { Crypt::Digest::digest_file_b64u('SHA512_224', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/SHA512_256.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub sha512_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub sha512_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub sha512_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub sha512_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub sha512_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub sha512_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub sha512_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub sha512_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('SHA512_256') }
	18	sub sha512_256 { Crypt::Digest::digest_data('SHA512_256', @_) }
	19	sub sha512_256_hex { Crypt::Digest::digest_data_hex('SHA512_256', @_) }
	20	sub sha512_256_b64 { Crypt::Digest::digest_data_b64('SHA512_256', @_) }
	21	sub sha512_256_b64u { Crypt::Digest::digest_data_b64u('SHA512_256', @_) }
	22	sub sha512_256_file { Crypt::Digest::digest_file('SHA512_256', @_) }
	23	sub sha512_256_file_hex { Crypt::Digest::digest_file_hex('SHA512_256', @_) }
	24	sub sha512_256_file_b64 { Crypt::Digest::digest_file_b64('SHA512_256', @_) }
	25	sub sha512_256_file_b64u { Crypt::Digest::digest_file_b64u('SHA512_256', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/Tiger192.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub tiger192 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub tiger192_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub tiger192_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub tiger192_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub tiger192_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub tiger192_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub tiger192_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub tiger192_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('Tiger192') }
	18	sub tiger192 { Crypt::Digest::digest_data('Tiger192', @_) }
	19	sub tiger192_hex { Crypt::Digest::digest_data_hex('Tiger192', @_) }
	20	sub tiger192_b64 { Crypt::Digest::digest_data_b64('Tiger192', @_) }
	21	sub tiger192_b64u { Crypt::Digest::digest_data_b64u('Tiger192', @_) }
	22	sub tiger192_file { Crypt::Digest::digest_file('Tiger192', @_) }
	23	sub tiger192_file_hex { Crypt::Digest::digest_file_hex('Tiger192', @_) }
	24	sub tiger192_file_b64 { Crypt::Digest::digest_file_b64('Tiger192', @_) }
	25	sub tiger192_file_b64u { Crypt::Digest::digest_file_b64u('Tiger192', @_) }
28	26
29	27	1;
30	28

+11

-13

lib/Crypt/Digest/Whirlpool.pm less more

12	12
13	13	use Carp;
14	14	$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16
17		sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
18
19		sub whirlpool { Crypt::Digest::digest_data(__PACKAGE__, @_) }
20		sub whirlpool_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
21		sub whirlpool_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
22		sub whirlpool_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
23
24		sub whirlpool_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
25		sub whirlpool_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
26		sub whirlpool_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
27		sub whirlpool_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
	15	use Crypt::Digest;
	16
	17	sub hashsize { Crypt::Digest::hashsize('Whirlpool') }
	18	sub whirlpool { Crypt::Digest::digest_data('Whirlpool', @_) }
	19	sub whirlpool_hex { Crypt::Digest::digest_data_hex('Whirlpool', @_) }
	20	sub whirlpool_b64 { Crypt::Digest::digest_data_b64('Whirlpool', @_) }
	21	sub whirlpool_b64u { Crypt::Digest::digest_data_b64u('Whirlpool', @_) }
	22	sub whirlpool_file { Crypt::Digest::digest_file('Whirlpool', @_) }
	23	sub whirlpool_file_hex { Crypt::Digest::digest_file_hex('Whirlpool', @_) }
	24	sub whirlpool_file_b64 { Crypt::Digest::digest_file_b64('Whirlpool', @_) }
	25	sub whirlpool_file_b64u { Crypt::Digest::digest_file_b64u('Whirlpool', @_) }
28	26
29	27	1;
30	28

+8

-0

lib/Crypt/Digest.pm less more

138	138	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a binary string.
139	139
140	140	$digest_raw = digest_data('SHA1', 'data string');
	141	#or
	142	$digest_raw = digest_data('SHA1', 'any data', 'more data', 'even more data');
141	143
142	144	=head2 digest_data_hex
143	145
144	146	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a hexadecimal string.
145	147
146	148	$digest_hex = digest_data_hex('SHA1', 'data string');
	149	#or
	150	$digest_hex = digest_data_hex('SHA1', 'any data', 'more data', 'even more data');
147	151
148	152	=head2 digest_data_b64
149	153
150	154	Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
151	155
152	156	$digest_b64 = digest_data_b64('SHA1', 'data string');
	157	#or
	158	$digest_b64 = digest_data_b64('SHA1', 'any data', 'more data', 'even more data');
153	159
154	160	=head2 digest_data_b64u
155	161
156	162	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).
157	163
158	164	$digest_b64url = digest_data_b64u('SHA1', 'data string');
	165	#or
	166	$digest_b64url = digest_data_b64u('SHA1', 'any data', 'more data', 'even more data');
159	167
160	168	=head2 digest_file
161	169

+10

-4

lib/Crypt/Mac/BLAKE2b.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( blake2b blake2b_hex blake2b_b64 blake2b_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its BLAKE2b message authentication code encoded as a binary string.
69	65
70	66	$blake2b_raw = blake2b($size, $key, 'data buffer');
	67	#or
	68	$blake2b_raw = blake2b($size, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 blake2b_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its BLAKE2b message authentication code encoded as a hexadecimal string.
75	73
76	74	$blake2b_hex = blake2b_hex($size, $key, 'data buffer');
	75	#or
	76	$blake2b_hex = blake2b_hex($size, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 blake2b_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its BLAKE2b message authentication code encoded as a Base64 string.
81	81
82	82	$blake2b_b64 = blake2b_b64($size, $key, 'data buffer');
	83	#or
	84	$blake2b_b64 = blake2b_b64($size, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 blake2b_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its BLAKE2b message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$blake2b_b64url = blake2b_b64u($size, $key, 'data buffer');
	91	#or
	92	$blake2b_b64url = blake2b_b64u($size, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/BLAKE2s.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( blake2s blake2s_hex blake2s_b64 blake2s_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its BLAKE2s message authentication code encoded as a binary string.
69	65
70	66	$blake2s_raw = blake2s($size, $key, 'data buffer');
	67	#or
	68	$blake2s_raw = blake2s($size, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 blake2s_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its BLAKE2s message authentication code encoded as a hexadecimal string.
75	73
76	74	$blake2s_hex = blake2s_hex($size, $key, 'data buffer');
	75	#or
	76	$blake2s_hex = blake2s_hex($size, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 blake2s_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its BLAKE2s message authentication code encoded as a Base64 string.
81	81
82	82	$blake2s_b64 = blake2s_b64($size, $key, 'data buffer');
	83	#or
	84	$blake2s_b64 = blake2s_b64($size, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 blake2s_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its BLAKE2s message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$blake2s_b64url = blake2s_b64u($size, $key, 'data buffer');
	91	#or
	92	$blake2s_b64url = blake2s_b64u($size, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/F9.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( f9 f9_hex f9_b64 f9_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its F9 message authentication code encoded as a binary string.
69	65
70	66	$f9_raw = f9($cipher_name, $key, 'data buffer');
	67	#or
	68	$f9_raw = f9($cipher_name, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 f9_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its F9 message authentication code encoded as a hexadecimal string.
75	73
76	74	$f9_hex = f9_hex($cipher_name, $key, 'data buffer');
	75	#or
	76	$f9_hex = f9_hex($cipher_name, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 f9_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its F9 message authentication code encoded as a Base64 string.
81	81
82	82	$f9_b64 = f9_b64($cipher_name, $key, 'data buffer');
	83	#or
	84	$f9_b64 = f9_b64($cipher_name, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 f9_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its F9 message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$f9_b64url = f9_b64u($cipher_name, $key, 'data buffer');
	91	#or
	92	$f9_b64url = f9_b64u($cipher_name, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/HMAC.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( hmac hmac_hex hmac_b64 hmac_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its HMAC message authentication code encoded as a binary string.
69	65
70	66	$hmac_raw = hmac($hash_name, $key, 'data buffer');
	67	#or
	68	$hmac_raw = hmac($hash_name, $key, 'any data', 'more data', 'even more data');
71	69
72	70	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
73	71	# $key ......... the key (octets/bytes)

77	75	Logically joins all arguments into a single string, and returns its HMAC message authentication code encoded as a hexadecimal string.
78	76
79	77	$hmac_hex = hmac_hex($hash_name, $key, 'data buffer');
	78	#or
	79	$hmac_hex = hmac_hex($hash_name, $key, 'any data', 'more data', 'even more data');
80	80
81	81	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
82	82	# $key ......... the key (octets/bytes, not hex!)

86	86	Logically joins all arguments into a single string, and returns its HMAC message authentication code encoded as a Base64 string.
87	87
88	88	$hmac_b64 = hmac_b64($hash_name, $key, 'data buffer');
	89	#or
	90	$hmac_b64 = hmac_b64($hash_name, $key, 'any data', 'more data', 'even more data');
89	91
90	92	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
91	93	# $key ......... the key (octets/bytes, not Base64!)

95	97	Logically joins all arguments into a single string, and returns its HMAC message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
96	98
97	99	$hmac_b64url = hmac_b64u($hash_name, $key, 'data buffer');
	100	#or
	101	$hmac_b64url = hmac_b64u($hash_name, $key, 'any data', 'more data', 'even more data');
98	102
99	103	# $hash_name ... any <NAME> for which there exists Crypt::Digest::<NAME>
100	104	# $key ......... the key (octets/bytes, not Base64url!)

119	123	=head2 add
120	124
121	125	$d->add('any data');
	126	#or
	127	$d->add('any data', 'more data', 'even more data');
122	128
123	129	=head2 addfile
124	130

+10

-4

lib/Crypt/Mac/OMAC.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( omac omac_hex omac_b64 omac_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its OMAC message authentication code encoded as a binary string.
69	65
70	66	$omac_raw = omac($cipher_name, $key, 'data buffer');
	67	#or
	68	$omac_raw = omac($cipher_name, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 omac_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its OMAC message authentication code encoded as a hexadecimal string.
75	73
76	74	$omac_hex = omac_hex($cipher_name, $key, 'data buffer');
	75	#or
	76	$omac_hex = omac_hex($cipher_name, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 omac_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its OMAC message authentication code encoded as a Base64 string.
81	81
82	82	$omac_b64 = omac_b64($cipher_name, $key, 'data buffer');
	83	#or
	84	$omac_b64 = omac_b64($cipher_name, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 omac_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its OMAC message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$omac_b64url = omac_b64u($cipher_name, $key, 'data buffer');
	91	#or
	92	$omac_b64url = omac_b64u($cipher_name, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/PMAC.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( pmac pmac_hex pmac_b64 pmac_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its PMAC message authentication code encoded as a binary string.
69	65
70	66	$pmac_raw = pmac($cipher_name, $key, 'data buffer');
	67	#or
	68	$pmac_raw = pmac($cipher_name, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 pmac_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its PMAC message authentication code encoded as a hexadecimal string.
75	73
76	74	$pmac_hex = pmac_hex($cipher_name, $key, 'data buffer');
	75	#or
	76	$pmac_hex = pmac_hex($cipher_name, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 pmac_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its PMAC message authentication code encoded as a Base64 string.
81	81
82	82	$pmac_b64 = pmac_b64($cipher_name, $key, 'data buffer');
	83	#or
	84	$pmac_b64 = pmac_b64($cipher_name, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 pmac_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its PMAC message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$pmac_b64url = pmac_b64u($cipher_name, $key, 'data buffer');
	91	#or
	92	$pmac_b64url = pmac_b64u($cipher_name, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/Pelican.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( pelican pelican_hex pelican_b64 pelican_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its Pelican message authentication code encoded as a binary string.
69	65
70	66	$pelican_raw = pelican($key, 'data buffer');
	67	#or
	68	$pelican_raw = pelican($key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 pelican_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its Pelican message authentication code encoded as a hexadecimal string.
75	73
76	74	$pelican_hex = pelican_hex($key, 'data buffer');
	75	#or
	76	$pelican_hex = pelican_hex($key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 pelican_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its Pelican message authentication code encoded as a Base64 string.
81	81
82	82	$pelican_b64 = pelican_b64($key, 'data buffer');
	83	#or
	84	$pelican_b64 = pelican_b64($key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 pelican_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its Pelican message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$pelican_b64url = pelican_b64u($key, 'data buffer');
	91	#or
	92	$pelican_b64url = pelican_b64u($key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/Poly1305.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( poly1305 poly1305_hex poly1305_b64 poly1305_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its Poly1305 message authentication code encoded as a binary string.
69	65
70	66	$poly1305_raw = poly1305($key, 'data buffer');
	67	#or
	68	$poly1305_raw = poly1305($key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 poly1305_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its Poly1305 message authentication code encoded as a hexadecimal string.
75	73
76	74	$poly1305_hex = poly1305_hex($key, 'data buffer');
	75	#or
	76	$poly1305_hex = poly1305_hex($key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 poly1305_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its Poly1305 message authentication code encoded as a Base64 string.
81	81
82	82	$poly1305_b64 = poly1305_b64($key, 'data buffer');
	83	#or
	84	$poly1305_b64 = poly1305_b64($key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 poly1305_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its Poly1305 message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$poly1305_b64url = poly1305_b64u($key, 'data buffer');
	91	#or
	92	$poly1305_b64url = poly1305_b64u($key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+10

-4

lib/Crypt/Mac/XCBC.pm less more

9	9	our %EXPORT_TAGS = ( all => [qw( xcbc xcbc_hex xcbc_b64 xcbc_b64u )] );
10	10	our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
11	11	our @EXPORT = qw();
12
13		use Carp;
14		$Carp::Internal{(__PACKAGE__)}++;
15		use CryptX;
16	12
17	13	1;
18	14

68	64	Logically joins all arguments into a single string, and returns its XCBC message authentication code encoded as a binary string.
69	65
70	66	$xcbc_raw = xcbc($cipher_name, $key, 'data buffer');
	67	#or
	68	$xcbc_raw = xcbc($cipher_name, $key, 'any data', 'more data', 'even more data');
71	69
72	70	=head2 xcbc_hex
73	71
74	72	Logically joins all arguments into a single string, and returns its XCBC message authentication code encoded as a hexadecimal string.
75	73
76	74	$xcbc_hex = xcbc_hex($cipher_name, $key, 'data buffer');
	75	#or
	76	$xcbc_hex = xcbc_hex($cipher_name, $key, 'any data', 'more data', 'even more data');
77	77
78	78	=head2 xcbc_b64
79	79
80	80	Logically joins all arguments into a single string, and returns its XCBC message authentication code encoded as a Base64 string.
81	81
82	82	$xcbc_b64 = xcbc_b64($cipher_name, $key, 'data buffer');
	83	#or
	84	$xcbc_b64 = xcbc_b64($cipher_name, $key, 'any data', 'more data', 'even more data');
83	85
84	86	=head2 xcbc_b64u
85	87
86	88	Logically joins all arguments into a single string, and returns its XCBC message authentication code encoded as a Base64 URL Safe string (see RFC 4648 section 5).
87	89
88	90	$xcbc_b64url = xcbc_b64u($cipher_name, $key, 'data buffer');
	91	#or
	92	$xcbc_b64url = xcbc_b64u($cipher_name, $key, 'any data', 'more data', 'even more data');
89	93
90	94	=head1 METHODS
91	95

104	108	=head2 add
105	109
106	110	$d->add('any data');
	111	#or
	112	$d->add('any data', 'more data', 'even more data');
107	113
108	114	=head2 addfile
109	115

+1

-15

lib/Crypt/Mac.pm less more

3	3	use warnings;
4	4	our $VERSION = '0.056_001';
5	5
6		require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7		our %EXPORT_TAGS = ( all => [qw( mac mac_hex )] );
8		our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
9		our @EXPORT = qw();
10
11	6	use Carp;
12	7	$Carp::Internal{(__PACKAGE__)}++;
13	8	use CryptX;
14
15		sub add {
16		my $self = shift;
17		local $SIG{__DIE__} = \&CryptX::_croak;
18		$self->_add_single($_) for (@_);
19		return $self;
20		}
21	9
22	10	sub addfile {
23	11	my ($self, $file) = @_;
24	12
25	13	my $handle;
26	14	if (ref(\$file) eq 'SCALAR') {
27		#filename
28	15	open($handle, "<", $file) \|\| die "FATAL: cannot open '$file': $!";
29	16	binmode($handle);
30	17	}
31	18	else {
32		#handle
33	19	$handle = $file
34	20	}
35	21	die "FATAL: invalid handle" unless defined $handle;

38	24	my $buf = "";
39	25	local $SIG{__DIE__} = \&CryptX::_croak;
40	26	while (($n = read($handle, $buf, 32*1024))) {
41		$self->_add_single($buf)
	27	$self->add($buf);
42	28	}
43	29	die "FATAL: read failed: $!" unless defined $n;
44	30

+2

-36

lib/Crypt/Mode.pm less more

9	9
10	10	sub encrypt {
11	11	my ($self, $pt) = (shift, shift);
12		$self->_start(1, @_);
13		return $self->add($pt) . $self->finish;
	12	$self->start_encrypt(@_)->_crypt($pt) . $self->finish;
14	13	}
15	14
16	15	sub decrypt {
17	16	my ($self, $ct) = (shift, shift);
18		$self->_start(-1, @_);
19		return $self->add($ct) . $self->finish;
20		}
21
22		sub start_encrypt {
23		my $self = shift;
24		$self->_start(1, @_);
25		return $self;
26		}
27
28		sub start_decrypt {
29		my $self = shift;
30		$self->_start(-1, @_);
31		return $self;
32		}
33
34		sub finish {
35		shift->_finish(@_);
	17	$self->start_decrypt(@_)->_crypt($ct) . $self->finish;
36	18	}
37	19
38	20	sub add {

40	22	my $rv = '';
41	23	$rv .= $self->_crypt($_) for (@_);
42	24	return $rv;
43		}
44
45		sub _crypt {
46		my $self = shift;
47		my $dir = $self->_get_dir;
48		return $self->_encrypt(@_) if $dir == 1;
49		return $self->_decrypt(@_) if $dir == -1;
50		return;
51		}
52
53		sub _finish {
54		my $self = shift;
55		my $dir = $self->_get_dir;
56		return $self->_finish_enc(@_) if $dir == 1;
57		return $self->_finish_dec(@_) if $dir == -1;
58		return;
59	25	}
60	26
61	27	sub CLONE_SKIP { 1 } # prevent cloning

+12

-1

t/digest_blake2b_160.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2b_160 qw( blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u );

13	13	is( Crypt::Digest::BLAKE2b_160->hashsize, 20, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2b_160')->hashsize, 20, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2b_160->new->hashsize, 20, 'hashsize/6');
	16
	17	is( blake2b_160("A","A","A"), pack("H*","14517ce78b0c7e5e5b7f096f1f3c046f01c46901"), 'blake2b_160 (raw/tripple_A)');
	18	is( blake2b_160_hex("A","A","A"), "14517ce78b0c7e5e5b7f096f1f3c046f01c46901", 'blake2b_160 (hex/tripple_A)');
	19	is( blake2b_160_b64("A","A","A"), "FFF854sMfl5bfwlvHzwEbwHEaQE=", 'blake2b_160 (base64/tripple_A)');
	20	is( blake2b_160_b64u("A","A","A"), "FFF854sMfl5bfwlvHzwEbwHEaQE", 'blake2b_160 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2b_160', "A","A","A"), pack("H*","14517ce78b0c7e5e5b7f096f1f3c046f01c46901"), 'blake2b_160 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2b_160', "A","A","A"), "14517ce78b0c7e5e5b7f096f1f3c046f01c46901", 'blake2b_160 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2b_160', "A","A","A"), "FFF854sMfl5bfwlvHzwEbwHEaQE=", 'blake2b_160 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2b_160', "A","A","A"), "FFF854sMfl5bfwlvHzwEbwHEaQE", 'blake2b_160 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2b_160->new->add("A","A","A")->hexdigest, "14517ce78b0c7e5e5b7f096f1f3c046f01c46901", 'blake2b_160 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2b_160->new->add("A")->add("A")->add("A")->hexdigest, "14517ce78b0c7e5e5b7f096f1f3c046f01c46901", 'blake2b_160 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2b_160(""), pack("H*","3345524abf6bbe1809449224b5972c41790b6cf2"), 'blake2b_160 (raw/1)');

+12

-1

t/digest_blake2b_256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2b_256 qw( blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u );

13	13	is( Crypt::Digest::BLAKE2b_256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2b_256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2b_256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( blake2b_256("A","A","A"), pack("H*","cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649"), 'blake2b_256 (raw/tripple_A)');
	18	is( blake2b_256_hex("A","A","A"), "cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649", 'blake2b_256 (hex/tripple_A)');
	19	is( blake2b_256_b64("A","A","A"), "zcQzkpZ1P5MKpFRwD9De1uHgh3LeqEmFnhfbvYXK5kk=", 'blake2b_256 (base64/tripple_A)');
	20	is( blake2b_256_b64u("A","A","A"), "zcQzkpZ1P5MKpFRwD9De1uHgh3LeqEmFnhfbvYXK5kk", 'blake2b_256 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2b_256', "A","A","A"), pack("H*","cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649"), 'blake2b_256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2b_256', "A","A","A"), "cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649", 'blake2b_256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2b_256', "A","A","A"), "zcQzkpZ1P5MKpFRwD9De1uHgh3LeqEmFnhfbvYXK5kk=", 'blake2b_256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2b_256', "A","A","A"), "zcQzkpZ1P5MKpFRwD9De1uHgh3LeqEmFnhfbvYXK5kk", 'blake2b_256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2b_256->new->add("A","A","A")->hexdigest, "cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649", 'blake2b_256 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2b_256->new->add("A")->add("A")->add("A")->hexdigest, "cdc4339296753f930aa454700fd0ded6e1e08772dea849859e17dbbd85cae649", 'blake2b_256 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2b_256(""), pack("H*","0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8"), 'blake2b_256 (raw/1)');

+12

-1

t/digest_blake2b_384.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2b_384 qw( blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u );

13	13	is( Crypt::Digest::BLAKE2b_384->hashsize, 48, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2b_384')->hashsize, 48, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2b_384->new->hashsize, 48, 'hashsize/6');
	16
	17	is( blake2b_384("A","A","A"), pack("H*","9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685"), 'blake2b_384 (raw/tripple_A)');
	18	is( blake2b_384_hex("A","A","A"), "9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685", 'blake2b_384 (hex/tripple_A)');
	19	is( blake2b_384_b64("A","A","A"), "mqB9nK8Xv/SXR/yUiOtrq83NV1YW+FqRdY7lDm5JpIhL9vtGtCTgrmaQcczYyxaF", 'blake2b_384 (base64/tripple_A)');
	20	is( blake2b_384_b64u("A","A","A"), "mqB9nK8Xv_SXR_yUiOtrq83NV1YW-FqRdY7lDm5JpIhL9vtGtCTgrmaQcczYyxaF", 'blake2b_384 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2b_384', "A","A","A"), pack("H*","9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685"), 'blake2b_384 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2b_384', "A","A","A"), "9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685", 'blake2b_384 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2b_384', "A","A","A"), "mqB9nK8Xv/SXR/yUiOtrq83NV1YW+FqRdY7lDm5JpIhL9vtGtCTgrmaQcczYyxaF", 'blake2b_384 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2b_384', "A","A","A"), "mqB9nK8Xv_SXR_yUiOtrq83NV1YW-FqRdY7lDm5JpIhL9vtGtCTgrmaQcczYyxaF", 'blake2b_384 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2b_384->new->add("A","A","A")->hexdigest, "9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685", 'blake2b_384 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2b_384->new->add("A")->add("A")->add("A")->hexdigest, "9aa07d9caf17bff49747fc9488eb6babcdcd575616f85a91758ee50e6e49a4884bf6fb46b424e0ae669071ccd8cb1685", 'blake2b_384 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2b_384(""), pack("H*","b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100"), 'blake2b_384 (raw/1)');

+12

-1

t/digest_blake2b_512.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2b_512 qw( blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u );

13	13	is( Crypt::Digest::BLAKE2b_512->hashsize, 64, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2b_512')->hashsize, 64, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2b_512->new->hashsize, 64, 'hashsize/6');
	16
	17	is( blake2b_512("A","A","A"), pack("H*","dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823"), 'blake2b_512 (raw/tripple_A)');
	18	is( blake2b_512_hex("A","A","A"), "dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823", 'blake2b_512 (hex/tripple_A)');
	19	is( blake2b_512_b64("A","A","A"), "3aXJKuWtugR9MX+Z3FipBZtajAkH+V2M3c9b/aqOTHTd2EvCaDzcLRajQP9XmOG/S9LIODMmEfJmu2KHDTO4Iw==", 'blake2b_512 (base64/tripple_A)');
	20	is( blake2b_512_b64u("A","A","A"), "3aXJKuWtugR9MX-Z3FipBZtajAkH-V2M3c9b_aqOTHTd2EvCaDzcLRajQP9XmOG_S9LIODMmEfJmu2KHDTO4Iw", 'blake2b_512 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2b_512', "A","A","A"), pack("H*","dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823"), 'blake2b_512 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2b_512', "A","A","A"), "dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823", 'blake2b_512 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2b_512', "A","A","A"), "3aXJKuWtugR9MX+Z3FipBZtajAkH+V2M3c9b/aqOTHTd2EvCaDzcLRajQP9XmOG/S9LIODMmEfJmu2KHDTO4Iw==", 'blake2b_512 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2b_512', "A","A","A"), "3aXJKuWtugR9MX-Z3FipBZtajAkH-V2M3c9b_aqOTHTd2EvCaDzcLRajQP9XmOG_S9LIODMmEfJmu2KHDTO4Iw", 'blake2b_512 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2b_512->new->add("A","A","A")->hexdigest, "dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823", 'blake2b_512 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2b_512->new->add("A")->add("A")->add("A")->hexdigest, "dda5c92ae5adba047d317f99dc58a9059b5a8c0907f95d8cddcf5bfdaa8e4c74ddd84bc2683cdc2d16a340ff5798e1bf4bd2c838332611f266bb62870d33b823", 'blake2b_512 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2b_512(""), pack("H*","786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce"), 'blake2b_512 (raw/1)');

+12

-1

t/digest_blake2s_128.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2s_128 qw( blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u );

13	13	is( Crypt::Digest::BLAKE2s_128->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2s_128')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2s_128->new->hashsize, 16, 'hashsize/6');
	16
	17	is( blake2s_128("A","A","A"), pack("H*","a2a5699c7579ee354f4d20fa75f09cb6"), 'blake2s_128 (raw/tripple_A)');
	18	is( blake2s_128_hex("A","A","A"), "a2a5699c7579ee354f4d20fa75f09cb6", 'blake2s_128 (hex/tripple_A)');
	19	is( blake2s_128_b64("A","A","A"), "oqVpnHV57jVPTSD6dfCctg==", 'blake2s_128 (base64/tripple_A)');
	20	is( blake2s_128_b64u("A","A","A"), "oqVpnHV57jVPTSD6dfCctg", 'blake2s_128 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2s_128', "A","A","A"), pack("H*","a2a5699c7579ee354f4d20fa75f09cb6"), 'blake2s_128 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2s_128', "A","A","A"), "a2a5699c7579ee354f4d20fa75f09cb6", 'blake2s_128 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2s_128', "A","A","A"), "oqVpnHV57jVPTSD6dfCctg==", 'blake2s_128 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2s_128', "A","A","A"), "oqVpnHV57jVPTSD6dfCctg", 'blake2s_128 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2s_128->new->add("A","A","A")->hexdigest, "a2a5699c7579ee354f4d20fa75f09cb6", 'blake2s_128 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2s_128->new->add("A")->add("A")->add("A")->hexdigest, "a2a5699c7579ee354f4d20fa75f09cb6", 'blake2s_128 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2s_128(""), pack("H*","64550d6ffe2c0a01a14aba1eade0200c"), 'blake2s_128 (raw/1)');

+12

-1

t/digest_blake2s_160.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2s_160 qw( blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u );

13	13	is( Crypt::Digest::BLAKE2s_160->hashsize, 20, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2s_160')->hashsize, 20, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2s_160->new->hashsize, 20, 'hashsize/6');
	16
	17	is( blake2s_160("A","A","A"), pack("H*","f44c709aebd62a7a13bd6ee5979981970a60e117"), 'blake2s_160 (raw/tripple_A)');
	18	is( blake2s_160_hex("A","A","A"), "f44c709aebd62a7a13bd6ee5979981970a60e117", 'blake2s_160 (hex/tripple_A)');
	19	is( blake2s_160_b64("A","A","A"), "9ExwmuvWKnoTvW7ll5mBlwpg4Rc=", 'blake2s_160 (base64/tripple_A)');
	20	is( blake2s_160_b64u("A","A","A"), "9ExwmuvWKnoTvW7ll5mBlwpg4Rc", 'blake2s_160 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2s_160', "A","A","A"), pack("H*","f44c709aebd62a7a13bd6ee5979981970a60e117"), 'blake2s_160 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2s_160', "A","A","A"), "f44c709aebd62a7a13bd6ee5979981970a60e117", 'blake2s_160 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2s_160', "A","A","A"), "9ExwmuvWKnoTvW7ll5mBlwpg4Rc=", 'blake2s_160 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2s_160', "A","A","A"), "9ExwmuvWKnoTvW7ll5mBlwpg4Rc", 'blake2s_160 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2s_160->new->add("A","A","A")->hexdigest, "f44c709aebd62a7a13bd6ee5979981970a60e117", 'blake2s_160 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2s_160->new->add("A")->add("A")->add("A")->hexdigest, "f44c709aebd62a7a13bd6ee5979981970a60e117", 'blake2s_160 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2s_160(""), pack("H*","354c9c33f735962418bdacb9479873429c34916f"), 'blake2s_160 (raw/1)');

+12

-1

t/digest_blake2s_224.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2s_224 qw( blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u );

13	13	is( Crypt::Digest::BLAKE2s_224->hashsize, 28, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2s_224')->hashsize, 28, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2s_224->new->hashsize, 28, 'hashsize/6');
	16
	17	is( blake2s_224("A","A","A"), pack("H*","8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006"), 'blake2s_224 (raw/tripple_A)');
	18	is( blake2s_224_hex("A","A","A"), "8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006", 'blake2s_224 (hex/tripple_A)');
	19	is( blake2s_224_b64("A","A","A"), "jCc44Y0LlkWHDX2ktSdWzvRsXz0YX06pPDYQBg==", 'blake2s_224 (base64/tripple_A)');
	20	is( blake2s_224_b64u("A","A","A"), "jCc44Y0LlkWHDX2ktSdWzvRsXz0YX06pPDYQBg", 'blake2s_224 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2s_224', "A","A","A"), pack("H*","8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006"), 'blake2s_224 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2s_224', "A","A","A"), "8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006", 'blake2s_224 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2s_224', "A","A","A"), "jCc44Y0LlkWHDX2ktSdWzvRsXz0YX06pPDYQBg==", 'blake2s_224 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2s_224', "A","A","A"), "jCc44Y0LlkWHDX2ktSdWzvRsXz0YX06pPDYQBg", 'blake2s_224 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2s_224->new->add("A","A","A")->hexdigest, "8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006", 'blake2s_224 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2s_224->new->add("A")->add("A")->add("A")->hexdigest, "8c2738e18d0b9645870d7da4b52756cef46c5f3d185f4ea93c361006", 'blake2s_224 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2s_224(""), pack("H*","1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4"), 'blake2s_224 (raw/1)');

+12

-1

t/digest_blake2s_256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::BLAKE2s_256 qw( blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u );

13	13	is( Crypt::Digest::BLAKE2s_256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('BLAKE2s_256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::BLAKE2s_256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( blake2s_256("A","A","A"), pack("H*","8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6"), 'blake2s_256 (raw/tripple_A)');
	18	is( blake2s_256_hex("A","A","A"), "8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6", 'blake2s_256 (hex/tripple_A)');
	19	is( blake2s_256_b64("A","A","A"), "jU/p9TaP85fOdERkD1IvCQWXWRwhOSJiE42mdQvx3/Y=", 'blake2s_256 (base64/tripple_A)');
	20	is( blake2s_256_b64u("A","A","A"), "jU_p9TaP85fOdERkD1IvCQWXWRwhOSJiE42mdQvx3_Y", 'blake2s_256 (base64url/tripple_A)');
	21	is( digest_data('BLAKE2s_256', "A","A","A"), pack("H*","8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6"), 'blake2s_256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('BLAKE2s_256', "A","A","A"), "8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6", 'blake2s_256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('BLAKE2s_256', "A","A","A"), "jU/p9TaP85fOdERkD1IvCQWXWRwhOSJiE42mdQvx3/Y=", 'blake2s_256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('BLAKE2s_256', "A","A","A"), "jU_p9TaP85fOdERkD1IvCQWXWRwhOSJiE42mdQvx3_Y", 'blake2s_256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::BLAKE2s_256->new->add("A","A","A")->hexdigest, "8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6", 'blake2s_256 (OO/tripple_A)');
	26	is( Crypt::Digest::BLAKE2s_256->new->add("A")->add("A")->add("A")->hexdigest, "8d4fe9f5368ff397ce7444640f522f090597591c21392262138da6750bf1dff6", 'blake2s_256 (OO3/tripple_A)');
16	27
17	28
18	29	is( blake2s_256(""), pack("H*","69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"), 'blake2s_256 (raw/1)');

+12

-1

t/digest_chaes.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::CHAES qw( chaes chaes_hex chaes_b64 chaes_b64u chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u );

13	13	is( Crypt::Digest::CHAES->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('CHAES')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::CHAES->new->hashsize, 16, 'hashsize/6');
	16
	17	is( chaes("A","A","A"), pack("H*","f01416b4c3f6389816b2fcd0b4cf9e41"), 'chaes (raw/tripple_A)');
	18	is( chaes_hex("A","A","A"), "f01416b4c3f6389816b2fcd0b4cf9e41", 'chaes (hex/tripple_A)');
	19	is( chaes_b64("A","A","A"), "8BQWtMP2OJgWsvzQtM+eQQ==", 'chaes (base64/tripple_A)');
	20	is( chaes_b64u("A","A","A"), "8BQWtMP2OJgWsvzQtM-eQQ", 'chaes (base64url/tripple_A)');
	21	is( digest_data('CHAES', "A","A","A"), pack("H*","f01416b4c3f6389816b2fcd0b4cf9e41"), 'chaes (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('CHAES', "A","A","A"), "f01416b4c3f6389816b2fcd0b4cf9e41", 'chaes (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('CHAES', "A","A","A"), "8BQWtMP2OJgWsvzQtM+eQQ==", 'chaes (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('CHAES', "A","A","A"), "8BQWtMP2OJgWsvzQtM-eQQ", 'chaes (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::CHAES->new->add("A","A","A")->hexdigest, "f01416b4c3f6389816b2fcd0b4cf9e41", 'chaes (OO/tripple_A)');
	26	is( Crypt::Digest::CHAES->new->add("A")->add("A")->add("A")->hexdigest, "f01416b4c3f6389816b2fcd0b4cf9e41", 'chaes (OO3/tripple_A)');
16	27
17	28
18	29	is( chaes(""), pack("H*","4047929f1f572643b55f829eb3291d11"), 'chaes (raw/1)');

+12

-1

t/digest_md2.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::MD2 qw( md2 md2_hex md2_b64 md2_b64u md2_file md2_file_hex md2_file_b64 md2_file_b64u );

13	13	is( Crypt::Digest::MD2->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('MD2')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::MD2->new->hashsize, 16, 'hashsize/6');
	16
	17	is( md2("A","A","A"), pack("H*","8788c1729761fdad983b830f04b19e86"), 'md2 (raw/tripple_A)');
	18	is( md2_hex("A","A","A"), "8788c1729761fdad983b830f04b19e86", 'md2 (hex/tripple_A)');
	19	is( md2_b64("A","A","A"), "h4jBcpdh/a2YO4MPBLGehg==", 'md2 (base64/tripple_A)');
	20	is( md2_b64u("A","A","A"), "h4jBcpdh_a2YO4MPBLGehg", 'md2 (base64url/tripple_A)');
	21	is( digest_data('MD2', "A","A","A"), pack("H*","8788c1729761fdad983b830f04b19e86"), 'md2 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('MD2', "A","A","A"), "8788c1729761fdad983b830f04b19e86", 'md2 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('MD2', "A","A","A"), "h4jBcpdh/a2YO4MPBLGehg==", 'md2 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('MD2', "A","A","A"), "h4jBcpdh_a2YO4MPBLGehg", 'md2 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::MD2->new->add("A","A","A")->hexdigest, "8788c1729761fdad983b830f04b19e86", 'md2 (OO/tripple_A)');
	26	is( Crypt::Digest::MD2->new->add("A")->add("A")->add("A")->hexdigest, "8788c1729761fdad983b830f04b19e86", 'md2 (OO3/tripple_A)');
16	27
17	28
18	29	is( md2(""), pack("H*","8350e5a3e24c153df2275c9f80692773"), 'md2 (raw/1)');

+12

-1

t/digest_md4.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::MD4 qw( md4 md4_hex md4_b64 md4_b64u md4_file md4_file_hex md4_file_b64 md4_file_b64u );

13	13	is( Crypt::Digest::MD4->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('MD4')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::MD4->new->hashsize, 16, 'hashsize/6');
	16
	17	is( md4("A","A","A"), pack("H*","17c3b38c112ac61c1f0d46555f379f14"), 'md4 (raw/tripple_A)');
	18	is( md4_hex("A","A","A"), "17c3b38c112ac61c1f0d46555f379f14", 'md4 (hex/tripple_A)');
	19	is( md4_b64("A","A","A"), "F8OzjBEqxhwfDUZVXzefFA==", 'md4 (base64/tripple_A)');
	20	is( md4_b64u("A","A","A"), "F8OzjBEqxhwfDUZVXzefFA", 'md4 (base64url/tripple_A)');
	21	is( digest_data('MD4', "A","A","A"), pack("H*","17c3b38c112ac61c1f0d46555f379f14"), 'md4 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('MD4', "A","A","A"), "17c3b38c112ac61c1f0d46555f379f14", 'md4 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('MD4', "A","A","A"), "F8OzjBEqxhwfDUZVXzefFA==", 'md4 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('MD4', "A","A","A"), "F8OzjBEqxhwfDUZVXzefFA", 'md4 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::MD4->new->add("A","A","A")->hexdigest, "17c3b38c112ac61c1f0d46555f379f14", 'md4 (OO/tripple_A)');
	26	is( Crypt::Digest::MD4->new->add("A")->add("A")->add("A")->hexdigest, "17c3b38c112ac61c1f0d46555f379f14", 'md4 (OO3/tripple_A)');
16	27
17	28
18	29	is( md4(""), pack("H*","31d6cfe0d16ae931b73c59d7e0c089c0"), 'md4 (raw/1)');

+12

-1

t/digest_md5.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::MD5 qw( md5 md5_hex md5_b64 md5_b64u md5_file md5_file_hex md5_file_b64 md5_file_b64u );

13	13	is( Crypt::Digest::MD5->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('MD5')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::MD5->new->hashsize, 16, 'hashsize/6');
	16
	17	is( md5("A","A","A"), pack("H*","e1faffb3e614e6c2fba74296962386b7"), 'md5 (raw/tripple_A)');
	18	is( md5_hex("A","A","A"), "e1faffb3e614e6c2fba74296962386b7", 'md5 (hex/tripple_A)');
	19	is( md5_b64("A","A","A"), "4fr/s+YU5sL7p0KWliOGtw==", 'md5 (base64/tripple_A)');
	20	is( md5_b64u("A","A","A"), "4fr_s-YU5sL7p0KWliOGtw", 'md5 (base64url/tripple_A)');
	21	is( digest_data('MD5', "A","A","A"), pack("H*","e1faffb3e614e6c2fba74296962386b7"), 'md5 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('MD5', "A","A","A"), "e1faffb3e614e6c2fba74296962386b7", 'md5 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('MD5', "A","A","A"), "4fr/s+YU5sL7p0KWliOGtw==", 'md5 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('MD5', "A","A","A"), "4fr_s-YU5sL7p0KWliOGtw", 'md5 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::MD5->new->add("A","A","A")->hexdigest, "e1faffb3e614e6c2fba74296962386b7", 'md5 (OO/tripple_A)');
	26	is( Crypt::Digest::MD5->new->add("A")->add("A")->add("A")->hexdigest, "e1faffb3e614e6c2fba74296962386b7", 'md5 (OO3/tripple_A)');
16	27
17	28
18	29	is( md5(""), pack("H*","d41d8cd98f00b204e9800998ecf8427e"), 'md5 (raw/1)');

+12

-1

t/digest_ripemd128.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::RIPEMD128 qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u );

13	13	is( Crypt::Digest::RIPEMD128->hashsize, 16, 'hashsize/4');
14	14	is( Crypt::Digest->new('RIPEMD128')->hashsize, 16, 'hashsize/5');
15	15	is( Crypt::Digest::RIPEMD128->new->hashsize, 16, 'hashsize/6');
	16
	17	is( ripemd128("A","A","A"), pack("H*","c2750c6ca0c35d367de2993c3f55e1df"), 'ripemd128 (raw/tripple_A)');
	18	is( ripemd128_hex("A","A","A"), "c2750c6ca0c35d367de2993c3f55e1df", 'ripemd128 (hex/tripple_A)');
	19	is( ripemd128_b64("A","A","A"), "wnUMbKDDXTZ94pk8P1Xh3w==", 'ripemd128 (base64/tripple_A)');
	20	is( ripemd128_b64u("A","A","A"), "wnUMbKDDXTZ94pk8P1Xh3w", 'ripemd128 (base64url/tripple_A)');
	21	is( digest_data('RIPEMD128', "A","A","A"), pack("H*","c2750c6ca0c35d367de2993c3f55e1df"), 'ripemd128 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('RIPEMD128', "A","A","A"), "c2750c6ca0c35d367de2993c3f55e1df", 'ripemd128 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('RIPEMD128', "A","A","A"), "wnUMbKDDXTZ94pk8P1Xh3w==", 'ripemd128 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('RIPEMD128', "A","A","A"), "wnUMbKDDXTZ94pk8P1Xh3w", 'ripemd128 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::RIPEMD128->new->add("A","A","A")->hexdigest, "c2750c6ca0c35d367de2993c3f55e1df", 'ripemd128 (OO/tripple_A)');
	26	is( Crypt::Digest::RIPEMD128->new->add("A")->add("A")->add("A")->hexdigest, "c2750c6ca0c35d367de2993c3f55e1df", 'ripemd128 (OO3/tripple_A)');
16	27
17	28
18	29	is( ripemd128(""), pack("H*","cdf26213a150dc3ecb610f18f6b38b46"), 'ripemd128 (raw/1)');

+12

-1

t/digest_ripemd160.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::RIPEMD160 qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u );

13	13	is( Crypt::Digest::RIPEMD160->hashsize, 20, 'hashsize/4');
14	14	is( Crypt::Digest->new('RIPEMD160')->hashsize, 20, 'hashsize/5');
15	15	is( Crypt::Digest::RIPEMD160->new->hashsize, 20, 'hashsize/6');
	16
	17	is( ripemd160("A","A","A"), pack("H*","e4e130acc1d2a5a63c17efb1eedbd02be28443d1"), 'ripemd160 (raw/tripple_A)');
	18	is( ripemd160_hex("A","A","A"), "e4e130acc1d2a5a63c17efb1eedbd02be28443d1", 'ripemd160 (hex/tripple_A)');
	19	is( ripemd160_b64("A","A","A"), "5OEwrMHSpaY8F++x7tvQK+KEQ9E=", 'ripemd160 (base64/tripple_A)');
	20	is( ripemd160_b64u("A","A","A"), "5OEwrMHSpaY8F--x7tvQK-KEQ9E", 'ripemd160 (base64url/tripple_A)');
	21	is( digest_data('RIPEMD160', "A","A","A"), pack("H*","e4e130acc1d2a5a63c17efb1eedbd02be28443d1"), 'ripemd160 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('RIPEMD160', "A","A","A"), "e4e130acc1d2a5a63c17efb1eedbd02be28443d1", 'ripemd160 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('RIPEMD160', "A","A","A"), "5OEwrMHSpaY8F++x7tvQK+KEQ9E=", 'ripemd160 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('RIPEMD160', "A","A","A"), "5OEwrMHSpaY8F--x7tvQK-KEQ9E", 'ripemd160 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::RIPEMD160->new->add("A","A","A")->hexdigest, "e4e130acc1d2a5a63c17efb1eedbd02be28443d1", 'ripemd160 (OO/tripple_A)');
	26	is( Crypt::Digest::RIPEMD160->new->add("A")->add("A")->add("A")->hexdigest, "e4e130acc1d2a5a63c17efb1eedbd02be28443d1", 'ripemd160 (OO3/tripple_A)');
16	27
17	28
18	29	is( ripemd160(""), pack("H*","9c1185a5c5e9fc54612808977ee8f548b2258d31"), 'ripemd160 (raw/1)');

+12

-1

t/digest_ripemd256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::RIPEMD256 qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u );

13	13	is( Crypt::Digest::RIPEMD256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('RIPEMD256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::RIPEMD256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( ripemd256("A","A","A"), pack("H*","0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82"), 'ripemd256 (raw/tripple_A)');
	18	is( ripemd256_hex("A","A","A"), "0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82", 'ripemd256 (hex/tripple_A)');
	19	is( ripemd256_b64("A","A","A"), "DJdlgmMUNdT7xCR1gQWgWmIq4ncm85V3SFjX6isvXYI=", 'ripemd256 (base64/tripple_A)');
	20	is( ripemd256_b64u("A","A","A"), "DJdlgmMUNdT7xCR1gQWgWmIq4ncm85V3SFjX6isvXYI", 'ripemd256 (base64url/tripple_A)');
	21	is( digest_data('RIPEMD256', "A","A","A"), pack("H*","0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82"), 'ripemd256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('RIPEMD256', "A","A","A"), "0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82", 'ripemd256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('RIPEMD256', "A","A","A"), "DJdlgmMUNdT7xCR1gQWgWmIq4ncm85V3SFjX6isvXYI=", 'ripemd256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('RIPEMD256', "A","A","A"), "DJdlgmMUNdT7xCR1gQWgWmIq4ncm85V3SFjX6isvXYI", 'ripemd256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::RIPEMD256->new->add("A","A","A")->hexdigest, "0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82", 'ripemd256 (OO/tripple_A)');
	26	is( Crypt::Digest::RIPEMD256->new->add("A")->add("A")->add("A")->hexdigest, "0c976582631435d4fbc424758105a05a622ae27726f395774858d7ea2b2f5d82", 'ripemd256 (OO3/tripple_A)');
16	27
17	28
18	29	is( ripemd256(""), pack("H*","02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d"), 'ripemd256 (raw/1)');

+12

-1

t/digest_ripemd320.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::RIPEMD320 qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u );

13	13	is( Crypt::Digest::RIPEMD320->hashsize, 40, 'hashsize/4');
14	14	is( Crypt::Digest->new('RIPEMD320')->hashsize, 40, 'hashsize/5');
15	15	is( Crypt::Digest::RIPEMD320->new->hashsize, 40, 'hashsize/6');
	16
	17	is( ripemd320("A","A","A"), pack("H*","4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60"), 'ripemd320 (raw/tripple_A)');
	18	is( ripemd320_hex("A","A","A"), "4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60", 'ripemd320 (hex/tripple_A)');
	19	is( ripemd320_b64("A","A","A"), "TPNLKIfx3RVD+wzpUL8VX7fJPGPWGtxn6FjBCD/VTkp+HasbmzO6YA==", 'ripemd320 (base64/tripple_A)');
	20	is( ripemd320_b64u("A","A","A"), "TPNLKIfx3RVD-wzpUL8VX7fJPGPWGtxn6FjBCD_VTkp-HasbmzO6YA", 'ripemd320 (base64url/tripple_A)');
	21	is( digest_data('RIPEMD320', "A","A","A"), pack("H*","4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60"), 'ripemd320 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('RIPEMD320', "A","A","A"), "4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60", 'ripemd320 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('RIPEMD320', "A","A","A"), "TPNLKIfx3RVD+wzpUL8VX7fJPGPWGtxn6FjBCD/VTkp+HasbmzO6YA==", 'ripemd320 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('RIPEMD320', "A","A","A"), "TPNLKIfx3RVD-wzpUL8VX7fJPGPWGtxn6FjBCD_VTkp-HasbmzO6YA", 'ripemd320 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::RIPEMD320->new->add("A","A","A")->hexdigest, "4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60", 'ripemd320 (OO/tripple_A)');
	26	is( Crypt::Digest::RIPEMD320->new->add("A")->add("A")->add("A")->hexdigest, "4cf34b2887f1dd1543fb0ce950bf155fb7c93c63d61adc67e858c1083fd54e4a7e1dab1b9b33ba60", 'ripemd320 (OO3/tripple_A)');
16	27
17	28
18	29	is( ripemd320(""), pack("H*","22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8"), 'ripemd320 (raw/1)');

+12

-1

t/digest_sha1.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA1 qw( sha1 sha1_hex sha1_b64 sha1_b64u sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u );

13	13	is( Crypt::Digest::SHA1->hashsize, 20, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA1')->hashsize, 20, 'hashsize/5');
15	15	is( Crypt::Digest::SHA1->new->hashsize, 20, 'hashsize/6');
	16
	17	is( sha1("A","A","A"), pack("H*","606ec6e9bd8a8ff2ad14e5fade3f264471e82251"), 'sha1 (raw/tripple_A)');
	18	is( sha1_hex("A","A","A"), "606ec6e9bd8a8ff2ad14e5fade3f264471e82251", 'sha1 (hex/tripple_A)');
	19	is( sha1_b64("A","A","A"), "YG7G6b2Kj/KtFOX63j8mRHHoIlE=", 'sha1 (base64/tripple_A)');
	20	is( sha1_b64u("A","A","A"), "YG7G6b2Kj_KtFOX63j8mRHHoIlE", 'sha1 (base64url/tripple_A)');
	21	is( digest_data('SHA1', "A","A","A"), pack("H*","606ec6e9bd8a8ff2ad14e5fade3f264471e82251"), 'sha1 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA1', "A","A","A"), "606ec6e9bd8a8ff2ad14e5fade3f264471e82251", 'sha1 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA1', "A","A","A"), "YG7G6b2Kj/KtFOX63j8mRHHoIlE=", 'sha1 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA1', "A","A","A"), "YG7G6b2Kj_KtFOX63j8mRHHoIlE", 'sha1 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA1->new->add("A","A","A")->hexdigest, "606ec6e9bd8a8ff2ad14e5fade3f264471e82251", 'sha1 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA1->new->add("A")->add("A")->add("A")->hexdigest, "606ec6e9bd8a8ff2ad14e5fade3f264471e82251", 'sha1 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha1(""), pack("H*","da39a3ee5e6b4b0d3255bfef95601890afd80709"), 'sha1 (raw/1)');

+12

-1

t/digest_sha224.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA224 qw( sha224 sha224_hex sha224_b64 sha224_b64u sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u );

13	13	is( Crypt::Digest::SHA224->hashsize, 28, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA224')->hashsize, 28, 'hashsize/5');
15	15	is( Crypt::Digest::SHA224->new->hashsize, 28, 'hashsize/6');
	16
	17	is( sha224("A","A","A"), pack("H*","808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018"), 'sha224 (raw/tripple_A)');
	18	is( sha224_hex("A","A","A"), "808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018", 'sha224 (hex/tripple_A)');
	19	is( sha224_b64("A","A","A"), "gIdRr195NvINHHlQjZjAeeQuwmgC7iOKWkhgGA==", 'sha224 (base64/tripple_A)');
	20	is( sha224_b64u("A","A","A"), "gIdRr195NvINHHlQjZjAeeQuwmgC7iOKWkhgGA", 'sha224 (base64url/tripple_A)');
	21	is( digest_data('SHA224', "A","A","A"), pack("H*","808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018"), 'sha224 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA224', "A","A","A"), "808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018", 'sha224 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA224', "A","A","A"), "gIdRr195NvINHHlQjZjAeeQuwmgC7iOKWkhgGA==", 'sha224 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA224', "A","A","A"), "gIdRr195NvINHHlQjZjAeeQuwmgC7iOKWkhgGA", 'sha224 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA224->new->add("A","A","A")->hexdigest, "808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018", 'sha224 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA224->new->add("A")->add("A")->add("A")->hexdigest, "808751af5f7936f20d1c79508d98c079e42ec26802ee238a5a486018", 'sha224 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha224(""), pack("H*","d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"), 'sha224 (raw/1)');

+12

-1

t/digest_sha256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA256 qw( sha256 sha256_hex sha256_b64 sha256_b64u sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u );

13	13	is( Crypt::Digest::SHA256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::SHA256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( sha256("A","A","A"), pack("H*","cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358"), 'sha256 (raw/tripple_A)');
	18	is( sha256_hex("A","A","A"), "cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358", 'sha256 (hex/tripple_A)');
	19	is( sha256_b64("A","A","A"), "yxrSEZ2Pr7aVZlEO5xJmH58UuDOFAG75KuxH9SOjg1g=", 'sha256 (base64/tripple_A)');
	20	is( sha256_b64u("A","A","A"), "yxrSEZ2Pr7aVZlEO5xJmH58UuDOFAG75KuxH9SOjg1g", 'sha256 (base64url/tripple_A)');
	21	is( digest_data('SHA256', "A","A","A"), pack("H*","cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358"), 'sha256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA256', "A","A","A"), "cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358", 'sha256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA256', "A","A","A"), "yxrSEZ2Pr7aVZlEO5xJmH58UuDOFAG75KuxH9SOjg1g=", 'sha256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA256', "A","A","A"), "yxrSEZ2Pr7aVZlEO5xJmH58UuDOFAG75KuxH9SOjg1g", 'sha256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA256->new->add("A","A","A")->hexdigest, "cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358", 'sha256 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA256->new->add("A")->add("A")->add("A")->hexdigest, "cb1ad2119d8fafb69566510ee712661f9f14b83385006ef92aec47f523a38358", 'sha256 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha256(""), pack("H*","e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), 'sha256 (raw/1)');

+12

-1

t/digest_sha384.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA384 qw( sha384 sha384_hex sha384_b64 sha384_b64u sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u );

13	13	is( Crypt::Digest::SHA384->hashsize, 48, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA384')->hashsize, 48, 'hashsize/5');
15	15	is( Crypt::Digest::SHA384->new->hashsize, 48, 'hashsize/6');
	16
	17	is( sha384("A","A","A"), pack("H*","8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe"), 'sha384 (raw/tripple_A)');
	18	is( sha384_hex("A","A","A"), "8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe", 'sha384 (hex/tripple_A)');
	19	is( sha384_b64("A","A","A"), "ilt8GbzRcE1SH4a5YY2G3g7Uj6KXEa1NFiMPfSazYRG+r3/v6LO+ehfODhQMoAL+", 'sha384 (base64/tripple_A)');
	20	is( sha384_b64u("A","A","A"), "ilt8GbzRcE1SH4a5YY2G3g7Uj6KXEa1NFiMPfSazYRG-r3_v6LO-ehfODhQMoAL-", 'sha384 (base64url/tripple_A)');
	21	is( digest_data('SHA384', "A","A","A"), pack("H*","8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe"), 'sha384 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA384', "A","A","A"), "8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe", 'sha384 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA384', "A","A","A"), "ilt8GbzRcE1SH4a5YY2G3g7Uj6KXEa1NFiMPfSazYRG+r3/v6LO+ehfODhQMoAL+", 'sha384 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA384', "A","A","A"), "ilt8GbzRcE1SH4a5YY2G3g7Uj6KXEa1NFiMPfSazYRG-r3_v6LO-ehfODhQMoAL-", 'sha384 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA384->new->add("A","A","A")->hexdigest, "8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe", 'sha384 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA384->new->add("A")->add("A")->add("A")->hexdigest, "8a5b7c19bcd1704d521f86b9618d86de0ed48fa29711ad4d16230f7d26b36111beaf7fefe8b3be7a17ce0e140ca002fe", 'sha384 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha384(""), pack("H*","38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"), 'sha384 (raw/1)');

+12

-1

t/digest_sha3_224.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA3_224 qw( sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u );

13	13	is( Crypt::Digest::SHA3_224->hashsize, 28, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA3_224')->hashsize, 28, 'hashsize/5');
15	15	is( Crypt::Digest::SHA3_224->new->hashsize, 28, 'hashsize/6');
	16
	17	is( sha3_224("A","A","A"), pack("H*","c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b"), 'sha3_224 (raw/tripple_A)');
	18	is( sha3_224_hex("A","A","A"), "c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b", 'sha3_224 (hex/tripple_A)');
	19	is( sha3_224_b64("A","A","A"), "wJ1a99mgIcSEBBIY88N4f9QnS2T/0BLtyg/lWw==", 'sha3_224 (base64/tripple_A)');
	20	is( sha3_224_b64u("A","A","A"), "wJ1a99mgIcSEBBIY88N4f9QnS2T_0BLtyg_lWw", 'sha3_224 (base64url/tripple_A)');
	21	is( digest_data('SHA3_224', "A","A","A"), pack("H*","c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b"), 'sha3_224 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA3_224', "A","A","A"), "c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b", 'sha3_224 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA3_224', "A","A","A"), "wJ1a99mgIcSEBBIY88N4f9QnS2T/0BLtyg/lWw==", 'sha3_224 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA3_224', "A","A","A"), "wJ1a99mgIcSEBBIY88N4f9QnS2T_0BLtyg_lWw", 'sha3_224 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA3_224->new->add("A","A","A")->hexdigest, "c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b", 'sha3_224 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA3_224->new->add("A")->add("A")->add("A")->hexdigest, "c09d5af7d9a021c484041218f3c3787fd4274b64ffd012edca0fe55b", 'sha3_224 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha3_224(""), pack("H*","6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7"), 'sha3_224 (raw/1)');

+12

-1

t/digest_sha3_256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA3_256 qw( sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u );

13	13	is( Crypt::Digest::SHA3_256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA3_256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::SHA3_256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( sha3_256("A","A","A"), pack("H*","7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa"), 'sha3_256 (raw/tripple_A)');
	18	is( sha3_256_hex("A","A","A"), "7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa", 'sha3_256 (hex/tripple_A)');
	19	is( sha3_256_b64("A","A","A"), "fcuCeh9afL6kI+djp90MeCTjUSx/HOSM1XEPYDtPHvo=", 'sha3_256 (base64/tripple_A)');
	20	is( sha3_256_b64u("A","A","A"), "fcuCeh9afL6kI-djp90MeCTjUSx_HOSM1XEPYDtPHvo", 'sha3_256 (base64url/tripple_A)');
	21	is( digest_data('SHA3_256', "A","A","A"), pack("H*","7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa"), 'sha3_256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA3_256', "A","A","A"), "7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa", 'sha3_256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA3_256', "A","A","A"), "fcuCeh9afL6kI+djp90MeCTjUSx/HOSM1XEPYDtPHvo=", 'sha3_256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA3_256', "A","A","A"), "fcuCeh9afL6kI-djp90MeCTjUSx_HOSM1XEPYDtPHvo", 'sha3_256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA3_256->new->add("A","A","A")->hexdigest, "7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa", 'sha3_256 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA3_256->new->add("A")->add("A")->add("A")->hexdigest, "7dcb827a1f5a7cbea423e763a7dd0c7824e3512c7f1ce48cd5710f603b4f1efa", 'sha3_256 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha3_256(""), pack("H*","a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"), 'sha3_256 (raw/1)');

+12

-1

t/digest_sha3_384.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA3_384 qw( sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u );

13	13	is( Crypt::Digest::SHA3_384->hashsize, 48, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA3_384')->hashsize, 48, 'hashsize/5');
15	15	is( Crypt::Digest::SHA3_384->new->hashsize, 48, 'hashsize/6');
	16
	17	is( sha3_384("A","A","A"), pack("H*","3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4"), 'sha3_384 (raw/tripple_A)');
	18	is( sha3_384_hex("A","A","A"), "3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4", 'sha3_384 (hex/tripple_A)');
	19	is( sha3_384_b64("A","A","A"), "NVXtimNLI1+wemkeGTSz6BIoyFm8HBes3rtLq4LNY/BuF8rtWFUztGFbxuP7LgvE", 'sha3_384 (base64/tripple_A)');
	20	is( sha3_384_b64u("A","A","A"), "NVXtimNLI1-wemkeGTSz6BIoyFm8HBes3rtLq4LNY_BuF8rtWFUztGFbxuP7LgvE", 'sha3_384 (base64url/tripple_A)');
	21	is( digest_data('SHA3_384', "A","A","A"), pack("H*","3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4"), 'sha3_384 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA3_384', "A","A","A"), "3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4", 'sha3_384 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA3_384', "A","A","A"), "NVXtimNLI1+wemkeGTSz6BIoyFm8HBes3rtLq4LNY/BuF8rtWFUztGFbxuP7LgvE", 'sha3_384 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA3_384', "A","A","A"), "NVXtimNLI1-wemkeGTSz6BIoyFm8HBes3rtLq4LNY_BuF8rtWFUztGFbxuP7LgvE", 'sha3_384 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA3_384->new->add("A","A","A")->hexdigest, "3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4", 'sha3_384 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA3_384->new->add("A")->add("A")->add("A")->hexdigest, "3555ed8a634b235fb07a691e1934b3e81228c859bc1c17acdebb4bab82cd63f06e17caed585533b4615bc6e3fb2e0bc4", 'sha3_384 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha3_384(""), pack("H*","0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004"), 'sha3_384 (raw/1)');

+12

-1

t/digest_sha3_512.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA3_512 qw( sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u );

13	13	is( Crypt::Digest::SHA3_512->hashsize, 64, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA3_512')->hashsize, 64, 'hashsize/5');
15	15	is( Crypt::Digest::SHA3_512->new->hashsize, 64, 'hashsize/6');
	16
	17	is( sha3_512("A","A","A"), pack("H*","852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857"), 'sha3_512 (raw/tripple_A)');
	18	is( sha3_512_hex("A","A","A"), "852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857", 'sha3_512 (hex/tripple_A)');
	19	is( sha3_512_b64("A","A","A"), "hSz0TrjThxXIR5drbeUmVkE211b6mbStWoJf1uO6XYkce0V2sRQQpulR//ozmbFL4dpCItU7WjX/I21lmJnoVw==", 'sha3_512 (base64/tripple_A)');
	20	is( sha3_512_b64u("A","A","A"), "hSz0TrjThxXIR5drbeUmVkE211b6mbStWoJf1uO6XYkce0V2sRQQpulR__ozmbFL4dpCItU7WjX_I21lmJnoVw", 'sha3_512 (base64url/tripple_A)');
	21	is( digest_data('SHA3_512', "A","A","A"), pack("H*","852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857"), 'sha3_512 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA3_512', "A","A","A"), "852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857", 'sha3_512 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA3_512', "A","A","A"), "hSz0TrjThxXIR5drbeUmVkE211b6mbStWoJf1uO6XYkce0V2sRQQpulR//ozmbFL4dpCItU7WjX/I21lmJnoVw==", 'sha3_512 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA3_512', "A","A","A"), "hSz0TrjThxXIR5drbeUmVkE211b6mbStWoJf1uO6XYkce0V2sRQQpulR__ozmbFL4dpCItU7WjX_I21lmJnoVw", 'sha3_512 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA3_512->new->add("A","A","A")->hexdigest, "852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857", 'sha3_512 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA3_512->new->add("A")->add("A")->add("A")->hexdigest, "852cf44eb8d38715c847976b6de526564136d756fa99b4ad5a825fd6e3ba5d891c7b4576b11410a6e951fffa3399b14be1da4222d53b5a35ff236d659899e857", 'sha3_512 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha3_512(""), pack("H*","a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"), 'sha3_512 (raw/1)');

+12

-1

t/digest_sha512.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA512 qw( sha512 sha512_hex sha512_b64 sha512_b64u sha512_file sha512_file_hex sha512_file_b64 sha512_file_b64u );

13	13	is( Crypt::Digest::SHA512->hashsize, 64, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA512')->hashsize, 64, 'hashsize/5');
15	15	is( Crypt::Digest::SHA512->new->hashsize, 64, 'hashsize/6');
	16
	17	is( sha512("A","A","A"), pack("H*","8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385"), 'sha512 (raw/tripple_A)');
	18	is( sha512_hex("A","A","A"), "8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385", 'sha512 (hex/tripple_A)');
	19	is( sha512_b64("A","A","A"), "jXCNGLVN85YtaW8GmtQtrXditdTTyX7l+i2uBnPtRlRRZMB4uNs9WcS5YCDkMW8Xuz2Rvx9rwIlrvnVBbrjDhQ==", 'sha512 (base64/tripple_A)');
	20	is( sha512_b64u("A","A","A"), "jXCNGLVN85YtaW8GmtQtrXditdTTyX7l-i2uBnPtRlRRZMB4uNs9WcS5YCDkMW8Xuz2Rvx9rwIlrvnVBbrjDhQ", 'sha512 (base64url/tripple_A)');
	21	is( digest_data('SHA512', "A","A","A"), pack("H*","8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385"), 'sha512 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA512', "A","A","A"), "8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385", 'sha512 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA512', "A","A","A"), "jXCNGLVN85YtaW8GmtQtrXditdTTyX7l+i2uBnPtRlRRZMB4uNs9WcS5YCDkMW8Xuz2Rvx9rwIlrvnVBbrjDhQ==", 'sha512 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA512', "A","A","A"), "jXCNGLVN85YtaW8GmtQtrXditdTTyX7l-i2uBnPtRlRRZMB4uNs9WcS5YCDkMW8Xuz2Rvx9rwIlrvnVBbrjDhQ", 'sha512 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA512->new->add("A","A","A")->hexdigest, "8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385", 'sha512 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA512->new->add("A")->add("A")->add("A")->hexdigest, "8d708d18b54df3962d696f069ad42dad7762b5d4d3c97ee5fa2dae0673ed46545164c078b8db3d59c4b96020e4316f17bb3d91bf1f6bc0896bbe75416eb8c385", 'sha512 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha512(""), pack("H*","cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), 'sha512 (raw/1)');

+12

-1

t/digest_sha512_224.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA512_224 qw( sha512_224 sha512_224_hex sha512_224_b64 sha512_224_b64u sha512_224_file sha512_224_file_hex sha512_224_file_b64 sha512_224_file_b64u );

13	13	is( Crypt::Digest::SHA512_224->hashsize, 28, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA512_224')->hashsize, 28, 'hashsize/5');
15	15	is( Crypt::Digest::SHA512_224->new->hashsize, 28, 'hashsize/6');
	16
	17	is( sha512_224("A","A","A"), pack("H*","3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3"), 'sha512_224 (raw/tripple_A)');
	18	is( sha512_224_hex("A","A","A"), "3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3", 'sha512_224 (hex/tripple_A)');
	19	is( sha512_224_b64("A","A","A"), "PVoLdC9MYdMVxs6GRXqfowkDiA0wVYxozkcTsw==", 'sha512_224 (base64/tripple_A)');
	20	is( sha512_224_b64u("A","A","A"), "PVoLdC9MYdMVxs6GRXqfowkDiA0wVYxozkcTsw", 'sha512_224 (base64url/tripple_A)');
	21	is( digest_data('SHA512_224', "A","A","A"), pack("H*","3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3"), 'sha512_224 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA512_224', "A","A","A"), "3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3", 'sha512_224 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA512_224', "A","A","A"), "PVoLdC9MYdMVxs6GRXqfowkDiA0wVYxozkcTsw==", 'sha512_224 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA512_224', "A","A","A"), "PVoLdC9MYdMVxs6GRXqfowkDiA0wVYxozkcTsw", 'sha512_224 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA512_224->new->add("A","A","A")->hexdigest, "3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3", 'sha512_224 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA512_224->new->add("A")->add("A")->add("A")->hexdigest, "3d5a0b742f4c61d315c6ce86457a9fa30903880d30558c68ce4713b3", 'sha512_224 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha512_224(""), pack("H*","6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4"), 'sha512_224 (raw/1)');

+12

-1

t/digest_sha512_256.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::SHA512_256 qw( sha512_256 sha512_256_hex sha512_256_b64 sha512_256_b64u sha512_256_file sha512_256_file_hex sha512_256_file_b64 sha512_256_file_b64u );

13	13	is( Crypt::Digest::SHA512_256->hashsize, 32, 'hashsize/4');
14	14	is( Crypt::Digest->new('SHA512_256')->hashsize, 32, 'hashsize/5');
15	15	is( Crypt::Digest::SHA512_256->new->hashsize, 32, 'hashsize/6');
	16
	17	is( sha512_256("A","A","A"), pack("H*","b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4"), 'sha512_256 (raw/tripple_A)');
	18	is( sha512_256_hex("A","A","A"), "b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4", 'sha512_256 (hex/tripple_A)');
	19	is( sha512_256_b64("A","A","A"), "sopilp2LmwIpe6YVxIW+Lf/vkHykGcKklABAJtbEvfQ=", 'sha512_256 (base64/tripple_A)');
	20	is( sha512_256_b64u("A","A","A"), "sopilp2LmwIpe6YVxIW-Lf_vkHykGcKklABAJtbEvfQ", 'sha512_256 (base64url/tripple_A)');
	21	is( digest_data('SHA512_256', "A","A","A"), pack("H*","b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4"), 'sha512_256 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('SHA512_256', "A","A","A"), "b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4", 'sha512_256 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('SHA512_256', "A","A","A"), "sopilp2LmwIpe6YVxIW+Lf/vkHykGcKklABAJtbEvfQ=", 'sha512_256 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('SHA512_256', "A","A","A"), "sopilp2LmwIpe6YVxIW-Lf_vkHykGcKklABAJtbEvfQ", 'sha512_256 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::SHA512_256->new->add("A","A","A")->hexdigest, "b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4", 'sha512_256 (OO/tripple_A)');
	26	is( Crypt::Digest::SHA512_256->new->add("A")->add("A")->add("A")->hexdigest, "b28a62969d8b9b02297ba615c485be2dffef907ca419c2a494004026d6c4bdf4", 'sha512_256 (OO3/tripple_A)');
16	27
17	28
18	29	is( sha512_256(""), pack("H*","c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a"), 'sha512_256 (raw/1)');

+12

-1

t/digest_tiger192.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::Tiger192 qw( tiger192 tiger192_hex tiger192_b64 tiger192_b64u tiger192_file tiger192_file_hex tiger192_file_b64 tiger192_file_b64u );

13	13	is( Crypt::Digest::Tiger192->hashsize, 24, 'hashsize/4');
14	14	is( Crypt::Digest->new('Tiger192')->hashsize, 24, 'hashsize/5');
15	15	is( Crypt::Digest::Tiger192->new->hashsize, 24, 'hashsize/6');
	16
	17	is( tiger192("A","A","A"), pack("H*","04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9"), 'tiger192 (raw/tripple_A)');
	18	is( tiger192_hex("A","A","A"), "04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9", 'tiger192 (hex/tripple_A)');
	19	is( tiger192_b64("A","A","A"), "BGgiU6zE5gkgFCKtUK1r4sUc8WmLCkHJ", 'tiger192 (base64/tripple_A)');
	20	is( tiger192_b64u("A","A","A"), "BGgiU6zE5gkgFCKtUK1r4sUc8WmLCkHJ", 'tiger192 (base64url/tripple_A)');
	21	is( digest_data('Tiger192', "A","A","A"), pack("H*","04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9"), 'tiger192 (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('Tiger192', "A","A","A"), "04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9", 'tiger192 (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('Tiger192', "A","A","A"), "BGgiU6zE5gkgFCKtUK1r4sUc8WmLCkHJ", 'tiger192 (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('Tiger192', "A","A","A"), "BGgiU6zE5gkgFCKtUK1r4sUc8WmLCkHJ", 'tiger192 (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::Tiger192->new->add("A","A","A")->hexdigest, "04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9", 'tiger192 (OO/tripple_A)');
	26	is( Crypt::Digest::Tiger192->new->add("A")->add("A")->add("A")->hexdigest, "04682253acc4e609201422ad50ad6be2c51cf1698b0a41c9", 'tiger192 (OO3/tripple_A)');
16	27
17	28
18	29	is( tiger192(""), pack("H*","3293ac630c13f0245f92bbb1766e16167a4e58492dde73f3"), 'tiger192 (raw/1)');

+12

-1

t/digest_whirlpool.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 83 + 94 + 6;
	5	use Test::More tests => 83 + 94 + 10 + 6;
6	6
7	7	use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u );
8	8	use Crypt::Digest::Whirlpool qw( whirlpool whirlpool_hex whirlpool_b64 whirlpool_b64u whirlpool_file whirlpool_file_hex whirlpool_file_b64 whirlpool_file_b64u );

13	13	is( Crypt::Digest::Whirlpool->hashsize, 64, 'hashsize/4');
14	14	is( Crypt::Digest->new('Whirlpool')->hashsize, 64, 'hashsize/5');
15	15	is( Crypt::Digest::Whirlpool->new->hashsize, 64, 'hashsize/6');
	16
	17	is( whirlpool("A","A","A"), pack("H*","a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64"), 'whirlpool (raw/tripple_A)');
	18	is( whirlpool_hex("A","A","A"), "a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64", 'whirlpool (hex/tripple_A)');
	19	is( whirlpool_b64("A","A","A"), "pN6jjHQ/MY23Fp4orCev8XOUK2e1b5iB2kZL2sSPR8xIHuKXRlV88BPRxUx6dpEsE4CxaCUd9xGCk1Ef2JqaZA==", 'whirlpool (base64/tripple_A)');
	20	is( whirlpool_b64u("A","A","A"), "pN6jjHQ_MY23Fp4orCev8XOUK2e1b5iB2kZL2sSPR8xIHuKXRlV88BPRxUx6dpEsE4CxaCUd9xGCk1Ef2JqaZA", 'whirlpool (base64url/tripple_A)');
	21	is( digest_data('Whirlpool', "A","A","A"), pack("H*","a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64"), 'whirlpool (digest_data_raw/tripple_A)');
	22	is( digest_data_hex('Whirlpool', "A","A","A"), "a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64", 'whirlpool (digest_data_hex/tripple_A)');
	23	is( digest_data_b64('Whirlpool', "A","A","A"), "pN6jjHQ/MY23Fp4orCev8XOUK2e1b5iB2kZL2sSPR8xIHuKXRlV88BPRxUx6dpEsE4CxaCUd9xGCk1Ef2JqaZA==", 'whirlpool (digest_data_b64/tripple_A)');
	24	is( digest_data_b64u('Whirlpool', "A","A","A"), "pN6jjHQ_MY23Fp4orCev8XOUK2e1b5iB2kZL2sSPR8xIHuKXRlV88BPRxUx6dpEsE4CxaCUd9xGCk1Ef2JqaZA", 'whirlpool (digest_data_b64u/tripple_A)');
	25	is( Crypt::Digest::Whirlpool->new->add("A","A","A")->hexdigest, "a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64", 'whirlpool (OO/tripple_A)');
	26	is( Crypt::Digest::Whirlpool->new->add("A")->add("A")->add("A")->hexdigest, "a4dea38c743f318db7169e28ac27aff173942b67b56f9881da464bdac48f47cc481ee29746557cf013d1c54c7a76912c1380b168251df7118293511fd89a9a64", 'whirlpool (OO3/tripple_A)');
16	27
17	28
18	29	is( whirlpool(""), pack("H*","19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3"), 'whirlpool (raw/1)');

+10

-1

t/mac_blake2b.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 36;
	5	use Test::More tests => 36 + 8;
6	6
7	7	use Crypt::Mac::BLAKE2b qw( blake2b blake2b_hex blake2b_b64 blake2b_b64u );
8	8

42	42	is( blake2b_hex(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'dc29010f123a4cd59c91da5fc494375962502ca2179021ebca2f6dd41befa8d2', 'BLAKE2b/func+hex/6');
43	43	is( blake2b_b64(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), '3CkBDxI6TNWckdpfxJQ3WWJQLKIXkCHryi9t1BvvqNI=', 'BLAKE2b/func+b64/6');
44	44	is( blake2b_b64u(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), '3CkBDxI6TNWckdpfxJQ3WWJQLKIXkCHryi9t1BvvqNI', 'BLAKE2b/func+b64u/6');
	45
	46	is( unpack('H*', Crypt::Mac::BLAKE2b->new(32, '12345678901234561234567890123456')->add("A","A","A")->mac), '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/oo+raw/tripple_A');
	47	is( unpack('H*', Crypt::Mac::BLAKE2b->new(32, '12345678901234561234567890123456')->add("A")->add("A")->add("A")->mac), '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/oo3+raw/tripple_A');
	48	is( Crypt::Mac::BLAKE2b->new(32, '12345678901234561234567890123456')->add("A","A","A")->hexmac, '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/oo+hex/tripple_A');
	49	is( Crypt::Mac::BLAKE2b->new(32, '12345678901234561234567890123456')->add("A")->add("A")->add("A")->hexmac, '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/oo3+hex/tripple_A');
	50	is( unpack('H*', blake2b(32, '12345678901234561234567890123456',"A","A","A")), '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/func+raw/tripple_A');
	51	is( blake2b_hex (32, '12345678901234561234567890123456',"A","A","A"), '794a20cc22c1f9f278aa1219ded10105cc9cfd264e66a327f32fbc309b2d404f', 'BLAKE2b/func+hex/tripple_A');
	52	is( blake2b_b64 (32, '12345678901234561234567890123456',"A","A","A"), 'eUogzCLB+fJ4qhIZ3tEBBcyc/SZOZqMn8y+8MJstQE8=', 'BLAKE2b/func+b64/tripple_A');
	53	is( blake2b_b64u(32, '12345678901234561234567890123456',"A","A","A"), 'eUogzCLB-fJ4qhIZ3tEBBcyc_SZOZqMn8y-8MJstQE8', 'BLAKE2b/func+b64u/tripple_A');

+10

-1

t/mac_blake2s.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 36;
	5	use Test::More tests => 36 + 8;
6	6
7	7	use Crypt::Mac::BLAKE2s qw( blake2s blake2s_hex blake2s_b64 blake2s_b64u );
8	8

42	42	is( blake2s_hex(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'a31f0e2ba5e73a3aab7e14503690515662758279075d7b68512709824923e65c', 'BLAKE2s/func+hex/6');
43	43	is( blake2s_b64(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'ox8OK6XnOjqrfhRQNpBRVmJ1gnkHXXtoUScJgkkj5lw=', 'BLAKE2s/func+b64/6');
44	44	is( blake2s_b64u(32,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'ox8OK6XnOjqrfhRQNpBRVmJ1gnkHXXtoUScJgkkj5lw', 'BLAKE2s/func+b64u/6');
	45
	46	is( unpack('H*', Crypt::Mac::BLAKE2s->new(32, '12345678901234561234567890123456')->add("A","A","A")->mac), '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/oo+raw/tripple_A');
	47	is( unpack('H*', Crypt::Mac::BLAKE2s->new(32, '12345678901234561234567890123456')->add("A")->add("A")->add("A")->mac), '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/oo3+raw/tripple_A');
	48	is( Crypt::Mac::BLAKE2s->new(32, '12345678901234561234567890123456')->add("A","A","A")->hexmac, '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/oo+hex/tripple_A');
	49	is( Crypt::Mac::BLAKE2s->new(32, '12345678901234561234567890123456')->add("A")->add("A")->add("A")->hexmac, '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/oo3+hex/tripple_A');
	50	is( unpack('H*', blake2s(32, '12345678901234561234567890123456',"A","A","A")), '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/func+raw/tripple_A');
	51	is( blake2s_hex (32, '12345678901234561234567890123456',"A","A","A"), '8acd7813fe7251676d1cf2817c09a25840fa9a1df7143536448a5dfdf7365725', 'BLAKE2s/func+hex/tripple_A');
	52	is( blake2s_b64 (32, '12345678901234561234567890123456',"A","A","A"), 'is14E/5yUWdtHPKBfAmiWED6mh33FDU2RIpd/fc2VyU=', 'BLAKE2s/func+b64/tripple_A');
	53	is( blake2s_b64u(32, '12345678901234561234567890123456',"A","A","A"), 'is14E_5yUWdtHPKBfAmiWED6mh33FDU2RIpd_fc2VyU', 'BLAKE2s/func+b64u/tripple_A');

+10

-1

t/mac_f9.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::F9 qw( f9 f9_hex f9_b64 f9_b64u );
8	8

78	78	is( f9_hex('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'fa83d84023c43a81', 'F9/func+hex/12');
79	79	is( f9_b64('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), '+oPYQCPEOoE=', 'F9/func+b64/12');
80	80	is( f9_b64u('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), '-oPYQCPEOoE', 'F9/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::F9->new('AES', '1234567890123456')->add("A","A","A")->mac), 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::F9->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->mac), 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/oo3+raw/tripple_A');
	84	is( Crypt::Mac::F9->new('AES', '1234567890123456')->add("A","A","A")->hexmac, 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/oo+hex/tripple_A');
	85	is( Crypt::Mac::F9->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->hexmac, 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/oo3+hex/tripple_A');
	86	is( unpack('H*', f9('AES', '1234567890123456',"A","A","A")), 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/func+raw/tripple_A');
	87	is( f9_hex ('AES', '1234567890123456',"A","A","A"), 'a30e9e0ee8cd9d7401f9a9967e82b5a1', 'F9/func+hex/tripple_A');
	88	is( f9_b64 ('AES', '1234567890123456',"A","A","A"), 'ow6eDujNnXQB+amWfoK1oQ==', 'F9/func+b64/tripple_A');
	89	is( f9_b64u('AES', '1234567890123456',"A","A","A"), 'ow6eDujNnXQB-amWfoK1oQ', 'F9/func+b64u/tripple_A');

+10

-1

t/mac_hmac.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::HMAC qw( hmac hmac_hex hmac_b64 hmac_b64u );
8	8

78	78	is( hmac_hex('Whirlpool','secretkey',"test\0test\0test\n"), 'dab6a22e05b46ce641e022e6ea2b42646a25b994ed15fed09145e3906d159efba37b899c344f589b3ad5868cd631a8eb304d21dedf47e364c791ccfa665681f7', 'HMAC/func+hex/12');
79	79	is( hmac_b64('Whirlpool','secretkey',"test\0test\0test\n"), '2raiLgW0bOZB4CLm6itCZGoluZTtFf7QkUXjkG0Vnvuje4mcNE9YmzrVhozWMajrME0h3t9H42THkcz6ZlaB9w==', 'HMAC/func+b64/12');
80	80	is( hmac_b64u('Whirlpool','secretkey',"test\0test\0test\n"), '2raiLgW0bOZB4CLm6itCZGoluZTtFf7QkUXjkG0Vnvuje4mcNE9YmzrVhozWMajrME0h3t9H42THkcz6ZlaB9w', 'HMAC/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::HMAC->new('SHA1', 'secretkey')->add("A","A","A")->mac), '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::HMAC->new('SHA1', 'secretkey')->add("A")->add("A")->add("A")->mac), '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/oo3+raw/tripple_A');
	84	is( Crypt::Mac::HMAC->new('SHA1', 'secretkey')->add("A","A","A")->hexmac, '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/oo+hex/tripple_A');
	85	is( Crypt::Mac::HMAC->new('SHA1', 'secretkey')->add("A")->add("A")->add("A")->hexmac, '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/oo3+hex/tripple_A');
	86	is( unpack('H*', hmac('SHA1', 'secretkey',"A","A","A")), '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/func+raw/tripple_A');
	87	is( hmac_hex ('SHA1', 'secretkey',"A","A","A"), '99070fd56a6595bbb458747d63808344fed0b9c1', 'HMAC/func+hex/tripple_A');
	88	is( hmac_b64 ('SHA1', 'secretkey',"A","A","A"), 'mQcP1Wpllbu0WHR9Y4CDRP7QucE=', 'HMAC/func+b64/tripple_A');
	89	is( hmac_b64u('SHA1', 'secretkey',"A","A","A"), 'mQcP1Wpllbu0WHR9Y4CDRP7QucE', 'HMAC/func+b64u/tripple_A');

+10

-1

t/mac_omac.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::OMAC qw( omac omac_hex omac_b64 omac_b64u );
8	8

78	78	is( omac_hex('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), '40e6d018b49ada77', 'OMAC/func+hex/12');
79	79	is( omac_b64('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'QObQGLSa2nc=', 'OMAC/func+b64/12');
80	80	is( omac_b64u('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'QObQGLSa2nc', 'OMAC/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::OMAC->new('AES', '1234567890123456')->add("A","A","A")->mac), '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::OMAC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->mac), '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/oo3+raw/tripple_A');
	84	is( Crypt::Mac::OMAC->new('AES', '1234567890123456')->add("A","A","A")->hexmac, '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/oo+hex/tripple_A');
	85	is( Crypt::Mac::OMAC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->hexmac, '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/oo3+hex/tripple_A');
	86	is( unpack('H*', omac('AES', '1234567890123456',"A","A","A")), '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/func+raw/tripple_A');
	87	is( omac_hex ('AES', '1234567890123456',"A","A","A"), '49b745733f380fb4cdd8ce1ff1e52abc', 'OMAC/func+hex/tripple_A');
	88	is( omac_b64 ('AES', '1234567890123456',"A","A","A"), 'SbdFcz84D7TN2M4f8eUqvA==', 'OMAC/func+b64/tripple_A');
	89	is( omac_b64u('AES', '1234567890123456',"A","A","A"), 'SbdFcz84D7TN2M4f8eUqvA', 'OMAC/func+b64u/tripple_A');

+10

-1

t/mac_pelican.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::Pelican qw( pelican pelican_hex pelican_b64 pelican_b64u );
8	8

78	78	is( pelican_hex('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), '8a798fcb2181d9f9ed81fcd2a7f6cd4e', 'Pelican/func+hex/12');
79	79	is( pelican_b64('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'inmPyyGB2fntgfzSp/bNTg==', 'Pelican/func+b64/12');
80	80	is( pelican_b64u('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'inmPyyGB2fntgfzSp_bNTg', 'Pelican/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::Pelican->new('1234567890123456')->add("A","A","A")->mac), '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::Pelican->new('1234567890123456')->add("A")->add("A")->add("A")->mac), '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/oo3+raw/tripple_A');
	84	is( Crypt::Mac::Pelican->new('1234567890123456')->add("A","A","A")->hexmac, '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/oo+hex/tripple_A');
	85	is( Crypt::Mac::Pelican->new('1234567890123456')->add("A")->add("A")->add("A")->hexmac, '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/oo3+hex/tripple_A');
	86	is( unpack('H*', pelican('1234567890123456',"A","A","A")), '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/func+raw/tripple_A');
	87	is( pelican_hex ('1234567890123456',"A","A","A"), '6f7dda998b3fdfeaa80737e5127532a5', 'Pelican/func+hex/tripple_A');
	88	is( pelican_b64 ('1234567890123456',"A","A","A"), 'b33amYs/3+qoBzflEnUypQ==', 'Pelican/func+b64/tripple_A');
	89	is( pelican_b64u('1234567890123456',"A","A","A"), 'b33amYs_3-qoBzflEnUypQ', 'Pelican/func+b64u/tripple_A');

+10

-1

t/mac_pmac.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::PMAC qw( pmac pmac_hex pmac_b64 pmac_b64u );
8	8

78	78	is( pmac_hex('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), '3797cde072a8e286', 'PMAC/func+hex/12');
79	79	is( pmac_b64('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'N5fN4HKo4oY=', 'PMAC/func+b64/12');
80	80	is( pmac_b64u('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'N5fN4HKo4oY', 'PMAC/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::PMAC->new('AES', '1234567890123456')->add("A","A","A")->mac), 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::PMAC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->mac), 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/oo3+raw/tripple_A');
	84	is( Crypt::Mac::PMAC->new('AES', '1234567890123456')->add("A","A","A")->hexmac, 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/oo+hex/tripple_A');
	85	is( Crypt::Mac::PMAC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->hexmac, 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/oo3+hex/tripple_A');
	86	is( unpack('H*', pmac('AES', '1234567890123456',"A","A","A")), 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/func+raw/tripple_A');
	87	is( pmac_hex ('AES', '1234567890123456',"A","A","A"), 'c46c52ff026e4e24837bc51a7e21f8cb', 'PMAC/func+hex/tripple_A');
	88	is( pmac_b64 ('AES', '1234567890123456',"A","A","A"), 'xGxS/wJuTiSDe8UafiH4yw==', 'PMAC/func+b64/tripple_A');
	89	is( pmac_b64u('AES', '1234567890123456',"A","A","A"), 'xGxS_wJuTiSDe8UafiH4yw', 'PMAC/func+b64u/tripple_A');

+10

-1

t/mac_poly1305.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 36;
	5	use Test::More tests => 36 + 8;
6	6
7	7	use Crypt::Mac::Poly1305 qw( poly1305 poly1305_hex poly1305_b64 poly1305_b64u );
8	8

42	42	is( poly1305_hex('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), '4c02cea60201d83ae4b2d644789422e5', 'Poly1305/func+hex/6');
43	43	is( poly1305_b64('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'TALOpgIB2DrkstZEeJQi5Q==', 'Poly1305/func+b64/6');
44	44	is( poly1305_b64u('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',"test\0test\0test\n"), 'TALOpgIB2DrkstZEeJQi5Q', 'Poly1305/func+b64u/6');
	45
	46	is( unpack('H*', Crypt::Mac::Poly1305->new('12345678901234561234567890123456')->add("A","A","A")->mac), '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/oo+raw/tripple_A');
	47	is( unpack('H*', Crypt::Mac::Poly1305->new('12345678901234561234567890123456')->add("A")->add("A")->add("A")->mac), '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/oo3+raw/tripple_A');
	48	is( Crypt::Mac::Poly1305->new('12345678901234561234567890123456')->add("A","A","A")->hexmac, '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/oo+hex/tripple_A');
	49	is( Crypt::Mac::Poly1305->new('12345678901234561234567890123456')->add("A")->add("A")->add("A")->hexmac, '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/oo3+hex/tripple_A');
	50	is( unpack('H*', poly1305('12345678901234561234567890123456',"A","A","A")), '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/func+raw/tripple_A');
	51	is( poly1305_hex ('12345678901234561234567890123456',"A","A","A"), '7c1e6c34ad72384ac4f52eb49f642abc', 'Poly1305/func+hex/tripple_A');
	52	is( poly1305_b64 ('12345678901234561234567890123456',"A","A","A"), 'fB5sNK1yOErE9S60n2QqvA==', 'Poly1305/func+b64/tripple_A');
	53	is( poly1305_b64u('12345678901234561234567890123456',"A","A","A"), 'fB5sNK1yOErE9S60n2QqvA', 'Poly1305/func+b64u/tripple_A');

+10

-1

t/mac_xcbc.t less more

2	2	use strict;
3	3	use warnings;
4	4
5		use Test::More tests => 72;
	5	use Test::More tests => 72 + 8;
6	6
7	7	use Crypt::Mac::XCBC qw( xcbc xcbc_hex xcbc_b64 xcbc_b64u );
8	8

78	78	is( xcbc_hex('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), '98276a4a6aafd86b', 'XCBC/func+hex/12');
79	79	is( xcbc_b64('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'mCdqSmqv2Gs=', 'XCBC/func+b64/12');
80	80	is( xcbc_b64u('Blowfish','12345678901234561234567890123456',"test\0test\0test\n"), 'mCdqSmqv2Gs', 'XCBC/func+b64u/12');
	81
	82	is( unpack('H*', Crypt::Mac::XCBC->new('AES', '1234567890123456')->add("A","A","A")->mac), 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/oo+raw/tripple_A');
	83	is( unpack('H*', Crypt::Mac::XCBC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->mac), 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/oo3+raw/tripple_A');
	84	is( Crypt::Mac::XCBC->new('AES', '1234567890123456')->add("A","A","A")->hexmac, 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/oo+hex/tripple_A');
	85	is( Crypt::Mac::XCBC->new('AES', '1234567890123456')->add("A")->add("A")->add("A")->hexmac, 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/oo3+hex/tripple_A');
	86	is( unpack('H*', xcbc('AES', '1234567890123456',"A","A","A")), 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/func+raw/tripple_A');
	87	is( xcbc_hex ('AES', '1234567890123456',"A","A","A"), 'da243c0a133fc33cd1f96b872c0bec9b', 'XCBC/func+hex/tripple_A');
	88	is( xcbc_b64 ('AES', '1234567890123456',"A","A","A"), '2iQ8ChM/wzzR+WuHLAvsmw==', 'XCBC/func+b64/tripple_A');
	89	is( xcbc_b64u('AES', '1234567890123456',"A","A","A"), '2iQ8ChM_wzzR-WuHLAvsmw', 'XCBC/func+b64u/tripple_A');