Commit b3d0c9e280ed278158bcf1d15963b7c6f66057df - libcryptx-perl

+5

-2

Changes less more

0	0	Changes for CryptX
1	1
2		0.054_* 2017-10-XX
	2	0.055 2017-11-28
3	3	- new Crypt::Cipher::IDEA
4	4	- new Crypt::Cipher::Serpent
5	5	- new Crypt::Stream::Salsa20
6	6	- new Crypt::Stream::Sosemanuk
7		- added CCM OO interface: new-add-add-done
	7	- added CCM object oriented interface: new-add-add-done
	8	- fix #39 accept CFLAGS and CPPFLAGS from the environment
	9	- fix #40 typos in POD
	10	- fix HMAC+SHA3 (now compliant with NIST test vectors)
8	11
9	12	0.054 2017-10-12
10	13	- fix Crypt::PK::DSA verify

+3

-0

MANIFEST less more

671	671	t/001_compile.t
672	672	t/002_all_pm.t
673	673	t/003_all_pm_pod.t
	674	t/004_all_pm_pod_spelling.t
	675	t/005_all_pm_pod_coverage.t
674	676	t/auth_enc_ccm.t
675	677	t/auth_enc_ccm_test_vector_ltc.t
676	678	t/auth_enc_chacha20poly1305.t

924	926	t/mac_blake2s.t
925	927	t/mac_f9.t
926	928	t/mac_hmac.t
	929	t/mac_hmac_nist.t
927	930	t/mac_hmac_test_vectors_ltc.t
928	931	t/mac_omac.t
929	932	t/mac_omac_test_vectors_ltc.t

+2

-2

META.json less more

35	35	}
36	36	}
37	37	},
38		"release_status" : "unstable",
	38	"release_status" : "stable",
39	39	"resources" : {
40	40	"bugtracker" : {
41	41	"web" : "https://github.com/DCIT/perl-CryptX/issues"

44	44	"url" : "https://github.com/DCIT/perl-CryptX"
45	45	}
46	46	},
47		"version" : "0.054_006",
	47	"version" : "0.055",
48	48	"x_serialization_backend" : "JSON::PP version 2.94"
49	49	}

+1

-1

META.yml less more

21	21	resources:
22	22	bugtracker: https://github.com/DCIT/perl-CryptX/issues
23	23	repository: https://github.com/DCIT/perl-CryptX
24		version: 0.054_006
	24	version: '0.055'
25	25	x_serialization_backend: 'CPAN::Meta::YAML version 0.018'

+12

-7

Makefile.PL less more

12	12	my $myextlib = "src/liballinone$Config{lib_ext}";
13	13	my $mycflags = "$Config{ccflags} $Config{cccdlflags} $Config{optimize}";
14	14
	15	#FIX: this is particularly useful for Debian https://github.com/DCIT/perl-CryptX/pull/39
	16	$mycflags .= " $ENV{CFLAGS}" if $ENV{CFLAGS};
	17	$mycflags .= " $ENV{CPPFLAGS}" if $ENV{CPPFLAGS};
	18
15	19	#FIX: gcc with -flto is a trouble maker see https://github.com/DCIT/perl-CryptX/issues/32
16	20	$mycflags =~ s/-flto\b//g;
17	21

22	26	$mycflags =~ s/-ansi\b//g;
23	27	$mycflags =~ s/-Wwrite-strings\b//g;
24	28	$mycflags =~ s/-Wcast-qual\b//g;
25
26		#FIX: this is particularly useful for Debian https://github.com/DCIT/perl-CryptX/pull/39
27		$mycflags = "$ENV{CFLAGS} $ENV{CPPFLAGS}" if $ENV{CFLAGS} \|\| $ENV{CPPFLAGS};
28	29
29	30	#FIX: avoid "ar: fatal: Numeric group ID too large" see https://github.com/DCIT/perl-CryptX/issues/33
30	31	my $myarflags = '$(AR_STATIC_ARGS)';

89	90	my $version_patch = q{
90	91	versionsync:
91	92	$(NOECHO) perl _generators/version_patch.pl sync
92
93	93	versioninc:
94	94	$(NOECHO) perl _generators/version_patch.pl inc
95
96	95	versionincdev:
97	96	$(NOECHO) perl _generators/version_patch.pl incdev
98
99	97	versiondec:
100	98	$(NOECHO) perl _generators/version_patch.pl dec
101
102	99	versiondecdev:
103	100	$(NOECHO) perl _generators/version_patch.pl decdev
	101	gencode:
	102	$(NOECHO) perl _generators/gen.pl gencode
	103	gentest: all
	104	$(NOECHO) perl _generators/gen.pl gentest
	105	openssltest: all
	106	$(NOECHO) perl -Mblib t/openssl/dsa-test.pl
	107	$(NOECHO) perl -Mblib t/openssl/ecc-test.pl
	108	$(NOECHO) perl -Mblib t/openssl/rsa-test.pl
104	109	};
105	110
106	111	return "$myextlib\n$version_patch";

+10

-5

README.md less more

0	0	# NAME
1	1
2		CryptX - Crypto toolkit (self-contained no external libraries needed)
	2	CryptX - Cryptographic toolkit (self-contained, no external libraries needed)
3	3
4	4	# DESCRIPTION
5	5

7	7
8	8	Currently available modules:
9	9
10		- Ciphers - see [Crypt::Cipher](https://metacpan.org/pod/Crypt::Cipher) and related modules
	10	- Symmetric ciphers - see [Crypt::Cipher](https://metacpan.org/pod/Crypt::Cipher) and related modules
11	11
12	12	[Crypt::Cipher::AES](https://metacpan.org/pod/Crypt::Cipher::AES), [Crypt::Cipher::Anubis](https://metacpan.org/pod/Crypt::Cipher::Anubis), [Crypt::Cipher::Blowfish](https://metacpan.org/pod/Crypt::Cipher::Blowfish), [Crypt::Cipher::Camellia](https://metacpan.org/pod/Crypt::Cipher::Camellia), [Crypt::Cipher::CAST5](https://metacpan.org/pod/Crypt::Cipher::CAST5), [Crypt::Cipher::DES](https://metacpan.org/pod/Crypt::Cipher::DES),
13	13	[Crypt::Cipher::DES\_EDE](https://metacpan.org/pod/Crypt::Cipher::DES_EDE), [Crypt::Cipher::IDEA](https://metacpan.org/pod/Crypt::Cipher::IDEA), [Crypt::Cipher::KASUMI](https://metacpan.org/pod/Crypt::Cipher::KASUMI), [Crypt::Cipher::Khazad](https://metacpan.org/pod/Crypt::Cipher::Khazad), [Crypt::Cipher::MULTI2](https://metacpan.org/pod/Crypt::Cipher::MULTI2), [Crypt::Cipher::Noekeon](https://metacpan.org/pod/Crypt::Cipher::Noekeon),

21	21
22	22	- Stream ciphers
23	23
24		[Crypt::Stream::RC4](https://metacpan.org/pod/Crypt::Stream::RC4), [Crypt::Stream::ChaCha](https://metacpan.org/pod/Crypt::Stream::ChaCha), [Crypt::Stream::Salsa20](https://metacpan.org/pod/Crypt::Stream::Salsa20), [Crypt::Stream::Sober128](https://metacpan.org/pod/Crypt::Stream::Sober128)
	24	[Crypt::Stream::RC4](https://metacpan.org/pod/Crypt::Stream::RC4), [Crypt::Stream::ChaCha](https://metacpan.org/pod/Crypt::Stream::ChaCha), [Crypt::Stream::Salsa20](https://metacpan.org/pod/Crypt::Stream::Salsa20), [Crypt::Stream::Sober128](https://metacpan.org/pod/Crypt::Stream::Sober128), [Crypt::Stream::Sosemanuk](https://metacpan.org/pod/Crypt::Stream::Sosemanuk)
25	25
26	26	- Authenticated encryption modes
27	27

36	36	[Crypt::Digest::SHA512](https://metacpan.org/pod/Crypt::Digest::SHA512), [Crypt::Digest::SHA512\_224](https://metacpan.org/pod/Crypt::Digest::SHA512_224), [Crypt::Digest::SHA512\_256](https://metacpan.org/pod/Crypt::Digest::SHA512_256), [Crypt::Digest::Tiger192](https://metacpan.org/pod/Crypt::Digest::Tiger192), [Crypt::Digest::Whirlpool](https://metacpan.org/pod/Crypt::Digest::Whirlpool),
37	37	[Crypt::Digest::SHA3\_224](https://metacpan.org/pod/Crypt::Digest::SHA3_224), [Crypt::Digest::SHA3\_256](https://metacpan.org/pod/Crypt::Digest::SHA3_256), [Crypt::Digest::SHA3\_384](https://metacpan.org/pod/Crypt::Digest::SHA3_384), [Crypt::Digest::SHA3\_512](https://metacpan.org/pod/Crypt::Digest::SHA3_512), [Crypt::Digest::SHAKE](https://metacpan.org/pod/Crypt::Digest::SHAKE)
38	38
	39	- Checksums
	40
	41	[Crypt::Checksum](https://metacpan.org/pod/Crypt::Checksum), [Crypt::Checksum::Adler32](https://metacpan.org/pod/Crypt::Checksum::Adler32), [Crypt::Checksum::CRC32](https://metacpan.org/pod/Crypt::Checksum::CRC32)
	42
39	43	- Message Authentication Codes
40	44
41		[Crypt::Mac::F9](https://metacpan.org/pod/Crypt::Mac::F9), [Crypt::Mac::HMAC](https://metacpan.org/pod/Crypt::Mac::HMAC), [Crypt::Mac::OMAC](https://metacpan.org/pod/Crypt::Mac::OMAC), [Crypt::Mac::Pelican](https://metacpan.org/pod/Crypt::Mac::Pelican), [Crypt::Mac::PMAC](https://metacpan.org/pod/Crypt::Mac::PMAC), [Crypt::Mac::XCBC](https://metacpan.org/pod/Crypt::Mac::XCBC), [Crypt::Mac::Poly1305](https://metacpan.org/pod/Crypt::Mac::Poly1305)
	45	[Crypt::Mac::BLAKE2b](https://metacpan.org/pod/Crypt::Mac::BLAKE2b), [Crypt::Mac::BLAKE2s](https://metacpan.org/pod/Crypt::Mac::BLAKE2s), [Crypt::Mac::F9](https://metacpan.org/pod/Crypt::Mac::F9), [Crypt::Mac::HMAC](https://metacpan.org/pod/Crypt::Mac::HMAC), [Crypt::Mac::OMAC](https://metacpan.org/pod/Crypt::Mac::OMAC),
	46	[Crypt::Mac::Pelican](https://metacpan.org/pod/Crypt::Mac::Pelican), [Crypt::Mac::PMAC](https://metacpan.org/pod/Crypt::Mac::PMAC), [Crypt::Mac::XCBC](https://metacpan.org/pod/Crypt::Mac::XCBC), [Crypt::Mac::Poly1305](https://metacpan.org/pod/Crypt::Mac::Poly1305)
42	47
43	48	- Public key cryptography
44	49

48	53
49	54	[Crypt::PRNG](https://metacpan.org/pod/Crypt::PRNG), [Crypt::PRNG::Fortuna](https://metacpan.org/pod/Crypt::PRNG::Fortuna), [Crypt::PRNG::Yarrow](https://metacpan.org/pod/Crypt::PRNG::Yarrow), [Crypt::PRNG::RC4](https://metacpan.org/pod/Crypt::PRNG::RC4), [Crypt::PRNG::Sober128](https://metacpan.org/pod/Crypt::PRNG::Sober128), [Crypt::PRNG::ChaCha20](https://metacpan.org/pod/Crypt::PRNG::ChaCha20)
50	55
51		- Key derivation functions - PBKDF1, PBKFD2 and HKDF
	56	- Key derivation functions - PBKDF1, PBKDF2 and HKDF
52	57
53	58	[Crypt::KeyDerivation](https://metacpan.org/pod/Crypt::KeyDerivation)
54	59

+4

-13

inc/CryptX_AuthEnc_OCB.xs.inc less more

73	73	RETVAL = newSVpvn("", 0);
74	74	}
75	75	else {
76		if (in_data_len % (&self->state)->block_len) {
77		croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
	76	if (in_data_len % 16) {
	77	croak ("FATAL: sizeof(data) should be multiple of 16");
78	78	}
79	79	RETVAL = NEWSV(0, in_data_len);
80	80	SvPOK_only(RETVAL);

134	134	RETVAL = newSVpvn("", 0);
135	135	}
136	136	else {
137		if (in_data_len % (&self->state)->block_len) {
138		croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
	137	if (in_data_len % 16) {
	138	croak ("FATAL: sizeof(data) should be multiple of 16");
139	139	}
140	140	RETVAL = NEWSV(0, in_data_len);
141	141	SvPOK_only(RETVAL);

225	225	}
226	226	}
227	227	}
228
229		int
230		blocksize(Crypt::AuthEnc::OCB self)
231		CODE:
232		{
233		RETVAL = (&self->state)->block_len;
234		}
235		OUTPUT:
236		RETVAL

+4

-4

inc/CryptX_KeyDerivation.xs.inc less more

30	30
31	31	rv = pkcs_5_alg1(password_ptr, (unsigned long)password_len, salt_ptr, iteration_count, id, output, &output_len);
32	32	if (rv != CRYPT_OK) {
33		SvREFCNT_dec(RETVAL);
	33	SvREFCNT_dec(RETVAL);
34	34	croak("FATAL: pkcs_5_alg1 process failed: %s", error_to_string(rv));
35	35	}
36	36	SvCUR_set(RETVAL, output_len);

68	68
69	69	rv = pkcs_5_alg2(password_ptr, (unsigned long)password_len, salt_ptr, (unsigned long)salt_len, iteration_count, id, output, &output_len);
70	70	if (rv != CRYPT_OK) {
71		SvREFCNT_dec(RETVAL);
	71	SvREFCNT_dec(RETVAL);
72	72	croak("FATAL: pkcs_5_alg2 process failed: %s", error_to_string(rv));
73	73	}
74	74	SvCUR_set(RETVAL, output_len);

137	137
138	138	rv = hkdf_expand(id, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
139	139	if (rv != CRYPT_OK) {
140		SvREFCNT_dec(RETVAL);
	140	SvREFCNT_dec(RETVAL);
141	141	croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
142	142	}
143	143	SvCUR_set(RETVAL, output_len);

178	178
179	179	rv = hkdf(id, salt_ptr, (unsigned long)salt_len, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
180	180	if (rv != CRYPT_OK) {
181		SvREFCNT_dec(RETVAL);
	181	SvREFCNT_dec(RETVAL);
182	182	croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
183	183	}
184	184	SvCUR_set(RETVAL, output_len);

+2

-2

inc/CryptX_PK_DSA.xs.inc less more

140	140	size(Crypt::PK::DSA self)
141	141	CODE:
142	142	if (self->key.type == -1 \|\| self->key.qord <= 0) XSRETURN_UNDEF;
143		RETVAL = mp_unsigned_bin_size(self->key.g);
	143	RETVAL = mp_unsigned_bin_size(self->key.p);
144	144	OUTPUT:
145	145	RETVAL
146	146

148	148	size_q(Crypt::PK::DSA self)
149	149	CODE:
150	150	if (self->key.type == -1 \|\| self->key.qord <= 0) XSRETURN_UNDEF;
151		RETVAL = self->key.qord;
	151	RETVAL = mp_unsigned_bin_size(self->key.q);
152	152	OUTPUT:
153	153	RETVAL
154	154

+4

-2

lib/Crypt/AuthEnc/CCM.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::AuthEnc Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw( ccm_encrypt_authenticate ccm_decrypt_verify )] );

95	95
96	96	=head1 DESCRIPTION
97	97
98		CCM is a encrypt+authenticate mode that is centered around using AES (or any 16-byte cipher) as aprimitive.
	98	CCM is a encrypt+authenticate mode that is centered around using AES (or any 16-byte cipher) as a primitive.
99	99	Unlike EAX and OCB mode, it is only meant for packet mode where the length of the input is known in advance.
100	100
101	101	=head1 EXPORT

173	173	=item * L<https://en.wikipedia.org/wiki/CCM_mode\|https://en.wikipedia.org/wiki/CCM_mode>
174	174
175	175	=back
	176
	177	=cut

+3

-1

lib/Crypt/AuthEnc/ChaCha20Poly1305.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::AuthEnc Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw( chacha20poly1305_encrypt_authenticate chacha20poly1305_decrypt_verify )] );

174	174	=item * L<https://tools.ietf.org/html/rfc7539>
175	175
176	176	=back
	177
	178	=cut

+3

-1

lib/Crypt/AuthEnc/EAX.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::AuthEnc Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw( eax_encrypt_authenticate eax_decrypt_verify )] );

182	182	=item * L<https://en.wikipedia.org/wiki/EAX_mode\|https://en.wikipedia.org/wiki/EAX_mode>
183	183
184	184	=back
	185
	186	=cut

+3

-1

lib/Crypt/AuthEnc/GCM.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::AuthEnc Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw( gcm_encrypt_authenticate gcm_decrypt_verify )] );

183	183	=item * L<https://en.wikipedia.org/wiki/Galois/Counter_Mode>
184	184
185	185	=back
	186
	187	=cut

+6

-3

lib/Crypt/AuthEnc/OCB.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::AuthEnc Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw( ocb_encrypt_authenticate ocb_decrypt_verify )] );

52	52
53	53	# obsolete, only for backwards compatibility
54	54	sub aad_add { goto &adata_add }
	55	sub blocksize { return 16 }
55	56
56	57	1;
57	58

160	161
161	162	#BEWARE: size of $ciphertext has to be multiple of blocklen (16 for AES)
162	163
163		=head2 encrypt_last
	164	=head2 decrypt_last
164	165
165	166	$plaintext = $ae->decrypt_last($data);
166	167

184	185
185	186	=item * L<https://tools.ietf.org/html/rfc7253>
186	187
187		=back⏎
	188	=back
	189
	190	=cut

+3

-3

lib/Crypt/AuthEnc.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	sub CLONE_SKIP { 1 } # prevent cloning
7	7
8	8	1;
9	9
10		__END__
	10	=pod
11	11
12	12	=head1 NAME
13	13
14	14	Crypt::AuthEnc - [internal only]
15	15
16		=cut⏎
	16	=cut

+2

-2

lib/Crypt/Checksum/Adler32.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use Carp;
7	7	$Carp::Internal{(__PACKAGE__)}++;

119	119
120	120	=back
121	121
122		=cut⏎
	122	=cut

+2

-2

lib/Crypt/Checksum/CRC32.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use Carp;
7	7	$Carp::Internal{(__PACKAGE__)}++;

119	119
120	120	=back
121	121
122		=cut⏎
	122	=cut

+10

-10

lib/Crypt/Checksum.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw/

105	105
106	106	=head2 adler32_data_int
107	107
108		Returns checksum as unsingned 32bit integer.
	108	Returns checksum as unsigned 32bit integer.
109	109
110	110	$checksum_hex = adler32_data_int('data string');
111	111	#or

129	129
130	130	=head2 adler32_file_int
131	131
132		Returns checksum as unsingned 32bit integer.
	132	Returns checksum as unsigned 32bit integer.
133	133
134		$checksum_hex = adler32_file_int('data string');
	134	$checksum_hex = adler32_file_int('filename.dat');
135	135	#or
136		$checksum_hex = adler32_file_int('any data', 'more data', 'even more data');
	136	$checksum_hex = adler32_file_int(*FILEHANDLE);
137	137
138	138	=head2 crc32_data
139	139

153	153
154	154	=head2 crc32_data_int
155	155
156		Returns checksum as unsingned 32bit integer.
	156	Returns checksum as unsigned 32bit integer.
157	157
158	158	$checksum_hex = crc32_data_int('data string');
159	159	#or

177	177
178	178	=head2 crc32_file_int
179	179
180		Returns checksum as unsingned 32bit integer.
	180	Returns checksum as unsigned 32bit integer.
181	181
182		$checksum_hex = crc32_file_int('data string');
	182	$checksum_hex = crc32_file_int('filename.dat');
183	183	#or
184		$checksum_hex = crc32_file_int('any data', 'more data', 'even more data');
	184	$checksum_hex = crc32_file_int(*FILEHANDLE);
185	185
186	186	=head1 SEE ALSO
187	187

195	195
196	196	=back
197	197
198		=cut⏎
	198	=cut

+2

-4

lib/Crypt/Cipher/AES.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::AES - Symetric cipher AES (aka Rijndael), key size: 128/192/256 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::AES - Symmetric cipher AES (aka Rijndael), key size: 128/192/256 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Anubis.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Anubis - Symetric cipher Anubis, key size: 128-320 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Anubis - Symmetric cipher Anubis, key size: 128-320 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Blowfish.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Blowfish - Symetric cipher Blowfish, key size: 64-448 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Blowfish - Symmetric cipher Blowfish, key size: 64-448 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/CAST5.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::CAST5 - Symetric cipher CAST5 (aka CAST-128), key size: 40-128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::CAST5 - Symmetric cipher CAST5 (aka CAST-128), key size: 40-128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Camellia.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Camellia - Symetric cipher Camellia, key size: 128/192/256 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Camellia - Symmetric cipher Camellia, key size: 128/192/256 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/DES.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::DES - Symetric cipher DES, key size: 64[56] bits (Crypt::CBC compliant)
	23	Crypt::Cipher::DES - Symmetric cipher DES, key size: 64[56] bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/DES_EDE.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::DES_EDE - Symetric cipher DES_EDE (aka Tripple-DES, 3DES), key size: 192[168] bits (Crypt::CBC compliant)
	23	Crypt::Cipher::DES_EDE - Symmetric cipher DES_EDE (aka Triple-DES, 3DES), key size: 192[168] bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/IDEA.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::IDEA - Symetric cipher IDEA, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::IDEA - Symmetric cipher IDEA, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/KASUMI.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::KASUMI - Symetric cipher KASUMI, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::KASUMI - Symmetric cipher KASUMI, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Khazad.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Khazad - Symetric cipher Khazad, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Khazad - Symmetric cipher Khazad, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/MULTI2.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::MULTI2 - Symetric cipher MULTI2, key size: 320 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::MULTI2 - Symmetric cipher MULTI2, key size: 320 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Noekeon.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Noekeon - Symetric cipher Noekeon, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Noekeon - Symmetric cipher Noekeon, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/RC2.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::RC2 - Symetric cipher RC2, key size: 40-1024 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::RC2 - Symmetric cipher RC2, key size: 40-1024 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/RC5.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::RC5 - Symetric cipher RC5, key size: 64-1024 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::RC5 - Symmetric cipher RC5, key size: 64-1024 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/RC6.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::RC6 - Symetric cipher RC6, key size: 64-1024 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::RC6 - Symmetric cipher RC6, key size: 64-1024 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SAFERP.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SAFERP - Symetric cipher SAFER+, key size: 128/192/256 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SAFERP - Symmetric cipher SAFER+, key size: 128/192/256 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SAFER_K128.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SAFER_K128 - Symetric cipher SAFER_K128, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SAFER_K128 - Symmetric cipher SAFER_K128, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SAFER_K64.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SAFER_K64 - Symetric cipher SAFER_K64, key size: 64 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SAFER_K64 - Symmetric cipher SAFER_K64, key size: 64 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SAFER_SK128.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SAFER_SK128 - Symetric cipher SAFER_SK128, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SAFER_SK128 - Symmetric cipher SAFER_SK128, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SAFER_SK64.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SAFER_SK64 - Symetric cipher SAFER_SK64, key size: 64 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SAFER_SK64 - Symmetric cipher SAFER_SK64, key size: 64 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/SEED.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::SEED - Symetric cipher SEED, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::SEED - Symmetric cipher SEED, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Serpent.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Serpent - Symetric cipher Serpent, key size: 128/192/256 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Serpent - Symmetric cipher Serpent, key size: 128/192/256 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Skipjack.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Skipjack - Symetric cipher Skipjack, key size: 80 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Skipjack - Symmetric cipher Skipjack, key size: 80 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/Twofish.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::Twofish - Symetric cipher Twofish, key size: 128/192/256 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::Twofish - Symmetric cipher Twofish, key size: 128/192/256 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+2

-4

lib/Crypt/Cipher/XTEA.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use CryptX;
9	9	use base 'Crypt::Cipher';

20	20
21	21	=head1 NAME
22	22
23		Crypt::Cipher::XTEA - Symetric cipher XTEA, key size: 128 bits (Crypt::CBC compliant)
	23	Crypt::Cipher::XTEA - Symmetric cipher XTEA, key size: 128 bits (Crypt::CBC compliant)
24	24
25	25	=head1 SYNOPSIS
26	26

116	116	=back
117	117
118	118	=cut
119
120		__END__⏎

+4

-6

lib/Crypt/Cipher.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use Carp;
7	7	$Carp::Internal{(__PACKAGE__)}++;

128	128
129	129	=head1 DESCRIPTION
130	130
131		Provides an interface to various symetric cipher algorithms.
	131	Provides an interface to various symmetric cipher algorithms.
132	132
133	133	B<BEWARE:> This module implements just elementary "one-block-(en\|de)cryption" operation - if you want to
134	134	encrypt/decrypt generic data you have to use some of the cipher block modes - check for example

149	149	# simply any <NAME> for which there exists Crypt::Cipher::<NAME>
150	150	# $key = binary key (keysize should comply with selected cipher requirements)
151	151
152		## some of the ciphers (e.g. MULTI2, RC5, SAFER) allows to set number of rounds
	152	## some of the ciphers (e.g. MULTI2, RC5, SAFER) allow one to set number of rounds
153	153	$d = Crypt::Cipher->new('MULTI2', $key, $rounds);
154	154	# $rounds = positive integer (should comply with selected cipher requirements)
155	155

201	201
202	202	=head2 default_rounds
203	203
204		Returns default number of rounds for given cipher. NOTE: only some cipher (e.g. MULTI2, RC5, SAFER) allows to set number of rounds via new().
	204	Returns default number of rounds for given cipher. NOTE: only some ciphers (e.g. MULTI2, RC5, SAFER) allow one to set number of rounds via new().
205	205
206	206	$d->default_rounds;
207	207	#or

220	220	=back
221	221
222	222	=cut
223
224		__END__

+1

-3

lib/Crypt/Digest/BLAKE2b_160.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2b_256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2b_384.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2b_512.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2s_128.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2s_160.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2s_224.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/BLAKE2s_256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

224	224	=back
225	225
226	226	=cut
227
228		__END__⏎

+1

-3

lib/Crypt/Digest/CHAES.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( chaes chaes_hex chaes_b64 chaes_b64u chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/MD2.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( md2 md2_hex md2_b64 md2_b64u md2_file md2_file_hex md2_file_b64 md2_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/MD4.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( md4 md4_hex md4_b64 md4_b64u md4_file md4_file_hex md4_file_b64 md4_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/MD5.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( md5 md5_hex md5_b64 md5_b64u md5_file md5_file_hex md5_file_b64 md5_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/RIPEMD128.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/RIPEMD160.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/RIPEMD256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/RIPEMD320.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA1.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( sha1 sha1_hex sha1_b64 sha1_b64u sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA224.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( sha224 sha224_hex sha224_b64 sha224_b64u sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( sha256 sha256_hex sha256_b64 sha256_b64u sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA384.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( sha384 sha384_hex sha384_b64 sha384_b64u sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA3_224.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA3_256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA3_384.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA3_512.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA512.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( sha512 sha512_hex sha512_b64 sha512_b64u sha512_file sha512_file_hex sha512_file_b64 sha512_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA512_224.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHA512_256.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [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 )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/SHAKE.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use Carp;
7	7	$Carp::Internal{(__PACKAGE__)}++;

101	101	=back
102	102
103	103	=cut
104
105		__END__⏎

+1

-3

lib/Crypt/Digest/Tiger192.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( tiger192 tiger192_hex tiger192_b64 tiger192_b64u tiger192_file tiger192_file_hex tiger192_file_b64 tiger192_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+1

-3

lib/Crypt/Digest/Whirlpool.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Digest Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( whirlpool whirlpool_hex whirlpool_b64 whirlpool_b64u whirlpool_file whirlpool_file_hex whirlpool_file_b64 whirlpool_file_b64u )] );

222	222	=back
223	223
224	224	=cut
225
226		__END__⏎

+2

-4

lib/Crypt/Digest.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u )] );

175	175
176	176	=head1 FUNCTIONS
177	177
178		Please note that all functions take as its first argument the algoritm name, supported values are:
	178	Please note that all functions take as its first argument the algorithm name, supported values are:
179	179
180	180	'CHAES', 'MD2', 'MD4', 'MD5', 'RIPEMD128', 'RIPEMD160',
181	181	'RIPEMD256', 'RIPEMD320', 'SHA1', 'SHA224', 'SHA256',

372	372	=back
373	373
374	374	=cut
375
376		__END__⏎

+5

-3

lib/Crypt/KeyDerivation.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw(pbkdf1 pbkdf2 hkdf hkdf_expand hkdf_extract)] );

69	69
70	70	=head1 NAME
71	71
72		Crypt::KeyDerivation - PBKDF1, PBKFD2 and HKDF key derivation functions
	72	Crypt::KeyDerivation - PBKDF1, PBKDF2 and HKDF key derivation functions
73	73
74	74	=head1 SYNOPSIS
75	75

88	88
89	89	=over
90	90
91		=item * PBKFD1 and PBKDF according to PKCS#5 v2.0 L<https://tools.ietf.org/html/rfc2898\|https://tools.ietf.org/html/rfc2898>
	91	=item * PBKDF1 and PBKDF according to PKCS#5 v2.0 L<https://tools.ietf.org/html/rfc2898\|https://tools.ietf.org/html/rfc2898>
92	92
93	93	=item * HKDF (+ related) according to L<https://tools.ietf.org/html/rfc5869\|https://tools.ietf.org/html/rfc5869>
94	94

171	171	# $hash_name .. optional, DEFAULT: 'SHA256'
172	172	# $len ........ optional, derived key len, DEFAULT: 32
173	173	# $info ....... optional context and application specific information, DEFAULT: ''
	174
	175	=cut

+1

-3

lib/Crypt/Mac/BLAKE2b.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( blake2b blake2b_hex blake2b_b64 blake2b_b64u )] );

151	151	=back
152	152
153	153	=cut
154
155		__END__⏎

+1

-3

lib/Crypt/Mac/BLAKE2s.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( blake2s blake2s_hex blake2s_b64 blake2s_b64u )] );

151	151	=back
152	152
153	153	=cut
154
155		__END__⏎

+1

-3

lib/Crypt/Mac/F9.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( f9 f9_hex f9_b64 f9_b64u )] );

151	151	=back
152	152
153	153	=cut
154
155		__END__⏎

+1

-3

lib/Crypt/Mac/HMAC.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( hmac hmac_hex hmac_b64 hmac_b64u )] );

170	170	=back
171	171
172	172	=cut
173
174		__END__⏎

+1

-3

lib/Crypt/Mac/OMAC.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( omac omac_hex omac_b64 omac_b64u )] );

153	153	=back
154	154
155	155	=cut
156
157		__END__⏎

+1

-3

lib/Crypt/Mac/PMAC.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( pmac pmac_hex pmac_b64 pmac_b64u )] );

153	153	=back
154	154
155	155	=cut
156
157		__END__⏎

+1

-3

lib/Crypt/Mac/Pelican.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( pelican pelican_hex pelican_b64 pelican_b64u )] );

151	151	=back
152	152
153	153	=cut
154
155		__END__⏎

+1

-3

lib/Crypt/Mac/Poly1305.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( poly1305 poly1305_hex poly1305_b64 poly1305_b64u )] );

151	151	=back
152	152
153	153	=cut
154
155		__END__⏎

+1

-3

lib/Crypt/Mac/XCBC.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use base qw(Crypt::Mac Exporter);
9	9	our %EXPORT_TAGS = ( all => [qw( xcbc xcbc_hex xcbc_b64 xcbc_b64u )] );

153	153	=back
154	154
155	155	=cut
156
157		__END__⏎

+3

-3

lib/Crypt/Mac.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw( mac mac_hex )] );

49	49
50	50	1;
51	51
52		__END__
	52	=pod
53	53
54	54	=head1 NAME
55	55
56	56	Crypt::Mac - [internal only]
57	57
58		=cut⏎
	58	=cut

+1

-1

lib/Crypt/Misc.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 5.57 'import';
7	7	use Carp 'croak';

+3

-1

lib/Crypt/Mode/CBC.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';

114	114	=item * L<https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher-block_chaining_.28CBC.29>
115	115
116	116	=back
	117
	118	=cut

+3

-1

lib/Crypt/Mode/CFB.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';

91	91	=item * L<https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_feedback_.28CFB.29>
92	92
93	93	=back
	94
	95	=cut

+3

-1

lib/Crypt/Mode/CTR.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';

98	98	=item * L<https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Counter_.28CTR.29>
99	99
100	100	=back
	101
	102	=cut

+3

-1

lib/Crypt/Mode/ECB.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';

115	115	=item * L<https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Electronic_codebook_.28ECB.29>
116	116
117	117	=back
	118
	119	=cut

+3

-1

lib/Crypt/Mode/OFB.pm less more

3	3
4	4	use strict;
5	5	use warnings;
6		our $VERSION = '0.054_006';
	6	our $VERSION = '0.055';
7	7
8	8	use Crypt::Cipher;
9	9	use base 'Crypt::Mode';

91	91	=item * L<https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Output_feedback_.28OFB.29>
92	92
93	93	=back
	94
	95	=cut

+3

-3

lib/Crypt/Mode.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	### METHODS
7	7

62	62
63	63	1;
64	64
65		__END__
	65	=pod
66	66
67	67	=head1 NAME
68	68
69	69	Crypt::Mode - [internal only]
70	70
71		=cut⏎
	71	=cut

+6

-4

lib/Crypt/PK/DH.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw( dh_shared_secret )] );

327	327	random data taken from C</dev/random> (UNIX) or C<CryptGenRandom> (Win32).
328	328
329	329	$pk->generate_key($groupsize);
330		### $groupsize (in bytes) corresponds to DH params (p, g) predefined by libtomcrypt
	330	### $groupsize (in bytes) corresponds to DH parameters (p, g) predefined by libtomcrypt
331	331	# 96 => DH-768
332	332	# 128 => DH-1024
333	333	# 192 => DH-1536

355	355	# where $g is the generator (base) in a hex string and $p is the prime in a hex string
356	356
357	357	$pk->generate_key(\$dh_param)
358		# $dh_param is the content of DER or PEM file with DH params
	358	# $dh_param is the content of DER or PEM file with DH parameters
359	359	# e.g. openssl dhparam 2048
360	360
361	361	=head2 import_key

378	378
379	379	=head2 export_key
380	380
381		B<BEWARE:> DH key format change - since v0.049 it is compatible with libtocrypt 1.18.
	381	B<BEWARE:> DH key format change - since v0.049 it is compatible with libtomcrypt 1.18.
382	382
383	383	my $private = $pk->export_key('private');
384	384	#or

479	479	=item * L<https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange\|https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange>
480	480
481	481	=back
	482
	483	=cut

+9

-2

lib/Crypt/PK/DSA.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw( dsa_encrypt dsa_decrypt dsa_sign_message dsa_verify_message dsa_sign_hash dsa_verify_hash )] );

472	472	=head2 size
473	473
474	474	my $size = $pk->size;
475		# returns key size in bytes or undef if no key loaded
	475	# returns key size (length of the prime p) in bytes or undef if key not loaded
	476
	477	=head2 size_q
	478
	479	my $size = $pk->size_q;
	480	# returns length of the prime q in bytes or undef if key not loaded
476	481
477	482	=head2 key2hash
478	483

642	647	=item * L<https://en.wikipedia.org/wiki/Digital_Signature_Algorithm\|https://en.wikipedia.org/wiki/Digital_Signature_Algorithm>
643	648
644	649	=back
	650
	651	=cut

+6

-4

lib/Crypt/PK/ECC.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw( ecc_encrypt ecc_decrypt ecc_sign_message ecc_verify_message ecc_sign_hash ecc_verify_hash ecc_shared_secret )] );

773	773	#or
774	774	$pk->generate_key($hashref_with_curve_params);
775	775
776		The following pre-defined C<$curve_name> values are supported:
	776	The following predefined C<$curve_name> values are supported:
777	777
778	778	# curves from http://www.ecc-brainpool.org/download/Domain-parameters.pdf
779	779	'brainpoolp160r1'

1028	1028	my $public_der = $pk->export_key_der('public');
1029	1029
1030	1030	Since CryptX-0.36 C<export_key_der> can also export keys in a format
1031		that does not explicitely contain curve parameters but only curve OID.
	1031	that does not explicitly contain curve parameters but only curve OID.
1032	1032
1033	1033	my $private_der = $pk->export_key_der('private_short');
1034	1034	#or

1041	1041	my $public_pem = $pk->export_key_pem('public');
1042	1042
1043	1043	Since CryptX-0.36 C<export_key_pem> can also export keys in a format
1044		that does not explicitely contain curve parameters but only curve OID.
	1044	that does not explicitly contain curve parameters but only curve OID.
1045	1045
1046	1046	my $private_pem = $pk->export_key_pem('private_short');
1047	1047	#or

1394	1394	=item * L<https://en.wikipedia.org/wiki/ECDSA\|https://en.wikipedia.org/wiki/ECDSA>
1395	1395
1396	1396	=back
	1397
	1398	=cut

+3

-1

lib/Crypt/PK/RSA.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
7	7	our %EXPORT_TAGS = ( all => [qw(rsa_encrypt rsa_decrypt rsa_sign_message rsa_verify_message rsa_sign_hash rsa_verify_hash)] );

960	960	=item * L<https://en.wikipedia.org/wiki/RSA_%28algorithm%29\|https://en.wikipedia.org/wiki/RSA_%28algorithm%29>
961	961
962	962	=back
	963
	964	=cut

+3

-3

lib/Crypt/PK.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use Carp;
7	7

23	23
24	24	1;
25	25
26		__END__
	26	=pod
27	27
28	28	=head1 NAME
29	29
30	30	Crypt::PK - [internal only]
31	31
32		=cut⏎
	32	=cut

+3

-1

lib/Crypt/PRNG/ChaCha20.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::PRNG Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

156	156	=item * L<https://tools.ietf.org/html/rfc7539>
157	157
158	158	=back
	159
	160	=cut

+3

-1

lib/Crypt/PRNG/Fortuna.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::PRNG Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

157	157	=item * L<https://en.wikipedia.org/wiki/Fortuna_%28PRNG%29\|https://en.wikipedia.org/wiki/Fortuna_%28PRNG%29>
158	158
159	159	=back
	160
	161	=cut

+3

-1

lib/Crypt/PRNG/RC4.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::PRNG Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

156	156	=item * L<https://en.wikipedia.org/wiki/RC4_cipher\|https://en.wikipedia.org/wiki/RC4_cipher>
157	157
158	158	=back
	159
	160	=cut

+3

-1

lib/Crypt/PRNG/Sober128.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::PRNG Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

156	156	=item * L<https://en.wikipedia.org/wiki/SOBER-128\|https://en.wikipedia.org/wiki/SOBER-128>
157	157
158	158	=back
	159
	160	=cut

+3

-1

lib/Crypt/PRNG/Yarrow.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Crypt::PRNG Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

155	155	=item * L<https://en.wikipedia.org/wiki/Yarrow_algorithm\|https://en.wikipedia.org/wiki/Yarrow_algorithm>
156	156
157	157	=back
	158
	159	=cut

+6

-4

lib/Crypt/PRNG.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Exporter);
7	7	our %EXPORT_TAGS = ( all => [qw(random_bytes random_bytes_hex random_bytes_b64 random_bytes_b64u random_string random_string_from rand irand)] );

192	192	#or
193	193	$n = rand($limit);
194	194
195		Returns a random floating point number from range C<[0,1)> (if called without param) or C<[0,$limit)>.
	195	Returns a random floating point number from range C<[0,1)> (if called without parameter) or C<[0,$limit)>.
196	196
197	197	=head2 irand
198	198
199	199	$i = irand;
200	200
201		Returns a random unsigned 32bit integer - range 0 .. 0xFFFFFFFF.
	201	Returns a random unsigned 32bit integer - range C<0 .. 0xFFFFFFFF>.
202	202
203	203	=head1 METHODS
204	204

279	279
280	280	=head1 SEE ALSO
281	281
282		L<Crypt::PRNG::Fortuna>, L<Crypt::PRNG::RC4>, L<Crypt::PRNG::Sober128>, L<Crypt::PRNG::Yarrow>⏎
	282	L<Crypt::PRNG::Fortuna>, L<Crypt::PRNG::RC4>, L<Crypt::PRNG::Sober128>, L<Crypt::PRNG::Yarrow>
	283
	284	=cut

+1

-1

lib/Crypt/Stream/ChaCha.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

+1

-1

lib/Crypt/Stream/RC4.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

+1

-1

lib/Crypt/Stream/Salsa20.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

+1

-1

lib/Crypt/Stream/Sober128.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

+1

-1

lib/Crypt/Stream/Sosemanuk.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

+16

-8

lib/CryptX.pm less more

1	1
2	2	use strict;
3	3	use warnings ;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use base qw(Exporter);
7	7	our @EXPORT_OK = qw();

55	55	}
56	56
57	57	1;
58		__END__
	58
	59	=pod
59	60
60	61	=head1 NAME
61	62
62		CryptX - Crypto toolkit (self-contained no external libraries needed)
	63	CryptX - Cryptographic toolkit (self-contained, no external libraries needed)
63	64
64	65	=head1 DESCRIPTION
65	66

69	70
70	71	=over
71	72
72		=item * Ciphers - see L<Crypt::Cipher> and related modules
	73	=item * Symmetric ciphers - see L<Crypt::Cipher> and related modules
73	74
74	75	L<Crypt::Cipher::AES>, L<Crypt::Cipher::Anubis>, L<Crypt::Cipher::Blowfish>, L<Crypt::Cipher::Camellia>, L<Crypt::Cipher::CAST5>, L<Crypt::Cipher::DES>,
75	76	L<Crypt::Cipher::DES_EDE>, L<Crypt::Cipher::IDEA>, L<Crypt::Cipher::KASUMI>, L<Crypt::Cipher::Khazad>, L<Crypt::Cipher::MULTI2>, L<Crypt::Cipher::Noekeon>,

83	84
84	85	=item * Stream ciphers
85	86
86		L<Crypt::Stream::RC4>, L<Crypt::Stream::ChaCha>, L<Crypt::Stream::Salsa20>, L<Crypt::Stream::Sober128>
	87	L<Crypt::Stream::RC4>, L<Crypt::Stream::ChaCha>, L<Crypt::Stream::Salsa20>, L<Crypt::Stream::Sober128>, L<Crypt::Stream::Sosemanuk>
87	88
88	89	=item * Authenticated encryption modes
89	90

98	99	L<Crypt::Digest::SHA512>, L<Crypt::Digest::SHA512_224>, L<Crypt::Digest::SHA512_256>, L<Crypt::Digest::Tiger192>, L<Crypt::Digest::Whirlpool>,
99	100	L<Crypt::Digest::SHA3_224>, L<Crypt::Digest::SHA3_256>, L<Crypt::Digest::SHA3_384>, L<Crypt::Digest::SHA3_512>, L<Crypt::Digest::SHAKE>
100	101
	102	=item * Checksums
	103
	104	L<Crypt::Checksum>, L<Crypt::Checksum::Adler32>, L<Crypt::Checksum::CRC32>
	105
101	106	=item * Message Authentication Codes
102	107
103		L<Crypt::Mac::F9>, L<Crypt::Mac::HMAC>, L<Crypt::Mac::OMAC>, L<Crypt::Mac::Pelican>, L<Crypt::Mac::PMAC>, L<Crypt::Mac::XCBC>, L<Crypt::Mac::Poly1305>
	108	L<Crypt::Mac::BLAKE2b>, L<Crypt::Mac::BLAKE2s>, L<Crypt::Mac::F9>, L<Crypt::Mac::HMAC>, L<Crypt::Mac::OMAC>,
	109	L<Crypt::Mac::Pelican>, L<Crypt::Mac::PMAC>, L<Crypt::Mac::XCBC>, L<Crypt::Mac::Poly1305>
104	110
105	111	=item * Public key cryptography
106	112

110	116
111	117	L<Crypt::PRNG>, L<Crypt::PRNG::Fortuna>, L<Crypt::PRNG::Yarrow>, L<Crypt::PRNG::RC4>, L<Crypt::PRNG::Sober128>, L<Crypt::PRNG::ChaCha20>
112	118
113		=item * Key derivation functions - PBKDF1, PBKFD2 and HKDF
	119	=item * Key derivation functions - PBKDF1, PBKDF2 and HKDF
114	120
115	121	L<Crypt::KeyDerivation>
116	122

126	132
127	133	=head1 COPYRIGHT
128	134
129		Copyright (c) 2013+ DCIT, a.s. L<http://www.dcit.cz> / Karel Miko⏎
	135	Copyright (c) 2013+ DCIT, a.s. L<http://www.dcit.cz> / Karel Miko
	136
	137	=cut

+1

-3

lib/Math/BigInt/LTM.pm less more

1	1
2	2	use strict;
3	3	use warnings;
4		our $VERSION = '0.054_006';
	4	our $VERSION = '0.055';
5	5
6	6	use CryptX;
7	7

435	435
436	436	1;
437	437
438		__END__
439
440	438	=pod
441	439
442	440	=head1 NAME

+4

-4

src/ltc/hashes/sha3.c less more

17	17	"sha3-224", /* name of hash */
18	18	17, /* internal ID */
19	19	28, /* Size of digest in octets */
20		128, /* Input block size in octets */
	20	144, /* Input block size in octets */
21	21	{ 2,16,840,1,101,3,4,2,7 }, /* ASN.1 OID */
22	22	9, /* Length OID */
23	23	&sha3_224_init,

32	32	"sha3-256", /* name of hash */
33	33	18, /* internal ID */
34	34	32, /* Size of digest in octets */
35		128, /* Input block size in octets */
	35	136, /* Input block size in octets */
36	36	{ 2,16,840,1,101,3,4,2,8 }, /* ASN.1 OID */
37	37	9, /* Length OID */
38	38	&sha3_256_init,

47	47	"sha3-384", /* name of hash */
48	48	19, /* internal ID */
49	49	48, /* Size of digest in octets */
50		128, /* Input block size in octets */
	50	104, /* Input block size in octets */
51	51	{ 2,16,840,1,101,3,4,2,9 }, /* ASN.1 OID */
52	52	9, /* Length OID */
53	53	&sha3_384_init,

62	62	"sha3-512", /* name of hash */
63	63	20, /* internal ID */
64	64	64, /* Size of digest in octets */
65		128, /* Input block size in octets */
	65	72, /* Input block size in octets */
66	66	{ 2,16,840,1,101,3,4,2,10 }, /* ASN.1 OID */
67	67	9, /* Length OID */
68	68	&sha3_512_init,

+1

-1

src/ltc/headers/tomcrypt.h less more

29	29	#define SCRYPT "1.18.0"
30	30
31	31	/* max size of either a cipher/hash block or symmetric key [largest of the two] */
32		#define MAXBLOCKSIZE 128
	32	#define MAXBLOCKSIZE 144
33	33
34	34	/* descriptor table size */
35	35	#define TAB_SIZE 32

+33

-1

t/002_all_pm.t less more

5	5	plan skip_all => "File::Find not installed" unless eval { require File::Find };
6	6	plan tests => 1;
7	7
	8
	9	sub _read {
	10	open my $fh, "<", shift;
	11	binmode $fh;
	12	return do { local $/; <$fh> };
	13	}
	14
	15	my @err;
	16	my $cryptx = _read("lib/CryptX.pm");
8	17	my @files;
9	18	File::Find::find({ wanted=>sub { push @files, $_ if /\.pm$/ }, no_chdir=>1 }, 'lib');
10	19
11	20	for my $m (sort @files) {
	21	my $content = _read($m);
	22	push @err, "ERROR: no newline at the end '$m'" unless $content =~ /\n$/s;
	23	push @err, "ERROR: avoid __END__ '$m'" if $content =~ /__END__/s;
	24	push @err, "ERROR: =pod ... =cut '$m'" unless $content =~ /=pod\n.*?=cut\n$/s;
	25	push @err, "ERROR: trailing whitespace '$m'" if $content =~ / \n/s;
	26	push @err, "ERROR: avoid tabs '$m'" if $content =~ /\t/s;
	27	push @err, "ERROR: avoid CRLF '$m'" if $content =~ /\r/s;
12	28	$m =~ s\|[\\/]\|::\|g;
13	29	$m =~ s\|^lib::\|\|;
14	30	$m =~ s\|\.pm$\|\|;
15		eval "use $m; 1;" or die "ERROR: 'use $m' failed";
	31	push @err, "ERROR: '$m' is missing in CryptX" unless $cryptx =~ /L<$m>/s \|\| $m =~ /^(CryptX\|Math::BigInt::LTM\|Crypt::(PK\|Mode\|Mac\|AuthEnc))$/;
	32	eval "use $m; 1;" or push @err, "ERROR: 'use $m' failed";
16	33	}
17	34
	35	my @others = ('CryptX.xs');
	36	File::Find::find({ wanted=>sub { push @others, $_ if /\.inc$/ }, no_chdir=>1 }, 'inc');
	37	File::Find::find({ wanted=>sub { push @others, $_ if /\.(t\|pl)$/ }, no_chdir=>1 }, 't');
	38
	39	for my $m (sort @others) {
	40	my $content = _read($m);
	41	push @err, "ERROR: no newline at the end '$m'" unless $content =~ /\n$/s;
	42	push @err, "ERROR: trailing whitespace '$m'" if $content =~ / \n/s;
	43	push @err, "ERROR: avoid tabs '$m'" if $content =~ /\t/s;
	44	push @err, "ERROR: avoid CRLF '$m'" if $content =~ /\r/s;
	45	}
	46
	47	warn "$_\n" for (@err);
	48	die if @err;
	49
18	50	ok 1, 'all done';

+2

-1

t/003_all_pm_pod.t less more

2	2
3	3	use Test::More;
4	4
	5	plan skip_all => "set TEST_POD to enable this test (developer only!)" unless $ENV{TEST_POD};
5	6	plan skip_all => "File::Find not installed" unless eval { require File::Find };
6	7	plan skip_all => "Test::Pod not installed" unless eval { require Test::Pod };
7	8	plan tests => 102;

11	12
12	13	for my $m (sort @files) {
13	14	Test::Pod::pod_file_ok( $m, "Valid POD in '$m'" );
14		}⏎
	15	}

+31

-0

t/004_all_pm_pod_spelling.t less more

	0	use strict;
	1	use warnings;
	2
	3	use Test::More;
	4
	5	plan skip_all => "set TEST_POD to enable this test (developer only!)" unless $ENV{TEST_POD};
	6	plan skip_all => "File::Find not installed" unless eval { require File::Find };
	7	plan skip_all => "Test::Pod::Spelling or Text::Aspell not installed" unless eval { require Test::Pod::Spelling; require Text::Aspell; };
	8
	9	Test::Pod::Spelling->import(
	10	spelling => {
	11	allow_words => [qw(
	12	AES BLAKEb BLAKEs CPAN CRC ChaCha CryptX DCIT DER Diffie EAX ECCDH ECDH ECDSA Flickr HKDF JSON JWA JWK
	13	Karel Miko OCB OCBv OID OMAC OO OpenSSL PBKDF PEM PKCS RIPEMD Rijndael SHA UUID RFC
	14	decrypt decrypts interoperability cryptographically cryptographic octects
	15	libtomcrypt libtommath
	16	params paramshash irand perl endian zbase bumac bmac budigest bdigest md de
	17	blakes_ blakeb_
	18	XOR'ing XOR'ed
	19	)]
	20	},
	21	);
	22
	23	plan tests => 102;
	24
	25	my @files;
	26	File::Find::find({ wanted=>sub { push @files, $_ if /\.pm$/ }, no_chdir=>1 }, 'lib');
	27
	28	for my $m (sort @files) {
	29	Test::Pod::Spelling::pod_file_spelling_ok( $m, "Spelling in '$m'" );
	30	}

+47

-0

t/005_all_pm_pod_coverage.t less more

	0	use strict;
	1	use warnings;
	2
	3	use Test::More;
	4
	5	plan skip_all => "set TEST_POD to enable this test (developer only!)" unless $ENV{TEST_POD};
	6	plan skip_all => "Pod::Coverage not installed" unless eval { require Pod::Coverage };
	7	plan skip_all => "File::Find not installed" unless eval { require File::Find };
	8	plan tests => 102;
	9
	10	my @files;
	11	File::Find::find({ wanted=>sub { push @files, $_ if /\.pm$/ }, no_chdir=>1 }, 'lib');
	12
	13	my @err;
	14	for my $m (sort @files) {
	15	my $f = $m;
	16	$m =~ s\|[\\/]\|::\|g;
	17	$m =~ s\|^lib::\|\|;
	18	$m =~ s\|\.pm$\|\|;
	19
	20	my $pc;
	21	if ($m eq 'Crypt::PK::DH') {
	22	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(decrypt\|dh_decrypt\|dh_encrypt\|dh_sign_hash\|dh_sign_message\|dh_verify_hash\|dh_verify_message\|encrypt\|sign_hash\|sign_message\|verify_hash\|verify_message)$/] );
	23	}
	24	elsif ($m eq 'Math::BigInt::LTM') {
	25	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(STORABLE_thaw\|STORABLE_freeze\|api_version)$/] );
	26	}
	27	elsif ($m eq 'Crypt::Mode') {
	28	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(add\|decrypt\|encrypt\|finish\|new\|start_decrypt\|start_encrypt)$/] );
	29	}
	30	elsif ($m eq 'Crypt::Mac') {
	31	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(add\|addfile)$/] );
	32	}
	33	elsif ($m eq 'Crypt::AuthEnc::OCB') {
	34	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(blocksize\|aad_add)$/] );
	35	}
	36	elsif ($m eq 'Crypt::AuthEnc::EAX') {
	37	$pc = Pod::Coverage->new(package => $m, pod_from => $f, trustme => [qr/^(header_add\|aad_add)$/] );
	38	}
	39	else {
	40	$pc = Pod::Coverage->new(package => $m, pod_from => $f);
	41	}
	42
	43	my $c = $pc->coverage \|\| 0;
	44	my @u = $pc->uncovered;
	45	ok(@u == 0, sprintf("$m score=%.2f naked=(" . join(" ", @u) . ")", $c));
	46	}

+1

-1

t/auth_enc_ccm.t less more

49	49	is(unpack('H*', $tag), "9e9cba5dd4939d0d8e2687c85c5d3b89", "ccm_encrypt_authenticate: tag (no header)");
50	50	my $pt = ccm_decrypt_verify('AES', $key, $nonce, "", $ct, $tag);
51	51	is($pt, "plain_halfplain_half", "ccm_decrypt_verify: plaintext (no header)");
52		}⏎
	52	}

+7

-7

t/auth_enc_ccm_test_vector_ltc.t less more

6	6
7	7	sub do_test {
8	8	my %a = @_;
9
10		my $key = pack("H*", $a{key});
	9
	10	my $key = pack("H*", $a{key});
11	11	my $nonce = pack("H*", $a{nonce});
12	12	my $header = pack("H*", $a{header});
13	13	my $plaintext = pack("H*", $a{plaintext});
14	14	my $ciphertext = pack("H*", $a{ciphertext});
15	15	my $tag = pack("H*", $a{tag});
16
	16
17	17	my ($ct3, $tag3) = ccm_encrypt_authenticate('AES', $key, $nonce, $header, length($tag), $plaintext);
18	18	is(unpack('H*', $ct3), $a{ciphertext}, "enc: ciphertext");
19	19	is(unpack('H*', $tag3), $a{tag}, "enc: tag");

32	32	ciphertext=>'588c979a61c663d2f066d0c2c0f989806d5f6b61dac384',
33	33	tag=>'17e8d12cfdf926e0',
34	34	},
35
	35
36	36	#/* 13 byte nonce, 12 byte header, 19 byte pt */
37	37	{
38	38	key=>'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf',

42	42	ciphertext=>'a28c6865939a9a79faaa5c4c2a9d4a91cdac8c',
43	43	tag=>'96c861b9c9e61ef1',
44	44	},
45
	45
46	46	#/* supplied by Brian Gladman */
47	47	{
48	48	key=>'404142434445464748494a4b4c4d4e4f',

52	52	ciphertext=>'7162015b',
53	53	tag=>'4dac255d',
54	54	},
55
	55
56	56	{
57	57	key=>'c97c1f67ce371185514a8a19f2bdd52f',
58	58	nonce=>'005030f1844408b5039776e70c',

61	61	ciphertext=>'f3d0a2fe9a3dbf2342a643e43246e80c3c04d019',
62	62	tag=>'7845ce0b16f97623',
63	63	},
64		);
	64	);

+8

-8

t/auth_enc_eax_test_vector_ltc.t less more

6	6
7	7	sub do_test {
8	8	my %a = @_;
9
10		my $key = pack("H*", $a{key});
	9
	10	my $key = pack("H*", $a{key});
11	11	my $nonce = pack("H*", $a{nonce});
12	12	my $header = pack("H*", $a{header});
13	13	my $plaintext = pack("H*", $a{plaintext});
14	14	my $ciphertext = pack("H*", $a{ciphertext});
15	15	my $tag = pack("H*", $a{tag});
16
	16
17	17	# encrypt
18	18	my $m1 = Crypt::AuthEnc::EAX->new("AES", $key, $nonce);
19	19	$m1->header_add($header);

38	38	is(unpack('H*', $tag3), $a{tag}, "enc: tag");
39	39	my $pt3 = eax_decrypt_verify('AES', $key, $nonce, $header, $ciphertext, $tag);
40	40	is(unpack('H*', $pt3), $a{plaintext}, "dec: plaintext");
41
	41
42	42	}
43	43
44	44	do_test(%$_) for (

76	76	{
77	77	#16, 16, 16, 32,
78	78	key => '000102030405060708090a0b0c0d0e0f',
79		nonce => '000102030405060708090a0b0c0d0e0f',
	79	nonce => '000102030405060708090a0b0c0d0e0f',
80	80	header => '000102030405060708090a0b0c0d0e0f',
81	81	plaintext => '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
82	82	ciphertext => '29d878d1a3be857b6fb8c8ea5950a778331fbf2ccf33986f35e8cf121dcb30bc',

86	86	{
87	87	#16, 15, 14, 29,
88	88	key => '000102030405060708090a0b0c0d0e0f',
89		nonce => '000102030405060708090a0b0c0d0e',
	89	nonce => '000102030405060708090a0b0c0d0e',
90	90	header => '000102030405060708090a0b0c0d',
91	91	plaintext => '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c',
92	92	ciphertext => 'dd25c754c5b17c5928b69b73155f7bb8888faf37091ad92c8a24db868b',
93	93	tag => '0d1a14e52224ffd23a05fa02cdef52da',
94	94	},
95
	95
96	96	#/* Vectors from Brian Gladman */
97	97	{
98	98	#16, 16, 8, 0,

121	121	ciphertext => 'd851d5bae0',
122	122	tag => '3a59f238a23e39199dc9266626c40f80',
123	123	},
124		);
	124	);

+11

-11

t/auth_enc_gcm_test_vector_ltc.t less more

6	6
7	7	sub do_test {
8	8	my %a = @_;
9
10		my $key = pack("H*", $a{key});
	9
	10	my $key = pack("H*", $a{key});
11	11	my $adata = pack("H*", $a{adata});
12	12	my $iv = pack("H*", $a{iv});
13	13	my $plaintext = pack("H*", $a{plaintext});
14	14	my $ciphertext = pack("H*", $a{ciphertext});
15	15	my $tag = pack("H*", $a{tag});
16
	16
17	17	# encrypt
18	18	my $m1 = Crypt::AuthEnc::GCM->new("AES", $key);
19	19	$m1->iv_add($iv);

40	40	is(unpack('H*', $tag3), $a{tag}, "enc: tag");
41	41	my $pt3 = gcm_decrypt_verify('AES', $key, $iv, $adata, $ciphertext, $tag);
42	42	is(unpack('H*', $pt3), $a{plaintext}, "dec: plaintext");
43
	43
44	44	}
45	45
46	46	do_test(%$_) for (

54	54	# ciphertext => '',
55	55	# tag => '58e2fccefa7e3061367f1d57a4e7455a',
56	56	# },
57
	57
58	58	#/* test case #2 */
59	59	{
60	60	key => '00000000000000000000000000000000',

64	64	ciphertext => '0388dace60b6a392f328c2b971b2fe78',
65	65	tag => 'ab6e47d42cec13bdf53a67b21257bddf',
66	66	},
67
	67
68	68	#/* test case #3 */
69	69	{
70	70	key => 'feffe9928665731c6d6a8f9467308308',

74	74	ciphertext => '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091473f5985',
75	75	tag => '4d5c2af327cd64a62cf35abd2ba6fab4',
76	76	},
77
	77
78	78	#/* test case #4 */
79	79	{
80	80	key => 'feffe9928665731c6d6a8f9467308308',

84	84	ciphertext => '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091',
85	85	tag => '5bc94fbc3221a5db94fae95ae7121a47',
86	86	},
87
	87
88	88	#/* test case #5 */
89	89	{
90	90	key => 'feffe9928665731c6d6a8f9467308308',

94	94	ciphertext => '61353b4c2806934a777ff51fa22a4755699b2a714fcdc6f83766e5f97b6c742373806900e49f24b22b097544d4896b424989b5e1ebac0f07c23f4598',
95	95	tag => '3612d2e79e3b0785561be14aaca2fccb',
96	96	},
97
	97
98	98	#/* test case #6 */
99	99	{
100	100	key => 'feffe9928665731c6d6a8f9467308308',

104	104	ciphertext => '8ce24998625615b603a033aca13fb894be9112a5c3a211a8ba262a3cca7e2ca701e4a9a4fba43c90ccdcb281d48c7c6fd62875d2aca417034c34aee5',
105	105	tag => '619cc5aefffe0bfa462af43c1699d050',
106	106	},
107
	107
108	108	#/* test case #46 from BG (catches the LTC bug of v1.15) */
109	109	{
110	110	key => '00000000000000000000000000000000',

114	114	ciphertext => 'cbc8d2f15481a4cc7dd1e19aaa83de5678483ec359ae7dec2ab8d534e0906f4b4663faff58a8b2d733b845eef7c9b331e9e10eb2612c995feb1ac15a6286cce8b297a8',
115	115	tag => '8d2d2a9372626f6bee8580276a6366bf',
116	116	}
117		);
	117	);

+4

-4

t/auth_enc_ocb_test_vectors_ietf.t less more

11	11	chomp($l);
12	12	next if $l =~ /^#/;
13	13	$l =~ s/[\s\t]+/ /g;
14
	14
15	15	if ($l eq '') {
16	16	next unless defined $d->{C};
17	17	my $A = pack('H*', $d->{A});

20	20	my $K = pack('H*', $d->{K});
21	21	my $N = pack('H*', $d->{N});
22	22	my $tag_len = $d->{T} * 1;
23
	23
24	24	{ #ENCRYPT
25	25	my $m = Crypt::AuthEnc::OCB->new('AES', $K, $N, $tag_len);
26	26	$m->adata_add($A);

47	47	$v =~ s/\s//g;
48	48	$d->{$k} = $v;
49	49	}
50
	50
51	51	}
52	52
53	53	#print $text;

172	172	P: 000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627
173	173	C: 1792A4E31E0755FB03E31B22116E6C2DDF9EFD6E33D536F1A0124B0A55BAE884ED93481529C76B6AD0C515F4D1CDD4FDAC4F02AA
174	174
175		LAST_ITEM_PLACEHOLDER_DO_NOT_DELETE!!!⏎
	175	LAST_ITEM_PLACEHOLDER_DO_NOT_DELETE!!!

+1

-1

t/cipher_aes_test_vectors_bc.t less more

14	14	my ($k, $v) = split /:/, $pair;
15	15	$d->{$k} = $v;
16	16	}
17
	17
18	18	my $c = Crypt::Cipher::AES->new(pack('H*',$d->{key}));
19	19	my $result = pack('H*', $d->{pt});
20	20	$result = $c->encrypt($result) for(1..$d->{iter});

+1

-1

t/cipher_seed_test_vectors_bc.t less more

12	12	my ($k, $v) = split /:/, $pair;
13	13	$d->{$k} = $v;
14	14	}
15
	15
16	16	my $c = Crypt::Cipher::SEED->new(pack('H*',$d->{key}));
17	17	my $result = pack('H*', $d->{pt});
18	18	$result = $c->encrypt($result) for(1..$d->{iter});

+1

-1

t/cipher_serpent_compat.t less more

25	25	key=000000000000000000000000000000004000000000000000 ptext=00000000000000000000000000000000 ctext=53bd3e8475db67f72910b945bf8c768e
26	26	key=000000000000000000000000000000010000000000000000 ptext=00000000000000000000000000000000 ctext=deab7388a6f1c61d41e25a0d88f062c4
27	27	key=0000000000000000000000800000000000000000000000000000000000000000 ptext=00000000000000000000000000000000 ctext=ad4b018d50e3a28124a0a1259dc667d4
28		key=4000000000000000000000000000000000000000000000000000000000000000 ptext=00000000000000000000000000000000 ctext=eae1d405570174df7df2f9966d509159⏎
	28	key=4000000000000000000000000000000000000000000000000000000000000000 ptext=00000000000000000000000000000000 ctext=eae1d405570174df7df2f9966d509159

+2

-2

t/cipher_test_vectors_ltc.t less more

31	31	my $size;
32	32
33	33	while (my $l = <DATA>) {
34		$l =~ s/[\r\n]*$//;
	34	$l =~ s/[\r\n]*$//;
35	35	$l =~ s/^[\s]([^\s\r\n]+).?/$1/;
36	36	$l =~ s/\s+//g;
37	37	my ($k, $v) = split /:/, $l;

57	57	next unless $tv->{$n}->{$ks}->{$i};
58	58	my $ct = Crypt::Cipher->new($N, $key)->encrypt($bytes);
59	59	is(unpack('H*', $ct), lc($tv->{$n}->{$ks}->{$i}), "$N/$ks/$i");
60		$bytes = $ct;
	60	$bytes = $ct;
61	61	$key = substr($ct x 100, 0, $ks);
62	62	}
63	63	}

+46

-46

t/cipher_test_vectors_openssl.t less more

11	11	use Crypt::Cipher;
12	12
13	13	while (my $l = <DATA>) {
14		$l =~ s/[\r\n]*$//;
	14	$l =~ s/[\r\n]*$//;
15	15	$l =~ s/^\s([^\s\r\n]+).?/$1/;
16	16	$l =~ s/\s+//;
17	17	next if !$l \|\| $l =~ /^#/;

62	62	die "UNKNOWN MODE '$mode'";
63	63	}
64	64	#warn "[$cipher\|$mode, ".length($key).", ".length($iv).", ".length($pt).", ".length($ct).", ".length($flag)."]\n";
65		}
	65	}
66	66
67	67	__DATA__
68	68	#cipher:key:iv:plaintext:ciphertext:0/1(decrypt/encrypt)

119	119	AES-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::AE2D8A571E03AC9C9EB76FAC45AF8E51:F5D3D58503B9699DE785895A96FDBAAF
120	120	AES-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::30C81C46A35CE411E5FBC1191A0A52EF:43B1CD7F598ECE23881B00E3ED030688
121	121	AES-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::F69F2445DF4F9B17AD2B417BE66C3710:7B0C785E27E8AD3F8223207104725DD4
122		# ECB-AES192.Encrypt and ECB-AES192.Decrypt
	122	# ECB-AES192.Encrypt and ECB-AES192.Decrypt
123	123	AES-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::6BC1BEE22E409F96E93D7E117393172A:BD334F1D6E45F25FF712A214571FA5CC
124	124	AES-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::AE2D8A571E03AC9C9EB76FAC45AF8E51:974104846D0AD3AD7734ECB3ECEE4EEF
125	125	AES-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::30C81C46A35CE411E5FBC1191A0A52EF:EF7AFD2270E2E60ADCE0BA2FACE6444E
126	126	AES-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::F69F2445DF4F9B17AD2B417BE66C3710:9A4B41BA738D6C72FB16691603C18E0E
127		# ECB-AES256.Encrypt and ECB-AES256.Decrypt
	127	# ECB-AES256.Encrypt and ECB-AES256.Decrypt
128	128	AES-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::6BC1BEE22E409F96E93D7E117393172A:F3EED1BDB5D2A03C064B5A7E3DB181F8
129	129	AES-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::AE2D8A571E03AC9C9EB76FAC45AF8E51:591CCB10D410ED26DC5BA74A31362870
130	130	AES-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::30C81C46A35CE411E5FBC1191A0A52EF:B6ED21B99CA6F4F9F153E7B1BEAFED1D
131	131	AES-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::F69F2445DF4F9B17AD2B417BE66C3710:23304B7A39F9F3FF067D8D8F9E24ECC7
132	132	# For all CBC encrypts and decrypts, the transformed sequence is
133	133	# AES-bits-CBC:key:IV/ciphertext':plaintext:ciphertext:encdec
134		# CBC-AES128.Encrypt and CBC-AES128.Decrypt
	134	# CBC-AES128.Encrypt and CBC-AES128.Decrypt
135	135	AES-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:7649ABAC8119B246CEE98E9B12E9197D
136	136	AES-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:7649ABAC8119B246CEE98E9B12E9197D:AE2D8A571E03AC9C9EB76FAC45AF8E51:5086CB9B507219EE95DB113A917678B2
137	137	AES-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:5086CB9B507219EE95DB113A917678B2:30C81C46A35CE411E5FBC1191A0A52EF:73BED6B8E3C1743B7116E69E22229516
138	138	AES-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:73BED6B8E3C1743B7116E69E22229516:F69F2445DF4F9B17AD2B417BE66C3710:3FF1CAA1681FAC09120ECA307586E1A7
139		# CBC-AES192.Encrypt and CBC-AES192.Decrypt
	139	# CBC-AES192.Encrypt and CBC-AES192.Decrypt
140	140	AES-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:4F021DB243BC633D7178183A9FA071E8
141	141	AES-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:4F021DB243BC633D7178183A9FA071E8:AE2D8A571E03AC9C9EB76FAC45AF8E51:B4D9ADA9AD7DEDF4E5E738763F69145A
142	142	AES-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:B4D9ADA9AD7DEDF4E5E738763F69145A:30C81C46A35CE411E5FBC1191A0A52EF:571B242012FB7AE07FA9BAAC3DF102E0
143	143	AES-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:571B242012FB7AE07FA9BAAC3DF102E0:F69F2445DF4F9B17AD2B417BE66C3710:08B0E27988598881D920A9E64F5615CD
144		# CBC-AES256.Encrypt and CBC-AES256.Decrypt
	144	# CBC-AES256.Encrypt and CBC-AES256.Decrypt
145	145	AES-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:F58C4C04D6E5F1BA779EABFB5F7BFBD6
146	146	AES-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:F58C4C04D6E5F1BA779EABFB5F7BFBD6:AE2D8A571E03AC9C9EB76FAC45AF8E51:9CFC4E967EDB808D679F777BC6702C7D
147	147	AES-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:9CFC4E967EDB808D679F777BC6702C7D:30C81C46A35CE411E5FBC1191A0A52EF:39F23369A9D9BACFA530E26304231461

149	149	# We don't support CFB{1,8}-AESxxx.{En,De}crypt
150	150	# For all CFB128 encrypts and decrypts, the transformed sequence is
151	151	# AES-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec
152		# CFB128-AES128.Encrypt
	152	# CFB128-AES128.Encrypt
153	153	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:3B3FD92EB72DAD20333449F8E83CFB4A:1
154	154	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:3B3FD92EB72DAD20333449F8E83CFB4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:C8A64537A0B3A93FCDE3CDAD9F1CE58B:1
155	155	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:C8A64537A0B3A93FCDE3CDAD9F1CE58B:30C81C46A35CE411E5FBC1191A0A52EF:26751F67A3CBB140B1808CF187A4F4DF:1
156	156	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:26751F67A3CBB140B1808CF187A4F4DF:F69F2445DF4F9B17AD2B417BE66C3710:C04B05357C5D1C0EEAC4C66F9FF7F2E6:1
157		# CFB128-AES128.Decrypt
	157	# CFB128-AES128.Decrypt
158	158	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:3B3FD92EB72DAD20333449F8E83CFB4A:0
159	159	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:3B3FD92EB72DAD20333449F8E83CFB4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:C8A64537A0B3A93FCDE3CDAD9F1CE58B:0
160	160	AES-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:C8A64537A0B3A93FCDE3CDAD9F1CE58B:30C81C46A35CE411E5FBC1191A0A52EF:26751F67A3CBB140B1808CF187A4F4DF:0

169	169	AES-192-CFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:CDC80D6FDDF18CAB34C25909C99A4174:AE2D8A571E03AC9C9EB76FAC45AF8E51:67CE7F7F81173621961A2B70171D3D7A:0
170	170	AES-192-CFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:67CE7F7F81173621961A2B70171D3D7A:30C81C46A35CE411E5FBC1191A0A52EF:2E1E8A1DD59B88B1C8E60FED1EFAC4C9:0
171	171	AES-192-CFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:2E1E8A1DD59B88B1C8E60FED1EFAC4C9:F69F2445DF4F9B17AD2B417BE66C3710:C05F9F9CA9834FA042AE8FBA584B09FF:0
172		# CFB128-AES256.Encrypt
	172	# CFB128-AES256.Encrypt
173	173	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:DC7E84BFDA79164B7ECD8486985D3860:1
174	174	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:DC7E84BFDA79164B7ECD8486985D3860:AE2D8A571E03AC9C9EB76FAC45AF8E51:39FFED143B28B1C832113C6331E5407B:1
175	175	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:39FFED143B28B1C832113C6331E5407B:30C81C46A35CE411E5FBC1191A0A52EF:DF10132415E54B92A13ED0A8267AE2F9:1
176	176	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:DF10132415E54B92A13ED0A8267AE2F9:F69F2445DF4F9B17AD2B417BE66C3710:75A385741AB9CEF82031623D55B1E471:1
177		# CFB128-AES256.Decrypt
	177	# CFB128-AES256.Decrypt
178	178	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:DC7E84BFDA79164B7ECD8486985D3860:0
179	179	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:DC7E84BFDA79164B7ECD8486985D3860:AE2D8A571E03AC9C9EB76FAC45AF8E51:39FFED143B28B1C832113C6331E5407B:0
180	180	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:39FFED143B28B1C832113C6331E5407B:30C81C46A35CE411E5FBC1191A0A52EF:DF10132415E54B92A13ED0A8267AE2F9:0
181	181	AES-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:DF10132415E54B92A13ED0A8267AE2F9:F69F2445DF4F9B17AD2B417BE66C3710:75A385741AB9CEF82031623D55B1E471:0
182	182	# For all OFB encrypts and decrypts, the transformed sequence is
183	183	# AES-bits-CFB:key:IV/output':plaintext:ciphertext:encdec
184		# OFB-AES128.Encrypt
185		AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:3B3FD92EB72DAD20333449F8E83CFB4A:1
186		AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:50FE67CC996D32B6DA0937E99BAFEC60:AE2D8A571E03AC9C9EB76FAC45AF8E51:7789508D16918F03F53C52DAC54ED825:1
187		AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:D9A4DADA0892239F6B8B3D7680E15674:30C81C46A35CE411E5FBC1191A0A52EF:9740051E9C5FECF64344F7A82260EDCC:1
188		AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:A78819583F0308E7A6BF36B1386ABF23:F69F2445DF4F9B17AD2B417BE66C3710:304C6528F659C77866A510D9C1D6AE5E:1
189		# OFB-AES128.Decrypt
	184	# OFB-AES128.Encrypt
	185	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:3B3FD92EB72DAD20333449F8E83CFB4A:1
	186	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:50FE67CC996D32B6DA0937E99BAFEC60:AE2D8A571E03AC9C9EB76FAC45AF8E51:7789508D16918F03F53C52DAC54ED825:1
	187	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:D9A4DADA0892239F6B8B3D7680E15674:30C81C46A35CE411E5FBC1191A0A52EF:9740051E9C5FECF64344F7A82260EDCC:1
	188	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:A78819583F0308E7A6BF36B1386ABF23:F69F2445DF4F9B17AD2B417BE66C3710:304C6528F659C77866A510D9C1D6AE5E:1
	189	# OFB-AES128.Decrypt
190	190	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:3B3FD92EB72DAD20333449F8E83CFB4A:0
191	191	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:50FE67CC996D32B6DA0937E99BAFEC60:AE2D8A571E03AC9C9EB76FAC45AF8E51:7789508D16918F03F53C52DAC54ED825:0
192	192	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:D9A4DADA0892239F6B8B3D7680E15674:30C81C46A35CE411E5FBC1191A0A52EF:9740051E9C5FECF64344F7A82260EDCC:0
193	193	AES-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:A78819583F0308E7A6BF36B1386ABF23:F69F2445DF4F9B17AD2B417BE66C3710:304C6528F659C77866A510D9C1D6AE5E:0
194		# OFB-AES192.Encrypt
195		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CDC80D6FDDF18CAB34C25909C99A4174:1
196		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:FCC28B8D4C63837C09E81700C1100401:1
197		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:8D9A9AEAC0F6596F559C6D4DAF59A5F2:1
198		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:6D9F200857CA6C3E9CAC524BD9ACC92A:1
199		# OFB-AES192.Decrypt
200		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CDC80D6FDDF18CAB34C25909C99A4174:0
201		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:FCC28B8D4C63837C09E81700C1100401:0
202		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:8D9A9AEAC0F6596F559C6D4DAF59A5F2:0
203		AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:6D9F200857CA6C3E9CAC524BD9ACC92A:0
204		# OFB-AES256.Encrypt
	194	# OFB-AES192.Encrypt
	195	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CDC80D6FDDF18CAB34C25909C99A4174:1
	196	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:FCC28B8D4C63837C09E81700C1100401:1
	197	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:8D9A9AEAC0F6596F559C6D4DAF59A5F2:1
	198	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:6D9F200857CA6C3E9CAC524BD9ACC92A:1
	199	# OFB-AES192.Decrypt
	200	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CDC80D6FDDF18CAB34C25909C99A4174:0
	201	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:FCC28B8D4C63837C09E81700C1100401:0
	202	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:8D9A9AEAC0F6596F559C6D4DAF59A5F2:0
	203	AES-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:6D9F200857CA6C3E9CAC524BD9ACC92A:0
	204	# OFB-AES256.Encrypt
205	205	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:DC7E84BFDA79164B7ECD8486985D3860:1
206	206	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:B7BF3A5DF43989DD97F0FA97EBCE2F4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:4FEBDC6740D20B3AC88F6AD82A4FB08D:1
207	207	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:E1C656305ED1A7A6563805746FE03EDC:30C81C46A35CE411E5FBC1191A0A52EF:71AB47A086E86EEDF39D1C5BBA97C408:1
208	208	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:41635BE625B48AFC1666DD42A09D96E7:F69F2445DF4F9B17AD2B417BE66C3710:0126141D67F37BE8538F5A8BE740E484:1
209		# OFB-AES256.Decrypt
	209	# OFB-AES256.Decrypt
210	210	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:DC7E84BFDA79164B7ECD8486985D3860:0
211	211	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:B7BF3A5DF43989DD97F0FA97EBCE2F4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:4FEBDC6740D20B3AC88F6AD82A4FB08D:0
212	212	AES-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:E1C656305ED1A7A6563805746FE03EDC:30C81C46A35CE411E5FBC1191A0A52EF:71AB47A086E86EEDF39D1C5BBA97C408:0

262	262	CAMELLIA-192-ECB:000102030405060708090A0B0C0D0E0F1011121314151617::00112233445566778899AABBCCDDEEFF:B22F3C36B72D31329EEE8ADDC2906C68:1
263	263	CAMELLIA-256-ECB:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F::00112233445566778899AABBCCDDEEFF:2EDF1F3418D53B88841FC8985FB1ECF2:1
264	264
265		# ECB-CAMELLIA128.Encrypt and ECB-CAMELLIA128.Decrypt
	265	# ECB-CAMELLIA128.Encrypt and ECB-CAMELLIA128.Decrypt
266	266	CAMELLIA-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::6BC1BEE22E409F96E93D7E117393172A:432FC5DCD628115B7C388D770B270C96
267	267	CAMELLIA-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::AE2D8A571E03AC9C9EB76FAC45AF8E51:0BE1F14023782A22E8384C5ABB7FAB2B
268	268	CAMELLIA-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::30C81C46A35CE411E5FBC1191A0A52EF:A0A1ABCD1893AB6FE0FE5B65DF5F8636
269	269	CAMELLIA-128-ECB:2B7E151628AED2A6ABF7158809CF4F3C::F69F2445DF4F9B17AD2B417BE66C3710:E61925E0D5DFAA9BB29F815B3076E51A
270	270
271		# ECB-CAMELLIA192.Encrypt and ECB-CAMELLIA192.Decrypt
	271	# ECB-CAMELLIA192.Encrypt and ECB-CAMELLIA192.Decrypt
272	272	CAMELLIA-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::6BC1BEE22E409F96E93D7E117393172A:CCCC6C4E138B45848514D48D0D3439D3
273	273	CAMELLIA-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::AE2D8A571E03AC9C9EB76FAC45AF8E51:5713C62C14B2EC0F8393B6AFD6F5785A
274	274	CAMELLIA-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::30C81C46A35CE411E5FBC1191A0A52EF:B40ED2B60EB54D09D030CF511FEEF366
275	275	CAMELLIA-192-ECB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B::F69F2445DF4F9B17AD2B417BE66C3710:909DBD95799096748CB27357E73E1D26
276	276
277		# ECB-CAMELLIA256.Encrypt and ECB-CAMELLIA256.Decrypt
	277	# ECB-CAMELLIA256.Encrypt and ECB-CAMELLIA256.Decrypt
278	278	CAMELLIA-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::6BC1BEE22E409F96E93D7E117393172A:BEFD219B112FA00098919CD101C9CCFA
279	279	CAMELLIA-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::AE2D8A571E03AC9C9EB76FAC45AF8E51:C91D3A8F1AEA08A9386CF4B66C0169EA
280	280	CAMELLIA-256-ECB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4::30C81C46A35CE411E5FBC1191A0A52EF:A623D711DC5F25A51BB8A80D56397D28

282	282
283	283	# For all CBC encrypts and decrypts, the transformed sequence is
284	284	# CAMELLIA-bits-CBC:key:IV/ciphertext':plaintext:ciphertext:encdec
285		# CBC-CAMELLIA128.Encrypt and CBC-CAMELLIA128.Decrypt
	285	# CBC-CAMELLIA128.Encrypt and CBC-CAMELLIA128.Decrypt
286	286	CAMELLIA-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:1607CF494B36BBF00DAEB0B503C831AB
287	287	CAMELLIA-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:1607CF494B36BBF00DAEB0B503C831AB:AE2D8A571E03AC9C9EB76FAC45AF8E51:A2F2CF671629EF7840C5A5DFB5074887
288	288	CAMELLIA-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:A2F2CF671629EF7840C5A5DFB5074887:30C81C46A35CE411E5FBC1191A0A52EF:0F06165008CF8B8B5A63586362543E54
289	289	CAMELLIA-128-CBC:2B7E151628AED2A6ABF7158809CF4F3C:36A84CDAFD5F9A85ADA0F0A993D6D577:F69F2445DF4F9B17AD2B417BE66C3710:74C64268CDB8B8FAF5B34E8AF3732980
290	290
291		# CBC-CAMELLIA192.Encrypt and CBC-CAMELLIA192.Decrypt
	291	# CBC-CAMELLIA192.Encrypt and CBC-CAMELLIA192.Decrypt
292	292	CAMELLIA-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:2A4830AB5AC4A1A2405955FD2195CF93
293	293	CAMELLIA-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:2A4830AB5AC4A1A2405955FD2195CF93:AE2D8A571E03AC9C9EB76FAC45AF8E51:5D5A869BD14CE54264F892A6DD2EC3D5
294	294	CAMELLIA-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:5D5A869BD14CE54264F892A6DD2EC3D5:30C81C46A35CE411E5FBC1191A0A52EF:37D359C3349836D884E310ADDF68C449
295	295	CAMELLIA-192-CBC:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:37D359C3349836D884E310ADDF68C449:F69F2445DF4F9B17AD2B417BE66C3710:01FAAA930B4AB9916E9668E1428C6B08
296	296
297		# CBC-CAMELLIA256.Encrypt and CBC-CAMELLIA256.Decrypt
	297	# CBC-CAMELLIA256.Encrypt and CBC-CAMELLIA256.Decrypt
298	298	CAMELLIA-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:E6CFA35FC02B134A4D2C0B6737AC3EDA
299	299	CAMELLIA-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:E6CFA35FC02B134A4D2C0B6737AC3EDA:AE2D8A571E03AC9C9EB76FAC45AF8E51:36CBEB73BD504B4070B1B7DE2B21EB50
300	300	CAMELLIA-256-CBC:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:36CBEB73BD504B4070B1B7DE2B21EB50:30C81C46A35CE411E5FBC1191A0A52EF:E31A6055297D96CA3330CDF1B1860A83

303	303	# We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt
304	304	# For all CFB128 encrypts and decrypts, the transformed sequence is
305	305	# CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec
306		# CFB128-CAMELLIA128.Encrypt
	306	# CFB128-CAMELLIA128.Encrypt
307	307	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1
308	308	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:1
309	309	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:9C2157A664626D1DEF9EA420FDE69B96:1
310	310	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:9C2157A664626D1DEF9EA420FDE69B96:F69F2445DF4F9B17AD2B417BE66C3710:742A25F0542340C7BAEF24CA8482BB09:1
311	311
312		# CFB128-CAMELLIA128.Decrypt
	312	# CFB128-CAMELLIA128.Decrypt
313	313	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:0
314	314	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:0
315	315	CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:9C2157A664626D1DEF9EA420FDE69B96:0

327	327	CAMELLIA-192-CFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:86F8491627906D780C7A6D46EA331F98:30C81C46A35CE411E5FBC1191A0A52EF:69511CCE594CF710CB98BB63D7221F01:0
328	328	CAMELLIA-192-CFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:69511CCE594CF710CB98BB63D7221F01:F69F2445DF4F9B17AD2B417BE66C3710:D5B5378A3ABED55803F25565D8907B84:0
329	329
330		# CFB128-CAMELLIA256.Encrypt
	330	# CFB128-CAMELLIA256.Encrypt
331	331	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CF6107BB0CEA7D7FB1BD31F5E7B06C93:1
332	332	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:CF6107BB0CEA7D7FB1BD31F5E7B06C93:AE2D8A571E03AC9C9EB76FAC45AF8E51:89BEDB4CCDD864EA11BA4CBE849B5E2B:1
333	333	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:89BEDB4CCDD864EA11BA4CBE849B5E2B:30C81C46A35CE411E5FBC1191A0A52EF:555FC3F34BDD2D54C62D9E3BF338C1C4:1
334	334	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:555FC3F34BDD2D54C62D9E3BF338C1C4:F69F2445DF4F9B17AD2B417BE66C3710:5953ADCE14DB8C7F39F1BD39F359BFFA:1
335	335
336		# CFB128-CAMELLIA256.Decrypt
	336	# CFB128-CAMELLIA256.Decrypt
337	337	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CF6107BB0CEA7D7FB1BD31F5E7B06C93:0
338	338	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:CF6107BB0CEA7D7FB1BD31F5E7B06C93:AE2D8A571E03AC9C9EB76FAC45AF8E51:89BEDB4CCDD864EA11BA4CBE849B5E2B:0
339	339	CAMELLIA-256-CFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:89BEDB4CCDD864EA11BA4CBE849B5E2B:30C81C46A35CE411E5FBC1191A0A52EF:555FC3F34BDD2D54C62D9E3BF338C1C4:0

341	341
342	342	# For all OFB encrypts and decrypts, the transformed sequence is
343	343	# CAMELLIA-bits-OFB:key:IV/output':plaintext:ciphertext:encdec
344		# OFB-CAMELLIA128.Encrypt
	344	# OFB-CAMELLIA128.Encrypt
345	345	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1
346	346	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:50FE67CC996D32B6DA0937E99BAFEC60:AE2D8A571E03AC9C9EB76FAC45AF8E51:25623DB569CA51E01482649977E28D84:1
347	347	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:D9A4DADA0892239F6B8B3D7680E15674:30C81C46A35CE411E5FBC1191A0A52EF:C776634A60729DC657D12B9FCA801E98:1
348	348	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:A78819583F0308E7A6BF36B1386ABF23:F69F2445DF4F9B17AD2B417BE66C3710:D776379BE0E50825E681DA1A4C980E8E:1
349	349
350		# OFB-CAMELLIA128.Decrypt
	350	# OFB-CAMELLIA128.Decrypt
351	351	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:0
352	352	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:50FE67CC996D32B6DA0937E99BAFEC60:AE2D8A571E03AC9C9EB76FAC45AF8E51:25623DB569CA51E01482649977E28D84:0
353	353	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:D9A4DADA0892239F6B8B3D7680E15674:30C81C46A35CE411E5FBC1191A0A52EF:C776634A60729DC657D12B9FCA801E98:0
354	354	CAMELLIA-128-OFB:2B7E151628AED2A6ABF7158809CF4F3C:A78819583F0308E7A6BF36B1386ABF23:F69F2445DF4F9B17AD2B417BE66C3710:D776379BE0E50825E681DA1A4C980E8E:0
355	355
356		# OFB-CAMELLIA192.Encrypt
	356	# OFB-CAMELLIA192.Encrypt
357	357	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:C832BB9780677DAA82D9B6860DCD565E:1
358	358	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:8ECEB7D0350D72C7F78562AEBDF99339:1
359	359	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:BDD62DBBB9700846C53B507F544696F0:1
360	360	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:E28014E046B802F385C4C2E13EAD4A72:1
361	361
362		# OFB-CAMELLIA192.Decrypt
	362	# OFB-CAMELLIA192.Decrypt
363	363	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:C832BB9780677DAA82D9B6860DCD565E:0
364	364	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:A609B38DF3B1133DDDFF2718BA09565E:AE2D8A571E03AC9C9EB76FAC45AF8E51:8ECEB7D0350D72C7F78562AEBDF99339:0
365	365	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:52EF01DA52602FE0975F78AC84BF8A50:30C81C46A35CE411E5FBC1191A0A52EF:BDD62DBBB9700846C53B507F544696F0:0
366	366	CAMELLIA-192-OFB:8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B:BD5286AC63AABD7EB067AC54B553F71D:F69F2445DF4F9B17AD2B417BE66C3710:E28014E046B802F385C4C2E13EAD4A72:0
367	367
368		# OFB-CAMELLIA256.Encrypt
	368	# OFB-CAMELLIA256.Encrypt
369	369	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CF6107BB0CEA7D7FB1BD31F5E7B06C93:1
370	370	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:B7BF3A5DF43989DD97F0FA97EBCE2F4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:127AD97E8E3994E4820027D7BA109368:1
371	371	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:E1C656305ED1A7A6563805746FE03EDC:30C81C46A35CE411E5FBC1191A0A52EF:6BFF6265A6A6B7A535BC65A80B17214E:1
372	372	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:41635BE625B48AFC1666DD42A09D96E7:F69F2445DF4F9B17AD2B417BE66C3710:0A4A0404E26AA78A27CB271E8BF3CF20:1
373	373
374		# OFB-CAMELLIA256.Decrypt
	374	# OFB-CAMELLIA256.Decrypt
375	375	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:CF6107BB0CEA7D7FB1BD31F5E7B06C93:0
376	376	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:B7BF3A5DF43989DD97F0FA97EBCE2F4A:AE2D8A571E03AC9C9EB76FAC45AF8E51:127AD97E8E3994E4820027D7BA109368:0
377	377	CAMELLIA-256-OFB:603DEB1015CA71BE2B73AEF0857D77811F352C073B6108D72D9810A30914DFF4:E1C656305ED1A7A6563805746FE03EDC:30C81C46A35CE411E5FBC1191A0A52EF:6BFF6265A6A6B7A535BC65A80B17214E:0

385	385	SEED-ECB:00000000000000000000000000000000::000102030405060708090A0B0C0D0E0F:5EBAC6E0054E166819AFF1CC6D346CDB:1
386	386	SEED-ECB:000102030405060708090A0B0C0D0E0F::00000000000000000000000000000000:C11F22F20140505084483597E4370F43:1
387	387	SEED-ECB:4706480851E61BE85D74BFB3FD956185::83A2F8A288641FB9A4E9A5CC2F131C7D:EE54D13EBCAE706D226BC3142CD40D4A:1
388		SEED-ECB:28DBC3BC49FFD87DCFA509B11D422BE7::B41E6BE2EBA84A148E2EED84593C5EC7:9B9B7BFCD1813CB95D0B3618F40F5122:1 ⏎
	388	SEED-ECB:28DBC3BC49FFD87DCFA509B11D422BE7::B41E6BE2EBA84A148E2EED84593C5EC7:9B9B7BFCD1813CB95D0B3618F40F5122:1

+1

-1

t/cipher_twofish_test_vectors_bc.t less more

12	12	my ($k, $v) = split /:/, $pair;
13	13	$d->{$k} = $v;
14	14	}
15
	15
16	16	my $c = Crypt::Cipher::Twofish->new(pack('H*',$d->{key}));
17	17	my $result = pack('H*', $d->{pt});
18	18	$result = $c->encrypt($result) for(1..$d->{iter});

+1

-1

t/cipher_xtea_test_vectors_bc.t less more

12	12	my ($k, $v) = split /:/, $pair;
13	13	$d->{$k} = $v;
14	14	}
15
	15
16	16	my $c = Crypt::Cipher::XTEA->new(pack('H*',$d->{key}));
17	17	my $result = pack('H*', $d->{pt});
18	18	$result = $c->encrypt($result) for(1..$d->{iter});

+1

-1

t/crypt-misc.t less more

141	141	is(unpack("H*", decode_b32b(encode_b32b($b))), $h);
142	142	is(unpack("H*", decode_b32z(encode_b32z($b))), $h);
143	143	is(unpack("H*", decode_b32c(encode_b32c($b))), $h);
144		}⏎
	144	}

+1

-1

t/digest_test_vectors_ltc.t less more

22	22	my $hash;
23	23
24	24	while (my $l = <DATA>) {
25		$l =~ s/[\r\n]*$//;
	25	$l =~ s/[\r\n]*$//;
26	26	$l =~ s/^[\s]([^\s\r\n]+).?/$1/;
27	27	$l =~ s/\s+//;
28	28	my ($k, $v) = split /:/, $l;

+7

-7

t/key_derivation.t less more

12	12	my $expected_prk = "077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5";
13	13	my $expected_okm = "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865";
14	14
15		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	15	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
16	16	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
17	17	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
18	18	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/1");

29	29	my $expected_prk = "06a6b88c5853361a06104c9ceb35b45cef760014904671014a193f40c15fc244";
30	30	my $expected_okm = "b11e398dc80327a1c8e7f78c596a49344f012eda2d4efad8a050cc4c19afa97c59045a99cac7827271cb41c65e590e09da3275600c2f09b8367793a9aca3db71cc30c58179ec3e87c14c01d5c1f3434f1d87";
31	31
32		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	32	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
33	33	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
34	34	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
35	35	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/2");

46	46	my $expected_prk = "19ef24a32c717b167f33a91d6f648bdf96596776afdb6377ac434c1c293ccb04";
47	47	my $expected_okm = "8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d9d201395faa4b61a96c8";
48	48
49		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	49	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
50	50	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
51	51	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
52	52	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/3");

63	63	my $expected_prk = "9b6c18c432a7bf8f0e71c8eb88f4b30baa2ba243";
64	64	my $expected_okm = "085a01ea1b10f36933068b56efa5ad81a4f14b822f5b091568a9cdd4f155fda2c22e422478d305f3f896";
65	65
66		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	66	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
67	67	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
68	68	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
69	69	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/4");

80	80	my $expected_prk = "8adae09a2a307059478d309b26c4115a224cfaf6";
81	81	my $expected_okm = "0bd770a74d1160f7c9f12cd5912a06ebff6adcae899d92191fe4305673ba2ffe8fa3f1a4e5ad79f3f334b3b202b2173c486ea37ce3d397ed034c7f9dfeb15c5e927336d0441f4c4300e2cff0d0900b52d3b4";
82	82
83		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	83	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
84	84	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
85	85	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
86	86	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/5");

97	97	my $expected_prk = "da8c8a73c7fa77288ec6f5e7c297786aa0d32d01";
98	98	my $expected_okm = "0ac1af7002b3d761d1e55298da9d0506b9ae52057220a306e07b6b87e8df21d0ea00033de03984d34918";
99	99
100		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	100	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
101	101	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
102	102	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
103	103	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/6");

114	114	my $expected_prk = "2adccada18779e7c2077ad2eb19d3f3e731385dd";
115	115	my $expected_okm = "2c91117204d745f3500d636a62f64f0ab3bae548aa53d423b0d1f27ebba6f5e5673a081d70cce7acfc48";
116	116
117		my $prk = hkdf_extract($keying_material, $salt, $hash_name);
	117	my $prk = hkdf_extract($keying_material, $salt, $hash_name);
118	118	my $okm1 = hkdf_expand($prk, $hash_name, $len, $info);
119	119	my $okm2 = hkdf($keying_material, $salt, $hash_name, $len, $info);
120	120	is(unpack("H*", $prk), $expected_prk, "PRK hkdf_extract/7");

+206

-0

t/mac_hmac_nist.t less more

	0	use strict;
	1	use warnings;
	2
	3	use Test::More tests => 36;
	4
	5	use Crypt::Mac::HMAC 'hmac_hex';
	6
	7	# test vectors from https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/example-values#aMsgAuth
	8
	9	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA3-224.pdf
	10	{
	11	my $input = "Sample message for keylen<blocklen";
	12	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b");
	13	is( hmac_hex('SHA3_224', $key, $input), '332cfd59347fdb8e576e77260be4aba2d6dc53117b3bfb52c6d18c04', 'SHA3_224');
	14	}
	15	{
	16	my $input = "Sample message for keylen=blocklen";
	17	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f");
	18	is( hmac_hex('SHA3_224', $key, $input), 'd8b733bcf66c644a12323d564e24dcf3fc75f231f3b67968359100c7', 'SHA3_224');
	19	}
	20	{
	21	my $input = "Sample message for keylen>blocklen";
	22	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaab");
	23	is( hmac_hex('SHA3_224', $key, $input), '078695eecc227c636ad31d063a15dd05a7e819a66ec6d8de1e193e59', 'SHA3_224');
	24	}
	25	{
	26	my $input = "Sample message for keylen<blocklen, with truncated tag";
	27	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b");
	28	is( substr(hmac_hex('SHA3_224', $key, $input), 0, 28), '8569c54cbb00a9b78ff1b391b0e5', 'SHA3_224');
	29	}
	30
	31	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA3-256.pdf
	32	{
	33	my $input = "Sample message for keylen<blocklen";
	34	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f");
	35	is( hmac_hex('SHA3_256', $key, $input), '4fe8e202c4f058e8dddc23d8c34e467343e23555e24fc2f025d598f558f67205', 'SHA3_256');
	36	}
	37	{
	38	my $input = "Sample message for keylen=blocklen";
	39	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687");
	40	is( hmac_hex('SHA3_256', $key, $input), '68b94e2e538a9be4103bebb5aa016d47961d4d1aa906061313b557f8af2c3faa', 'SHA3_256');
	41	}
	42	{
	43	my $input = "Sample message for keylen>blocklen";
	44	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7");
	45	is( hmac_hex('SHA3_256', $key, $input), '9bcf2c238e235c3ce88404e813bd2f3a97185ac6f238c63d6229a00b07974258', 'SHA3_256');
	46	}
	47	{
	48	my $input = "Sample message for keylen<blocklen, with truncated tag";
	49	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f");
	50	is( substr(hmac_hex('SHA3_256', $key, $input), 0, 32), 'c8dc7148d8c1423aa549105dafdf9cad', 'SHA3_256');
	51	}
	52
	53	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA3-384.pdf
	54	{
	55	my $input = "Sample message for keylen<blocklen";
	56	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f");
	57	is( hmac_hex('SHA3_384', $key, $input), 'd588a3c51f3f2d906e8298c1199aa8ff6296218127f6b38a90b6afe2c5617725bc99987f79b22a557b6520db710b7f42', 'SHA3_384');
	58	}
	59	{
	60	my $input = "Sample message for keylen=blocklen";
	61	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f6061626364656667");
	62	is( hmac_hex('SHA3_384', $key, $input), 'a27d24b592e8c8cbf6d4ce6fc5bf62d8fc98bf2d486640d9eb8099e24047837f5f3bffbe92dcce90b4ed5b1e7e44fa90', 'SHA3_384');
	63	}
	64	{
	65	my $input = "Sample message for keylen>blocklen";
	66	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f9091929394959697");
	67	is( hmac_hex('SHA3_384', $key, $input), 'e5ae4c739f455279368ebf36d4f5354c95aa184c899d3870e460ebc288ef1f9470053f73f7c6da2a71bcaec38ce7d6ac', 'SHA3_384');
	68	}
	69	{
	70	my $input = "Sample message for keylen<blocklen, with truncated tag";
	71	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f");
	72	is( substr(hmac_hex('SHA3_384', $key, $input), 0, 48), '25f4bf53606e91af79d24a4bb1fd6aecd44414a30c8ebb0a', 'SHA3_384');
	73	}
	74
	75	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA3-512.pdf
	76	{
	77	my $input = "Sample message for keylen<blocklen";
	78	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
	79	is( hmac_hex('SHA3_512', $key, $input), '4efd629d6c71bf86162658f29943b1c308ce27cdfa6db0d9c3ce81763f9cbce5f7ebe9868031db1a8f8eb7b6b95e5c5e3f657a8996c86a2f6527e307f0213196', 'SHA3_512');
	80	}
	81	{
	82	my $input = "Sample message for keylen=blocklen";
	83	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647");
	84	is( hmac_hex('SHA3_512', $key, $input), '544e257ea2a3e5ea19a590e6a24b724ce6327757723fe2751b75bf007d80f6b360744bf1b7a88ea585f9765b47911976d3191cf83c039f5ffab0d29cc9d9b6da', 'SHA3_512');
	85	}
	86	{
	87	my $input = "Sample message for keylen>blocklen";
	88	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f8081828384858687");
	89	is( hmac_hex('SHA3_512', $key, $input), '5f464f5e5b7848e3885e49b2c385f0694985d0e38966242dc4a5fe3fea4b37d46b65ceced5dcf59438dd840bab22269f0ba7febdb9fcf74602a35666b2a32915', 'SHA3_512');
	90	}
	91	{
	92	my $input = "Sample message for keylen<blocklen, with truncated tag";
	93	my $key = pack("H*", "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f");
	94	is( substr(hmac_hex('SHA3_512', $key, $input), 0, 64), '7bb06d859257b25ce73ca700df34c5cbef5c898bac91029e0b27975d4e526a08', 'SHA3_512');
	95	}
	96
	97	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA1.pdf
	98	{
	99	my $input = "Sample message for keylen=blocklen";
	100	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F");
	101	is( hmac_hex('SHA1', $key, $input), '5fd596ee78d5553c8ff4e72d266dfd192366da29', 'SHA1');
	102	}
	103	{
	104	my $input = "Sample message for keylen<blocklen";
	105	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F10111213");
	106	is( hmac_hex('SHA1', $key, $input), '4c99ff0cb1b31bd33f8431dbaf4d17fcd356a807', 'SHA1');
	107	}
	108	{
	109	my $input = "Sample message for keylen=blocklen";
	110	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F60616263");
	111	is( hmac_hex('SHA1', $key, $input), '2d51b2f7750e410584662e38f133435f4c4fd42a', 'SHA1');
	112	}
	113	{
	114	my $input = "Sample message for keylen<blocklen, with truncated tag";
	115	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30");
	116	is( substr(hmac_hex('SHA1', $key, $input), 0, 24), 'fe3529565cd8e28c5fa79eac', 'SHA1');
	117	}
	118
	119	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA224.pdf
	120	{
	121	my $input = "Sample message for keylen=blocklen";
	122	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F");
	123	is( hmac_hex('SHA224', $key, $input), 'c7405e3ae058e8cd30b08b4140248581ed174cb34e1224bcc1efc81b', 'SHA224');
	124	}
	125	{
	126	my $input = "Sample message for keylen<blocklen";
	127	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B");
	128	is( hmac_hex('SHA224', $key, $input), 'e3d249a8cfb67ef8b7a169e9a0a599714a2cecba65999a51beb8fbbe', 'SHA224');
	129	}
	130	{
	131	my $input = "Sample message for keylen=blocklen";
	132	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F60616263");
	133	is( hmac_hex('SHA224', $key, $input), '91c52509e5af8531601ae6230099d90bef88aaefb961f4080abc014d', 'SHA224');
	134	}
	135	{
	136	my $input = "Sample message for keylen<blocklen, with truncated tag";
	137	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30");
	138	is( substr(hmac_hex('SHA224', $key, $input), 0, 32), 'd522f1df596ca4b4b1c23d27bde067d6', 'SHA224');
	139	}
	140
	141	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA256.pdf
	142	{
	143	my $input = "Sample message for keylen=blocklen";
	144	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F");
	145	is( hmac_hex('SHA256', $key, $input), '8bb9a1db9806f20df7f77b82138c7914d174d59e13dc4d0169c9057b133e1d62', 'SHA256');
	146	}
	147	{
	148	my $input = "Sample message for keylen<blocklen";
	149	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F");
	150	is( hmac_hex('SHA256', $key, $input), 'a28cf43130ee696a98f14a37678b56bcfcbdd9e5cf69717fecf5480f0ebdf790', 'SHA256');
	151	}
	152	{
	153	my $input = "Sample message for keylen=blocklen";
	154	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F60616263");
	155	is( hmac_hex('SHA256', $key, $input), 'bdccb6c72ddeadb500ae768386cb38cc41c63dbb0878ddb9c7a38a431b78378d', 'SHA256');
	156	}
	157	{
	158	my $input = "Sample message for keylen<blocklen, with truncated tag";
	159	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30");
	160	is( substr(hmac_hex('SHA256', $key, $input), 0, 32), '27a8b157839efeac98df070b331d5936', 'SHA256');
	161	}
	162
	163	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA384.pdf
	164	{
	165	my $input = "Sample message for keylen=blocklen";
	166	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F");
	167	is( hmac_hex('SHA384', $key, $input), '63c5daa5e651847ca897c95814ab830bededc7d25e83eef9195cd45857a37f448947858f5af50cc2b1b730ddf29671a9', 'SHA384');
	168	}
	169	{
	170	my $input = "Sample message for keylen<blocklen";
	171	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F");
	172	is( hmac_hex('SHA384', $key, $input), '6eb242bdbb582ca17bebfa481b1e23211464d2b7f8c20b9ff2201637b93646af5ae9ac316e98db45d9cae773675eeed0', 'SHA384');
	173	}
	174	{
	175	my $input = "Sample message for keylen=blocklen";
	176	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7");
	177	is( substr(hmac_hex('SHA384', $key, $input), 0, 48), '5b664436df69b0ca22551231a3f0a3d5b4f97991713cfa84', 'SHA384');
	178	}
	179	{
	180	my $input = "Sample message for keylen<blocklen, with truncated tag";
	181	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30");
	182	is( substr(hmac_hex('SHA384', $key, $input), 0, 48), 'c48130d3df703dd7cdaa56800dfbd2ba2458320e6e1f98fe', 'SHA384');
	183	}
	184
	185	# https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/HMAC_SHA512.pdf
	186	{
	187	my $input = "Sample message for keylen=blocklen";
	188	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F");
	189	is( hmac_hex('SHA512', $key, $input), 'fc25e240658ca785b7a811a8d3f7b4ca48cfa26a8a366bf2cd1f836b05fcb024bd36853081811d6cea4216ebad79da1cfcb95ea4586b8a0ce356596a55fb1347', 'SHA512');
	190	}
	191	{
	192	my $input = "Sample message for keylen<blocklen";
	193	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F");
	194	is( hmac_hex('SHA512', $key, $input), 'fd44c18bda0bb0a6ce0e82b031bf2818f6539bd56ec00bdc10a8a2d730b3634de2545d639b0f2cf710d0692c72a1896f1f211c2b922d1a96c392e07e7ea9fedc', 'SHA512');
	195	}
	196	{
	197	my $input = "Sample message for keylen=blocklen";
	198	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7");
	199	is( hmac_hex('SHA512', $key, $input), 'd93ec8d2de1ad2a9957cb9b83f14e76ad6b5e0cce285079a127d3b14bccb7aa7286d4ac0d4ce64215f2bc9e6870b33d97438be4aaa20cda5c5a912b48b8e27f3', 'SHA512');
	200	}
	201	{
	202	my $input = "Sample message for keylen<blocklen, with truncated tag";
	203	my $key = pack("H*", "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30");
	204	is( substr(hmac_hex('SHA512', $key, $input), 0, 64), '00f3e9a77bb0f06de15f160603e42b5028758808596664c03e1ab8fb2b076778', 'SHA512');
	205	}

+3

-3

t/mac_hmac_test_vectors_ltc.t less more

23	23	my $name;
24	24
25	25	while (my $l = <DATA>) {
26		$l =~ s/[\r\n]*$//;
	26	$l =~ s/[\r\n]*$//;
27	27	$l =~ s/^[\s]([^\s\r\n]+).?/$1/;
28	28	$l =~ s/\s+//;
29	29	if ($l=~/^HMAC-([^\n\r]+)/) {

41	41
42	42	for my $n (sort keys %$tv) {
43	43	my $N = $trans->{$n} \|\| die "FATAL: unknown name '$n'";
44		my $key = substr($seq, 0, Crypt::Digest->hashsize($N));
	44	my $key = substr($seq, 0, Crypt::Digest->hashsize($N));
45	45	for my $i (0..255) {
46	46	my $bytes = substr($seq, 0, $i);
47	47	next unless $tv->{$n}->{$i};
48	48	my $result = Crypt::Mac::HMAC->new($N, $key)->add($bytes)->mac;
49	49	is(unpack('H*', $result), lc($tv->{$n}->{$i}), "$N/$i");
50		$bytes = $result;
	50	$bytes = $result;
51	51	$key = substr($result x 100, 0, Crypt::Digest->hashsize($N));
52	52	}
53	53	}

+3

-3

t/mac_omac_test_vectors_ltc.t less more

31	31	my $ks;
32	32
33	33	while (my $l = <DATA>) {
34		$l =~ s/[\r\n]*$//;
	34	$l =~ s/[\r\n]*$//;
35	35	$l =~ s/^[\s]([^\s\r\n]+).?/$1/;
36	36	$l =~ s/\s+//;
37	37	if ($l=~/^OMAC-([a-z0-9\+\-]+).*?(\d+)/i) {

51	51	for my $n (sort keys %$tv) {
52	52	for my $ks (sort keys %{$tv->{$n}}) {
53	53	my $N = $trans->{$n} \|\| die "FATAL: unknown name '$n'";
54		my $key = substr($seq, 0, $ks);
	54	my $key = substr($seq, 0, $ks);
55	55	for my $i (0..255) {
56	56	my $bytes = substr($seq, 0, $i);
57	57	next unless $tv->{$n}->{$ks}->{$i};
58	58	my $result = Crypt::Mac::OMAC->new($N, $key)->add($bytes)->mac;
59	59	is(unpack('H*', $result), lc($tv->{$n}->{$ks}->{$i}), "$N/$i");
60		$bytes = $result;
	60	$bytes = $result;
61	61	$key = substr($result x 100, 0, $ks);
62	62	}
63	63	}

+3

-3

t/mac_pmac_test_vectors_ltc.t less more

31	31	my $ks;
32	32
33	33	while (my $l = <DATA>) {
34		$l =~ s/[\r\n]*$//;
	34	$l =~ s/[\r\n]*$//;
35	35	$l =~ s/^[\s]([^\s\r\n]+).?/$1/;
36	36	$l =~ s/\s+//;
37	37	if ($l=~/^PMAC-([a-z0-9\+\-]+).*?(\d+)/i) {

51	51	for my $n (sort keys %$tv) {
52	52	for my $ks (sort keys %{$tv->{$n}}) {
53	53	my $N = $trans->{$n} \|\| die "FATAL: unknown name '$n'";
54		my $key = substr($seq, 0, $ks);
	54	my $key = substr($seq, 0, $ks);
55	55	for my $i (0..255) {
56	56	my $bytes = substr($seq, 0, $i);
57	57	next unless $tv->{$n}->{$ks}->{$i};
58	58	my $result = Crypt::Mac::PMAC->new($N, $key)->add($bytes)->mac;
59	59	is(unpack('H*', $result), lc($tv->{$n}->{$ks}->{$i}), "$N/$i");
60		$bytes = $result;
	60	$bytes = $result;
61	61	$key = substr($result x 100, 0, $ks);
62	62	}
63	63	}

+1

-1

t/mbi_ltm_01load.t less more

9	9	use_ok('Math::BigInt'); # Math::BigInt is required for the tests
10	10	};
11	11
12		diag "Math::BigInt VERSION=$Math::BigInt::VERSION\n";⏎
	12	diag "Math::BigInt VERSION=$Math::BigInt::VERSION\n";

+1

-1

t/mbi_ltm_bigfltpm.t less more

37	37	is(ref($e->{_e}->[0]), '', '$e->{_e}->[0] is a scalar');
38	38	}
39	39
40		require './t/mbi_ltm/bigfltpm.inc'; # all tests here for sharing
	40	require './t/mbi_ltm/bigfltpm.inc'; # all tests here for sharing

+9

-11

t/mbi_ltm_biglog.t less more

109	109	is ($cl->new('20')->blog(20,10), '1.000000000');
110	110	is ($cl->new('100')->blog(100,10), '1.000000000');
111	111
112		is ($cl->new('100')->blog(10,10), '2.000000000'); # 10 ** 2 == 100
113		is ($cl->new('400')->blog(20,10), '2.000000000'); # 20 ** 2 == 400
	112	is ($cl->new('100')->blog(10,10), '2.000000000'); # 10 ** 2 == 100
	113	is ($cl->new('400')->blog(20,10), '2.000000000'); # 20 ** 2 == 400
114	114
115		is ($cl->new('4')->blog(2,10), '2.000000000'); # 2 ** 2 == 4
116		is ($cl->new('16')->blog(2,10), '4.000000000'); # 2 ** 4 == 16
	115	is ($cl->new('4')->blog(2,10), '2.000000000'); # 2 ** 2 == 4
	116	is ($cl->new('16')->blog(2,10), '4.000000000'); # 2 ** 4 == 16
117	117
118	118	is ($cl->new('1.2')->bpow('0.3',10), '1.056219968');
119	119	is ($cl->new('10')->bpow('0.6',10), '3.981071706');

164	164	# test bexp() with cached results
165	165
166	166	is ($cl->new(1)->bexp(), '2.718281828459045235360287471352662497757', 'bexp(1)');
167		is ($cl->new(2)->bexp(40), $cl->new(1)->bexp(45)->bpow(2,40), 'bexp(2)');
	167	is ($cl->new(2)->bexp(40), $cl->new(1)->bexp(45)->bpow(2,40), 'bexp(2)');
168	168
169		is ($cl->new("12.5")->bexp(61), $cl->new(1)->bexp(65)->bpow(12.5,61), 'bexp(12.5)');
	169	is ($cl->new("12.5")->bexp(61), $cl->new(1)->bexp(65)->bpow(12.5,61), 'bexp(12.5)');
170	170
171	171	#############################################################################
172	172	# test bexp() with big values (non-cached)
173	173
174		is ($cl->new(1)->bexp(100),
	174	is ($cl->new(1)->bexp(100),
175	175	'2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427',
176	176	'bexp(100)');
177	177
178		is ($cl->new("12.5")->bexp(91), $cl->new(1)->bexp(95)->bpow(12.5,91),
179		'bexp(12.5) to 91 digits');
	178	is ($cl->new("12.5")->bexp(91), $cl->new(1)->bexp(95)->bpow(12.5,91),
	179	'bexp(12.5) to 91 digits');
180	180
181	181	# all done
182	182	1;

189	189	print "# Tried: $x->bpow($y,$scale);\n"
190	190	unless ok ($cl->new($x)->bpow($y,$scale),$result);
191	191	}
192
193

+1

-2

t/mbi_ltm_bigroot.t less more

23	23	my $cl = "Math::BigFloat";
24	24	my $c = "Math::BigInt";
25	25
26		# 2 ** 240 =
	26	# 2 ** 240 =
27	27	# 1766847064778384329583297500742918515827483896875618958121606201292619776
28	28
29	29	# takes way too long

46	46	$result =~ s/\..*//;
47	47	is ($c->new($x)->bpow($n)->broot($y,$scale),$result, "Try: $c $x->bpow($n)->broot($y,$s) == $result");
48	48	}
49

+7

-7

t/mode_cbc.t less more

5	5	my @tests;
6	6
7	7	# test vectors from http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
8		push @tests,
	8	push @tests,
9	9	{ padding=>'none', key=>'2b7e151628aed2a6abf7158809cf4f3c', iv=>'000102030405060708090a0b0c0d0e0f', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7' },
10	10	{ padding=>'none', key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', iv=>'000102030405060708090a0b0c0d0e0f', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd' },
11	11	{ padding=>'none', key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', iv=>'000102030405060708090a0b0c0d0e0f', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b' },
12		;
	12	;
13	13
14	14	# test vectors produced by Crypt::CBC
15		push @tests,
	15	push @tests,
16	16	{ mode=>'AES+Crypt::CBC', padding=>'standard', len=>45, key=>'4cdc909dc310796429e26bcaca1b21329f5060813b7d17bf1a65f293154b54a9', iv=>'9124d8cfafd3d732e597f463d35a8a43', pt=>'ad67301bcd23a5d7b4601f93db3e6b5db71243fa00244182d0a2df6f0384a09f117821b7b70a4bcdc0a73a70130851f704a7aca59b96a3e5b8dc89efa7ee7846a906a3eb591bf8b6b472ae07113ac3cccfb1bc84723ed1472c1f59705eae7b9fbd6df2b38d2eac2a6c726b9f92', ct=>'588c33d96d99477bc6305c829a1fb188ab165f60ccadac67daaefb8054cfe8093cbb6fba14b684c26cd10c66db87cf1aa8cd69c98180d1d7cb6edc9191332863653ea707cb9ec4da0c7d4381cac33faa938a53df3519d06859260be7ac582674cdedfa411f4cd0204c8b2132d4b100cc' },
17	17	{ mode=>'AES+Crypt::CBC', padding=>'standard', len=>46, key=>'0c1afd6567e265240aacef873eb78ff11ce0e53931ca7de49143d8a2b1c84df5', iv=>'df5f1521ed1ee7b47ae7e5ef0ac49abb', pt=>'13436402bb6c57b3f202e88cd4d21d828e85856415000e5ef01f9fe43bf100ee5b94ea29e3246200dcddbc5779dce5e219c078bbad8cd878727c0c27f179c100beefcc832f605c8e8f27251a8b51b2475d5170ff8100c95d4d875d386016535a13373f7e15d798e0c39c94193b24', ct=>'3eb5203a12d11b2fe629cd764a9963ad7f314d0efe75806c12e00f3bfe916c765a318be81337d1cb43f20c030f8af6e31991fb09477d06baa3492836f884470177584ad32241ac8fd66469fdd858ce1d04e90375689e70a4bc40be149b1df6cabc5943cff8e7cecdac6fe81fc0aac8f8' },
18	18	{ mode=>'AES+Crypt::CBC', padding=>'standard', len=>47, key=>'9dd6b591b1589ff6fb5bbd41a8da4b1449674155119285857d719d44281daa3d', iv=>'321d48c36326dcc951aa208542d2fdd7', pt=>'75e4309485e3df2006c411a316073973e8adf51bfd6287a7833f15e18f2f6b571c192a527bd6290722713eb77c9116a28b321cc5decd44a5a49a13750d43e99e4d360e647300cb7b9d31a82c39d8885e6d2b5521f1c7339b30d3947bddc7323a50891f4d37a7bc9cc6971037373722', ct=>'f1f7d95a90ece772a931e3c1f919da110246268291d10d5b2a3ff62596f0cd2a0c3dbdab41e210424f5a1d35b72a4df26a32d4c9ac80e808438f31e07a4f16555a82bade488a73afe239e6c557f100cf17632a8f767445ad6db8f7d2775f63f4b4e73fc5180b20334f941f8c49f7968a' },

67	67	my $m = Crypt::Mode::CBC->new('AES', $_->{padding});
68	68
69	69	for my $l (1..33) {
70
	70
71	71	{
72	72	$m->start_encrypt(pack("H",$_->{key}), pack("H",$_->{iv}));
73	73	my $i = 0;

79	79	$ct .= $m->finish;
80	80	is(unpack("H*",$ct), $_->{ct}, "cipher text match [l=$l]");
81	81	}
82
	82
83	83	{
84	84	$m->start_decrypt(pack("H",$_->{key}), pack("H",$_->{iv}));
85	85	my $i = 0;

91	91	$pt .= $m->finish;
92	92	is(unpack("H*",$pt), $_->{pt}, "plain text match [l=$l]");
93	93	}
94
95		}
	94
	95	}
96	96	}
97	97	}

+6

-6

t/mode_cfb.t less more

3	3	use Crypt::Mode::CFB;
4	4
5	5	my @tests = (
6		{ key=>'2b7e151628aed2a6abf7158809cf4f3c', iv=>'000102030405060708090a0b0c0d0e0f',
7		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710',
	6	{ key=>'2b7e151628aed2a6abf7158809cf4f3c', iv=>'000102030405060708090a0b0c0d0e0f',
	7	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710',
8	8	ct=>'3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6' },
9		{ key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', iv=>'000102030405060708090a0b0c0d0e0f',
10		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c',
	9	{ key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', iv=>'000102030405060708090a0b0c0d0e0f',
	10	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c',
11	11	ct=>'cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b' },
12		{ key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', iv=>'000102030405060708090a0b0c0d0e0f',
13		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417b',
	12	{ key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', iv=>'000102030405060708090a0b0c0d0e0f',
	13	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417b',
14	14	ct=>'dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d' },
15	15	);
16	16

+7

-7

t/mode_ecb.t less more

5	5	my @tests;
6	6
7	7	# test vectors from http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
8		push @tests,
	8	push @tests,
9	9	{ padding=>'none', key=>'2b7e151628aed2a6abf7158809cf4f3c', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4' },
10	10	{ padding=>'none', key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'bd334f1d6e45f25ff712a214571fa5cc974104846d0ad3ad7734ecb3ecee4eefef7afd2270e2e60adce0ba2face6444e9a4b41ba738d6c72fb16691603c18e0e' },
11	11	{ padding=>'none', key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710', ct=>'f3eed1bdb5d2a03c064b5a7e3db181f8591ccb10d410ed26dc5ba74a31362870b6ed21b99ca6f4f9f153e7b1beafed1d23304b7a39f9f3ff067d8d8f9e24ecc7' },
12		;
	12	;
13	13
14	14	# test vectors produced by Crypt::ECB
15		push @tests,
	15	push @tests,
16	16	{ mode=>'AES+Crypt::ECB', padding=>'standard', len=>45, key=>'9c1975bc3f89e58f790e8e1cdaeea5cc1147fa43c5da2f9ae681274bd406a663', pt=>'a99303fcd37a6c39acb2dd2f3955cbcdf2d4643cc5542019f549ca2b62a4b27a099f42e0a8fb90fc53f0f32c5402f89822215472d1a5c5e8e299090cfeb80151222922c91aa0a8e21ff07147ca62a4542cc36fb437ff2f56be51e6db4e763252960b4a02cfda2fb8a74a63c0fa', ct=>'b52d56dfbd230e87af5d6cd122b050ba4dacfa112e214359d04626efbf57ccde810246076261e0dd7be797bc9b07b20c3a737f72822498fecc68d73ff6c057a1313684058ff1110af0e59347953e1b337b6dbcb852f9210099ea4b54482ae4d9069193d5cb22c6cdfad968a27771b38b' },
17	17	{ mode=>'AES+Crypt::ECB', padding=>'standard', len=>46, key=>'11748a8de11e393c610eb582ee3534414f7187790435cdcbe1fd5f7c6db757be', pt=>'ff6da3d97b3907fcc171090bdcc97a43d98cde4bd76937eb672e3a4ce04b15de634d6c320bbe0b84304e52fbf004111f0d0671674196b3ea380f09295a04deb1f26b4d49bc239669bbed6b9316277516914ca4f30d570c156ea90f58565cbf26ead7c6d04eb411b83ef2445a914c', ct=>'91f00f683e3a381ebadb9553db928776fa972a06ca73a31e38ba6501d0f7b27c0013dcf3b25b3206ccd2083fcc815eaa3f843fa14ceca9e54a687b69d0e515dff1cf4b756744f242955b766c87473275ffa6c2191c89ad064c4b83e95ded84514613bc5d7763ffc0b0ec2281bf36d76c' },
18	18	{ mode=>'AES+Crypt::ECB', padding=>'standard', len=>47, key=>'d36ba22781e756dfe5e64bc9729e7d50bc00a24133ea90de1d77e666e9b39bb5', pt=>'a74a52d0a02d9e959127a1fa84790605828c6e1e8a9d71ff78320b1bc888affb3e19db2c5e62233ef6ab4adf89524efe369b12259925461b88d412d8276e5e80f327addee10c3e99778e0df730cf70509faef08e7c22b2142cc6201474465b47af54e99299290117eca9514a583ecf', ct=>'1e768190063599f2be4309a27c2d1b294714bb567f231ea9ad17fe31c183b3ab2d3db1b95a3e646aa88c35d98b3ce193640e2013e643b5da787087a2a115b1f61370e42943c90c384c64b128eeaa06c98b0c7b9e9a3c2b875100c5fb9703c5e94dc394c45ffc079d2ba75ad2b342100e' },

54	54	my $ct = pack("H*", $_->{ct});
55	55	my $m = Crypt::Mode::ECB->new('AES', $_->{padding});
56	56	for my $l (1..33) {
57
	57
58	58	{
59	59	$m->start_encrypt(pack("H*",$_->{key}));
60	60	my $i = 0;

66	66	$ct .= $m->finish;
67	67	is(unpack("H*",$ct), $_->{ct}, "cipher text match [l=$l]");
68	68	}
69
	69
70	70	{
71	71	$m->start_decrypt(pack("H*",$_->{key}));
72	72	my $i = 0;

78	78	$pt .= $m->finish;
79	79	is(unpack("H*",$pt), $_->{pt}, "plain text match [l=$l]");
80	80	}
81
82		}
	81
	82	}
83	83	}
84	84	}

+6

-6

t/mode_ofb.t less more

3	3	use Crypt::Mode::OFB;
4	4
5	5	my @tests = (
6		{ key=>'2b7e151628aed2a6abf7158809cf4f3c', iv=>'000102030405060708090a0b0c0d0e0f',
7		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710',
	6	{ key=>'2b7e151628aed2a6abf7158809cf4f3c', iv=>'000102030405060708090a0b0c0d0e0f',
	7	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710',
8	8	ct=>'3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e' },
9		{ key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', iv=>'000102030405060708090a0b0c0d0e0f',
10		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c',
	9	{ key=>'8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b', iv=>'000102030405060708090a0b0c0d0e0f',
	10	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c',
11	11	ct=>'cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9ac' },
12		{ key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', iv=>'000102030405060708090a0b0c0d0e0f',
13		pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417b',
	12	{ key=>'603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4', iv=>'000102030405060708090a0b0c0d0e0f',
	13	pt=>'6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417b',
14	14	ct=>'dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8b' },
15	15	);
16	16

+9

-9

t/pk_dh.t less more

12	12	ok($k->is_private, 'is_private cryptx_priv_dh1.bin');
13	13	is($k->size, 256, 'size');
14	14	is(uc($k->key2hash->{x}), '73CA6A11B1595C06AB08E8E0875B9689E265C29E3F52FBC7830F071AEA4AF5A26D23CFBC96101267', 'key2hash');
15
	15
16	16	$k = Crypt::PK::DH->new('t/data/cryptx_priv_dh2.bin');
17	17	ok($k, 'load cryptx_priv_dh2.bin');
18	18	ok($k->is_private, 'is_private cryptx_priv_dh2.bin');
19
	19
20	20	$k = Crypt::PK::DH->new('t/data/cryptx_pub_dh1.bin');
21	21	ok($k, 'load cryptx_pub_dh1.bin');
22	22	ok(!$k->is_private, 'is_private cryptx_pub_dh1.bin');
23
	23
24	24	$k = Crypt::PK::DH->new('t/data/cryptx_pub_dh2.bin');
25	25	ok($k, 'load cryptx_pub_dh2.bin');
26	26	ok(!$k->is_private, 'is_private cryptx_pub_dh2.bin');

34	34	ok($k->is_private, 'is_private cryptx_priv_dh_pg1.bin');
35	35	is($k->size, 256, 'size');
36	36	is(uc($k->key2hash->{x}), '3E2F764CDAD2EDFEC737E2198C9C4FAFBA4274C8A73A9E2FDCBC11954D8B48C375399E4BDE930EC9', 'key2hash');
37
	37
38	38	$k = Crypt::PK::DH->new('t/data/cryptx_priv_dh_pg2.bin');
39	39	ok($k, 'load cryptx_priv_dh_pg2.bin');
40	40	ok($k->is_private, 'is_private cryptx_priv_dh_pg2.bin');
41
	41
42	42	$k = Crypt::PK::DH->new('t/data/cryptx_pub_dh_pg1.bin');
43	43	ok($k, 'load cryptx_pub_dh_pg1.bin');
44	44	ok(!$k->is_private, 'is_private cryptx_pub_dh_pg1.bin');
45
	45
46	46	$k = Crypt::PK::DH->new('t/data/cryptx_pub_dh_pg2.bin');
47	47	ok($k, 'load cryptx_pub_dh_pg2.bin');
48	48	ok(!$k->is_private, 'is_private cryptx_pub_dh_pg2.bin');

58	58	$pr2->import_key('t/data/cryptx_priv_dh2.bin');
59	59	my $pu2 = Crypt::PK::DH->new;
60	60	$pu2->import_key('t/data/cryptx_pub_dh2.bin');
61
	61
62	62	my $ss1 = $pr1->shared_secret($pu2);
63	63	my $ss2 = $pr2->shared_secret($pu1);
64	64	is(unpack("H",$ss1), unpack("H",$ss2), 'shared_secret');

69	69	$pr1->import_key('t/data/cryptx_priv_dh_pg1.bin');
70	70	my $pu1 = Crypt::PK::DH->new;
71	71	$pu1->import_key('t/data/cryptx_pub_dh_pg1.bin');
72
	72
73	73	my $pr2 = Crypt::PK::DH->new;
74	74	$pr2->import_key('t/data/cryptx_priv_dh_pg2.bin');
75	75	my $pu2 = Crypt::PK::DH->new;
76	76	$pu2->import_key('t/data/cryptx_pub_dh_pg2.bin');
77
	77
78	78	my $ss1 = $pr1->shared_secret($pu2);
79	79	my $ss2 = $pr2->shared_secret($pu1);
80	80	is(unpack("H",$ss1), unpack("H",$ss2), 'shared_secret');

+14

-14

t/pk_dsa.t less more

16	16	$k = Crypt::PK::DSA->new('t/data/cryptx_priv_dsa2.der');
17	17	ok($k, 'load cryptx_priv_dsa2.der');
18	18	ok($k->is_private, 'is_private cryptx_priv_dsa2.der');
19
	19
20	20	$k = Crypt::PK::DSA->new('t/data/cryptx_pub_dsa1.der');
21	21	ok($k, 'load cryptx_pub_dsa1.der');
22	22	ok(!$k->is_private, 'is_private cryptx_pub_dsa1.der');
23
	23
24	24	$k = Crypt::PK::DSA->new('t/data/cryptx_pub_dsa2.der');
25	25	ok($k, 'load cryptx_pub_dsa2.der');
26	26	ok(!$k->is_private, 'is_private cryptx_pub_dsa2.der');
27
	27
28	28	$k = Crypt::PK::DSA->new('t/data/openssl_dsa1.der');
29	29	ok($k, 'load openssl_dsa1.der');
30	30	ok($k->is_private, 'is_private openssl_dsa1.der');
31
	31
32	32	$k = Crypt::PK::DSA->new('t/data/openssl_dsa2.der');
33	33	ok($k, 'load openssl_dsa2.der');
34	34	ok($k->is_private, 'is_private openssl_dsa2.der');
35
	35
36	36	$k = Crypt::PK::DSA->new('t/data/cryptx_priv_dsa1.pem');
37	37	ok($k, 'load cryptx_priv_dsa1.pem');
38	38	ok($k->is_private, 'is_private cryptx_priv_dsa1.pem');
39
	39
40	40	$k = Crypt::PK::DSA->new('t/data/cryptx_priv_dsa2.pem');
41	41	ok($k, 'load cryptx_priv_dsa2.pem');
42	42	ok($k->is_private, 'is_private cryptx_priv_dsa2.pem');
43
	43
44	44	$k = Crypt::PK::DSA->new('t/data/cryptx_pub_dsa1.pem');
45	45	ok($k, 'load cryptx_pub_dsa1.pem');
46	46	ok(!$k->is_private, 'is_private cryptx_pub_dsa1.pem');
47
	47
48	48	$k = Crypt::PK::DSA->new('t/data/cryptx_pub_dsa2.pem');
49	49	ok($k, 'load cryptx_pub_dsa2.pem');
50	50	ok(!$k->is_private, 'is_private cryptx_pub_dsa2.pem');
51
	51
52	52	$k = Crypt::PK::DSA->new('t/data/openssl_dsa1.pem');
53	53	ok($k, 'load openssl_dsa1.pem');
54	54	ok($k->is_private, 'is_private openssl_dsa1.pem');
55
	55
56	56	$k = Crypt::PK::DSA->new('t/data/openssl_dsa2.pem');
57	57	ok($k, 'load openssl_dsa2.pem');
58	58	ok($k->is_private, 'is_private openssl_dsa2.pem');

63	63	$pr1->import_key('t/data/cryptx_priv_dsa1.der');
64	64	my $pu1 = Crypt::PK::DSA->new;
65	65	$pu1->import_key('t/data/cryptx_pub_dsa1.der');
66
	66
67	67	my $ct = $pu1->encrypt("secret message");
68	68	my $pt = $pr1->decrypt($ct);
69	69	ok(length $ct > 200, 'encrypt ' . length($ct));

76	76	my $hash = pack("H*","04624fae618e9ad0c5e479f62e1420c71fff34dd");
77	77	$sig = $pr1->sign_hash($hash, 'SHA1');
78	78	ok(length $sig > 60, 'sign_hash ' . length($sig));
79		ok($pu1->verify_hash($sig, $hash, 'SHA1'), 'verify_hash');
80
	79	ok($pu1->verify_hash($sig, $hash, 'SHA1'), 'verify_hash');
	80
81	81	my $pr2 = Crypt::PK::DSA->new;
82	82	$pr2->import_key('t/data/cryptx_priv_dsa2.der');
83	83	my $pu2 = Crypt::PK::DSA->new;
84	84	$pu2->import_key('t/data/cryptx_pub_dsa2.der');
85
	85
86	86	#my $ss1 = $pr1->shared_secret($pu2);
87	87	#my $ss2 = $pr2->shared_secret($pu1);
88	88	#is(unpack("H",$ss1), unpack("H",$ss2), 'shared_secret');

+12

-12

t/pk_ecc.t less more

29	29	$k = Crypt::PK::ECC->new('t/data/cryptx_priv_ecc2.der');
30	30	ok($k, 'load cryptx_priv_ecc2.der');
31	31	ok($k->is_private, 'is_private cryptx_priv_ecc2.der');
32
	32
33	33	$k = Crypt::PK::ECC->new('t/data/cryptx_pub_ecc1.der');
34	34	ok($k, 'load cryptx_pub_ecc1.der');
35	35	ok(!$k->is_private, 'is_private cryptx_pub_ecc1.der');
36
	36
37	37	$k = Crypt::PK::ECC->new('t/data/cryptx_pub_ecc2.der');
38	38	ok($k, 'load cryptx_pub_ecc2.der');
39	39	ok(!$k->is_private, 'is_private cryptx_pub_ecc2.der');
40
	40
41	41	### XXX-TODO regenerate keys
42	42	$k = Crypt::PK::ECC->new('t/data/cryptx_priv_ecc1.pem');
43	43	ok($k, 'load cryptx_priv_ecc1.pem');
44	44	ok($k->is_private, 'is_private cryptx_priv_ecc1.pem');
45
	45
46	46	$k = Crypt::PK::ECC->new('t/data/cryptx_priv_ecc2.pem');
47	47	ok($k, 'load cryptx_priv_ecc2.pem');
48	48	ok($k->is_private, 'is_private cryptx_priv_ecc2.pem');
49
	49
50	50	$k = Crypt::PK::ECC->new('t/data/cryptx_pub_ecc1.pem');
51	51	ok($k, 'load cryptx_pub_ecc1.pem');
52	52	ok(!$k->is_private, 'is_private cryptx_pub_ecc1.pem');
53
	53
54	54	$k = Crypt::PK::ECC->new('t/data/cryptx_pub_ecc2.pem');
55	55	ok($k, 'load cryptx_pub_ecc2.pem');
56	56	ok(!$k->is_private, 'is_private cryptx_pub_ecc2.pem');

87	87	$pr1->import_key('t/data/cryptx_priv_ecc1.der');
88	88	my $pu1 = Crypt::PK::ECC->new;
89	89	$pu1->import_key('t/data/cryptx_pub_ecc1.der');
90
	90
91	91	my $ct = $pu1->encrypt("secret message");
92	92	my $pt = $pr1->decrypt($ct);
93	93	ok(length $ct > 30, 'encrypt ' . length($ct));
94	94	is($pt, "secret message", 'decrypt');
95
	95
96	96	my $sig = $pr1->sign_message("message");
97	97	ok(length $sig > 60, 'sign_message ' . length($sig));
98	98	ok($pu1->verify_message($sig, "message"), 'verify_message');

104	104	my $hash = pack("H*","04624fae618e9ad0c5e479f62e1420c71fff34dd");
105	105	$sig = $pr1->sign_hash($hash, 'SHA1');
106	106	ok(length $sig > 60, 'sign_hash ' . length($sig));
107		ok($pu1->verify_hash($sig, $hash, 'SHA1'), 'verify_hash');
108
	107	ok($pu1->verify_hash($sig, $hash, 'SHA1'), 'verify_hash');
	108
109	109	my $pr2 = Crypt::PK::ECC->new;
110	110	$pr2->import_key('t/data/cryptx_priv_ecc2.der');
111	111	my $pu2 = Crypt::PK::ECC->new;
112	112	$pu2->import_key('t/data/cryptx_pub_ecc2.der');
113
	113
114	114	my $ss1 = $pr1->shared_secret($pu2);
115	115	my $ss2 = $pr2->shared_secret($pu1);
116	116	is(unpack("H",$ss1), unpack("H",$ss2), 'shared_secret');

141	141	$sig = ecc_sign_hash('t/data/cryptx_priv_ecc1.der', $hash, 'SHA1');
142	142	ok($sig, 'ecc_sign_hash');
143	143	ok(ecc_verify_hash('t/data/cryptx_pub_ecc1.der', $sig, $hash, 'SHA1'), 'ecc_verify_hash');
144
	144
145	145	my $ss1 = ecc_shared_secret('t/data/cryptx_priv_ecc1.der', 't/data/cryptx_pub_ecc2.der');
146	146	my $ss2 = ecc_shared_secret('t/data/cryptx_priv_ecc2.der', 't/data/cryptx_pub_ecc1.der');
147	147	is(unpack("H",$ss1), unpack("H",$ss2), 'shared_secret');

+1

-1

t/pk_ecc_test_vectors_openssl.t less more

76	76	for my $h (@$data) {
77	77	my $ec_pri = Crypt::PK::ECC->new->import_key_raw(pack("H*",$h->{PRI}), $h->{CURVE});
78	78	my $ec_pub = Crypt::PK::ECC->new->import_key_raw(pack("H*",$h->{PUB}), $h->{CURVE});
79		my $ec_pubc = Crypt::PK::ECC->new->import_key_raw(pack("H*",$h->{PUBC}), $h->{CURVE});
	79	my $ec_pubc = Crypt::PK::ECC->new->import_key_raw(pack("H*",$h->{PUBC}), $h->{CURVE});
80	80	is( unpack("H*", $ec_pub ->export_key_raw('public_compressed')), $h->{PUBC}, "$h->{PRI_FILE}/ec_pub public compressed");
81	81	is( unpack("H*", $ec_pub ->export_key_raw('public')) , $h->{PUB}, "$h->{PRI_FILE}/ec_pub public uncompressed");
82	82	is( unpack("H*", $ec_pubc->export_key_raw('public_compressed')), $h->{PUBC}, "$h->{PRI_FILE}/ec_pubc public compressed");

+13

-13

t/pk_rsa.t less more

15	15	$k = Crypt::PK::RSA->new('t/data/cryptx_priv_rsa2.der');
16	16	ok($k, 'load cryptx_priv_rsa2.der');
17	17	ok($k->is_private, 'is_private cryptx_priv_rsa2.der');
18
	18
19	19	$k = Crypt::PK::RSA->new('t/data/cryptx_pub_rsa1.der');
20	20	ok($k, 'load cryptx_pub_rsa1.der');
21	21	ok(!$k->is_private, 'is_private cryptx_pub_rsa1.der');
22
	22
23	23	$k = Crypt::PK::RSA->new('t/data/cryptx_pub_rsa2.der');
24	24	ok($k, 'load cryptx_pub_rsa2.der');
25	25	ok(!$k->is_private, 'is_private cryptx_pub_rsa2.der');
26
	26
27	27	$k = Crypt::PK::RSA->new('t/data/openssl_rsa1.der');
28	28	ok($k, 'load openssl_rsa1.der');
29	29	ok($k->is_private, 'is_private openssl_rsa1.der');
30
	30
31	31	$k = Crypt::PK::RSA->new('t/data/openssl_rsa2.der');
32	32	ok($k, 'load openssl_rsa2.der');
33	33	ok($k->is_private, 'is_private openssl_rsa2.der');
34
	34
35	35	$k = Crypt::PK::RSA->new('t/data/cryptx_priv_rsa1.pem');
36	36	ok($k, 'load cryptx_priv_rsa1.pem');
37	37	ok($k->is_private, 'is_private cryptx_priv_rsa1.pem');
38
	38
39	39	$k = Crypt::PK::RSA->new('t/data/cryptx_priv_rsa2.pem');
40	40	ok($k, 'load cryptx_priv_rsa2.pem');
41	41	ok($k->is_private, 'is_private cryptx_priv_rsa2.pem');
42
	42
43	43	$k = Crypt::PK::RSA->new('t/data/cryptx_pub_rsa1.pem');
44	44	ok($k, 'load cryptx_pub_rsa1.pem');
45	45	ok(!$k->is_private, 'is_private cryptx_pub_rsa1.pem');
46
	46
47	47	$k = Crypt::PK::RSA->new('t/data/cryptx_pub_rsa2.pem');
48	48	ok($k, 'load cryptx_pub_rsa2.pem');
49	49	ok(!$k->is_private, 'is_private cryptx_pub_rsa2.pem');
50
	50
51	51	$k = Crypt::PK::RSA->new('t/data/openssl_rsa1.pem');
52	52	ok($k, 'load openssl_rsa1.pem');
53	53	ok($k->is_private, 'is_private openssl_rsa1.pem');
54
	54
55	55	$k = Crypt::PK::RSA->new('t/data/openssl_rsa2.pem');
56	56	ok($k, 'load openssl_rsa2.pem');
57	57	ok($k->is_private, 'is_private openssl_rsa2.pem');
58	58
59		# X509
	59	# X509
60	60	$k = Crypt::PK::RSA->new('t/data/openssl_rsa-x509.pem');
61	61	ok($k, 'openssl_rsa-x509.pem');
62	62	ok(!$k->is_private, 'not private openssl_rsa-x509.pem');

70	70	$pr1->import_key('t/data/cryptx_priv_rsa1.der');
71	71	my $pu1 = Crypt::PK::RSA->new;
72	72	$pu1->import_key('t/data/cryptx_pub_rsa1.der');
73
	73
74	74	my $ct = $pu1->encrypt("secret message");
75	75	my $pt = $pr1->decrypt($ct);
76	76	ok(length $ct > 200, 'encrypt ' . length($ct));
77	77	is($pt, "secret message", 'decrypt');
78
	78
79	79	my $sig = $pr1->sign_message("message");
80	80	ok(length $sig > 60, 'sign_message ' . length($sig));
81	81	ok($pu1->verify_message($sig, "message"), 'verify_message');

+7

-7

t/prng.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");

+7

-7

t/prng_chacha20.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");

+7

-7

t/prng_fortuna.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");

+7

-7

t/prng_rc4.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");

+7

-7

t/prng_sober128.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");

+7

-7

t/prng_yarrow.t less more

10	10	my $sum = 0;
11	11	$sum += $r->double for (1..1000);
12	12	my $avg = $sum/1000;
13		ok($avg>0.4 && $avg<0.6, "rand $avg");
	13	ok($avg>0.4 && $avg<0.6, "rand $avg");
14	14	}
15	15
16	16	{
17	17	my $sum = 0;
18	18	$sum += $r->double(-180) for (1..1000);
19	19	my $avg = $sum/1000;
20		ok($avg>-100 && $avg<-80, "rand $avg");
	20	ok($avg>-100 && $avg<-80, "rand $avg");
21	21	}
22	22
23	23	{
24	24	my $sum = 0;
25	25	$sum += $r->int32 for (1..1000);
26	26	my $avg = $sum/1000;
27		ok($avg>230 && $avg<232, "rand $avg");
	27	ok($avg>230 && $avg<232, "rand $avg");
28	28	}
29	29
30	30	{
31	31	my $sum = 0;
32	32	$sum += rand(80) for (1..1000);
33	33	my $avg = $sum/1000;
34		ok($avg>30 && $avg<50, "rand $avg");
	34	ok($avg>30 && $avg<50, "rand $avg");
35	35	}
36	36
37	37	{
38	38	my $sum = 0;
39	39	$sum += rand(-180) for (1..1000);
40	40	my $avg = $sum/1000;
41		ok($avg>-100 && $avg<-80, "rand $avg");
	41	ok($avg>-100 && $avg<-80, "rand $avg");
42	42	}
43	43
44	44	{
45	45	my $sum = 0;
46	46	$sum += irand for (1..1000);
47	47	my $avg = $sum/1000;
48		ok($avg>230 && $avg<232, "rand $avg");
	48	ok($avg>230 && $avg<232, "rand $avg");
49	49	}
50	50
51	51	{

55	55	like($r->bytes_hex(55), qr/^[0-9A-Fa-f]{110}$/, "bytes_hex");
56	56	like($r->bytes_b64(60), qr/^[A-Za-z0-9+\/=]{80}$/, "bytes_b64");
57	57	like($r->bytes_b64u(60), qr/^[A-Za-z0-9_-]{80}$/, "bytes_b64u");
58
	58
59	59	like(random_string(45), qr/^[A-Z-a-z0-9]+$/, 'string');
60	60	like(random_string_from("ABC,.-", 45), qr/^[ABC,\,\.\-]+$/, 'string');
61	61	is(length random_bytes(55), 55, "bytes");