TclTLS
Check-in [37325867e6]
Login
HomeTimelineDownloadBrowse SourceBranchesTagsTicketsWiki
Overview
Comment:Added IDEA cipher test vectors
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | crypto
Files: files | file ages | folders
SHA3-256: 37325867e682a3caafb29ac72ee2a61235870f0583fa4b546fc38a2e65c8a94a
User & Date: bohagan on 2024-04-08 02:51:53
Other Links: branch diff | manifest | tags
Context
2024-04-08
03:30
Make test case files from test vectors script updates to optimize logic check-in: 45c6b53f90 user: bohagan tags: crypto
02:51
Added IDEA cipher test vectors check-in: 37325867e6 user: bohagan tags: crypto
2024-04-07
22:20
Added Seed cipher test vectors check-in: 18bed2dd62 user: bohagan tags: crypto
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified tests/test_vectors/Symetric_Block/AES-128-CBC.test from [65c5b321f9] to [e19d54dff8]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-CBC.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_CBC [expr {[lsearch -nocase [tls::ciphers] AES-128-CBC] > -1}]

tcltest::test Block_AES-128-CBC-1.1 {Encrypt AES-128-CBC} \
tcltest::test Symetric_Block_AES-128-CBC-1.1 {Encrypt AES-128-CBC} \
	-constraints AES_128_CBC \
	-body {binary encode hex [tls::encrypt -cipher AES-128-CBC -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7

tcltest::test Block_AES-128-CBC-1.2 {Decrypt AES-128-CBC} \
tcltest::test Symetric_Block_AES-128-CBC-1.2 {Decrypt AES-128-CBC} \
	-constraints AES_128_CBC \
	-body {binary encode hex [tls::decrypt -cipher AES-128-CBC -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-128-CFB.test from [7d24d887c8] to [23592c06a9]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-CFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_CFB [expr {[lsearch -nocase [tls::ciphers] AES-128-CFB] > -1}]

tcltest::test Block_AES-128-CFB-1.1 {Encrypt AES-128-CFB} \
tcltest::test Symetric_Block_AES-128-CFB-1.1 {Encrypt AES-128-CFB} \
	-constraints AES_128_CFB \
	-body {binary encode hex [tls::encrypt -cipher AES-128-CFB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6

tcltest::test Block_AES-128-CFB-1.2 {Decrypt AES-128-CFB} \
tcltest::test Symetric_Block_AES-128-CFB-1.2 {Decrypt AES-128-CFB} \
	-constraints AES_128_CFB \
	-body {binary encode hex [tls::decrypt -cipher AES-128-CFB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-128-CFB1.test from [3bd696dc72] to [e9429b9d23]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-CFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_CFB1 [expr {[lsearch -nocase [tls::ciphers] AES-128-CFB1] > -1}]

tcltest::test Block_AES-128-CFB1-1.1 {Encrypt AES-128-CFB1} \
tcltest::test Symetric_Block_AES-128-CFB1-1.1 {Encrypt AES-128-CFB1} \
	-constraints AES_128_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher AES-128-CFB1 -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1]]} \
	-match exact -result 68b3

tcltest::test Block_AES-128-CFB1-1.2 {Decrypt AES-128-CFB1} \
tcltest::test Symetric_Block_AES-128-CFB1-1.2 {Decrypt AES-128-CFB1} \
	-constraints AES_128_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher AES-128-CFB1 -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 68b3]]} \
	-match exact -result 6bc1
︙

Modified tests/test_vectors/Symetric_Block/AES-128-CFB8.test from [6dc07bce40] to [707d078c22]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-CFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_CFB8 [expr {[lsearch -nocase [tls::ciphers] AES-128-CFB8] > -1}]

tcltest::test Block_AES-128-CFB8-1.1 {Encrypt AES-128-CFB8} \
tcltest::test Symetric_Block_AES-128-CFB8-1.1 {Encrypt AES-128-CFB8} \
	-constraints AES_128_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher AES-128-CFB8 -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d]]} \
	-match exact -result 3b79424c9c0dd436bace9e0ed4586a4f32b9

tcltest::test Block_AES-128-CFB8-1.2 {Decrypt AES-128-CFB8} \
tcltest::test Symetric_Block_AES-128-CFB8-1.2 {Decrypt AES-128-CFB8} \
	-constraints AES_128_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher AES-128-CFB8 -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 3b79424c9c0dd436bace9e0ed4586a4f32b9]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d
︙

Modified tests/test_vectors/Symetric_Block/AES-128-CTR.test from [edb0e884ff] to [8eee83348b]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-CTR.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_CTR [expr {[lsearch -nocase [tls::ciphers] AES-128-CTR] > -1}]

tcltest::test Block_AES-128-CTR-1.1 {Encrypt AES-128-CTR} \
tcltest::test Symetric_Block_AES-128-CTR-1.1 {Encrypt AES-128-CTR} \
	-constraints AES_128_CTR \
	-body {binary encode hex [tls::encrypt -cipher AES-128-CTR -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee

tcltest::test Block_AES-128-CTR-1.2 {Decrypt AES-128-CTR} \
tcltest::test Symetric_Block_AES-128-CTR-1.2 {Decrypt AES-128-CTR} \
	-constraints AES_128_CTR \
	-body {binary encode hex [tls::decrypt -cipher AES-128-CTR -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-128-ECB.test from [d0e873f017] to [d6a54b5c73]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22
23









-
+






-
+








# Auto generated from "AES-128-ECB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_ECB [expr {[lsearch -nocase [tls::ciphers] AES-128-ECB] > -1}]

tcltest::test Block_AES-128-ECB-1.1 {Encrypt AES-128-ECB} \
tcltest::test Symetric_Block_AES-128-ECB-1.1 {Encrypt AES-128-ECB} \
	-constraints AES_128_ECB \
	-body {binary encode hex [tls::encrypt -cipher AES-128-ECB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4

tcltest::test Block_AES-128-ECB-1.2 {Decrypt AES-128-ECB} \
tcltest::test Symetric_Block_AES-128-ECB-1.2 {Decrypt AES-128-ECB} \
	-constraints AES_128_ECB \
	-body {binary encode hex [tls::decrypt -cipher AES-128-ECB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -data [binary decode hex 3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/AES-128-OFB.test from [eac590d856] to [f6e77133c7]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-128-OFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_128_OFB [expr {[lsearch -nocase [tls::ciphers] AES-128-OFB] > -1}]

tcltest::test Block_AES-128-OFB-1.1 {Encrypt AES-128-OFB} \
tcltest::test Symetric_Block_AES-128-OFB-1.1 {Encrypt AES-128-OFB} \
	-constraints AES_128_OFB \
	-body {binary encode hex [tls::encrypt -cipher AES-128-OFB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e

tcltest::test Block_AES-128-OFB-1.2 {Decrypt AES-128-OFB} \
tcltest::test Symetric_Block_AES-128-OFB-1.2 {Decrypt AES-128-OFB} \
	-constraints AES_128_OFB \
	-body {binary encode hex [tls::decrypt -cipher AES-128-OFB -padding 0 \
		 -key [binary decode hex 2b7e151628aed2a6abf7158809cf4f3c] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-192-CBC.test from [64074eee9c] to [f854923791]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-CBC.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_CBC [expr {[lsearch -nocase [tls::ciphers] AES-192-CBC] > -1}]

tcltest::test Block_AES-192-CBC-1.1 {Encrypt AES-192-CBC} \
tcltest::test Symetric_Block_AES-192-CBC-1.1 {Encrypt AES-192-CBC} \
	-constraints AES_192_CBC \
	-body {binary encode hex [tls::encrypt -cipher AES-192-CBC -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd

tcltest::test Block_AES-192-CBC-1.2 {Decrypt AES-192-CBC} \
tcltest::test Symetric_Block_AES-192-CBC-1.2 {Decrypt AES-192-CBC} \
	-constraints AES_192_CBC \
	-body {binary encode hex [tls::decrypt -cipher AES-192-CBC -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-192-CFB.test from [01e591ca3c] to [33ebf8d108]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-CFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_CFB [expr {[lsearch -nocase [tls::ciphers] AES-192-CFB] > -1}]

tcltest::test Block_AES-192-CFB-1.1 {Encrypt AES-192-CFB} \
tcltest::test Symetric_Block_AES-192-CFB-1.1 {Encrypt AES-192-CFB} \
	-constraints AES_192_CFB \
	-body {binary encode hex [tls::encrypt -cipher AES-192-CFB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b09ff

tcltest::test Block_AES-192-CFB-1.2 {Decrypt AES-192-CFB} \
tcltest::test Symetric_Block_AES-192-CFB-1.2 {Decrypt AES-192-CFB} \
	-constraints AES_192_CFB \
	-body {binary encode hex [tls::decrypt -cipher AES-192-CFB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b09ff]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-192-CFB1.test from [932dbfda2a] to [f67be2762a]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-CFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_CFB1 [expr {[lsearch -nocase [tls::ciphers] AES-192-CFB1] > -1}]

tcltest::test Block_AES-192-CFB1-1.1 {Encrypt AES-192-CFB1} \
tcltest::test Symetric_Block_AES-192-CFB1-1.1 {Encrypt AES-192-CFB1} \
	-constraints AES_192_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher AES-192-CFB1 -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1]]} \
	-match exact -result 9359

tcltest::test Block_AES-192-CFB1-1.2 {Decrypt AES-192-CFB1} \
tcltest::test Symetric_Block_AES-192-CFB1-1.2 {Decrypt AES-192-CFB1} \
	-constraints AES_192_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher AES-192-CFB1 -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 9359]]} \
	-match exact -result 6bc1
︙

Modified tests/test_vectors/Symetric_Block/AES-192-CFB8.test from [738f1cb327] to [1becc429a9]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-CFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_CFB8 [expr {[lsearch -nocase [tls::ciphers] AES-192-CFB8] > -1}]

tcltest::test Block_AES-192-CFB8-1.1 {Encrypt AES-192-CFB8} \
tcltest::test Symetric_Block_AES-192-CFB8-1.1 {Encrypt AES-192-CFB8} \
	-constraints AES_192_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher AES-192-CFB8 -padding 0 \
		 -key [binary decode hex 8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d]]} \
	-match exact -result cda2521ef0a905ca44cd057cbf0d47a0678a

tcltest::test Block_AES-192-CFB8-1.2 {Decrypt AES-192-CFB8} \
tcltest::test Symetric_Block_AES-192-CFB8-1.2 {Decrypt AES-192-CFB8} \
	-constraints AES_192_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher AES-192-CFB8 -padding 0 \
		 -key [binary decode hex 8E73B0F7DA0E6452C810F32B809079E562F8EAD2522C6B7B] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex cda2521ef0a905ca44cd057cbf0d47a0678a]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d
︙

Modified tests/test_vectors/Symetric_Block/AES-192-CTR.test from [e9bd75d05d] to [fcd1a806ee]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-CTR.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_CTR [expr {[lsearch -nocase [tls::ciphers] AES-192-CTR] > -1}]

tcltest::test Block_AES-192-CTR-1.1 {Encrypt AES-192-CTR} \
tcltest::test Symetric_Block_AES-192-CTR-1.1 {Encrypt AES-192-CTR} \
	-constraints AES_192_CTR \
	-body {binary encode hex [tls::encrypt -cipher AES-192-CTR -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 1abc932417521ca24f2b0459fe7e6e0b090339ec0aa6faefd5ccc2c6f4ce8e941e36b26bd1ebc670d1bd1d665620abf74f78a7f6d29809585a97daec58c6b050

tcltest::test Block_AES-192-CTR-1.2 {Decrypt AES-192-CTR} \
tcltest::test Symetric_Block_AES-192-CTR-1.2 {Decrypt AES-192-CTR} \
	-constraints AES_192_CTR \
	-body {binary encode hex [tls::decrypt -cipher AES-192-CTR -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 1abc932417521ca24f2b0459fe7e6e0b090339ec0aa6faefd5ccc2c6f4ce8e941e36b26bd1ebc670d1bd1d665620abf74f78a7f6d29809585a97daec58c6b050]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-192-ECB.test from [86743a06c2] to [48b9e7cd3a]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22
23









-
+






-
+








# Auto generated from "AES-192-ECB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_ECB [expr {[lsearch -nocase [tls::ciphers] AES-192-ECB] > -1}]

tcltest::test Block_AES-192-ECB-1.1 {Encrypt AES-192-ECB} \
tcltest::test Symetric_Block_AES-192-ECB-1.1 {Encrypt AES-192-ECB} \
	-constraints AES_192_ECB \
	-body {binary encode hex [tls::encrypt -cipher AES-192-ECB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result bd334f1d6e45f25ff712a214571fa5cc974104846d0ad3ad7734ecb3ecee4eefef7afd2270e2e60adce0ba2face6444e9a4b41ba738d6c72fb16691603c18e0e

tcltest::test Block_AES-192-ECB-1.2 {Decrypt AES-192-ECB} \
tcltest::test Symetric_Block_AES-192-ECB-1.2 {Decrypt AES-192-ECB} \
	-constraints AES_192_ECB \
	-body {binary encode hex [tls::decrypt -cipher AES-192-ECB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -data [binary decode hex bd334f1d6e45f25ff712a214571fa5cc974104846d0ad3ad7734ecb3ecee4eefef7afd2270e2e60adce0ba2face6444e9a4b41ba738d6c72fb16691603c18e0e]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/AES-192-OFB.test from [f40553a7c5] to [4c63bc3822]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-192-OFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_192_OFB [expr {[lsearch -nocase [tls::ciphers] AES-192-OFB] > -1}]

tcltest::test Block_AES-192-OFB-1.1 {Encrypt AES-192-OFB} \
tcltest::test Symetric_Block_AES-192-OFB-1.1 {Encrypt AES-192-OFB} \
	-constraints AES_192_OFB \
	-body {binary encode hex [tls::encrypt -cipher AES-192-OFB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a

tcltest::test Block_AES-192-OFB-1.2 {Decrypt AES-192-OFB} \
tcltest::test Symetric_Block_AES-192-OFB-1.2 {Decrypt AES-192-OFB} \
	-constraints AES_192_OFB \
	-body {binary encode hex [tls::decrypt -cipher AES-192-OFB -padding 0 \
		 -key [binary decode hex 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-256-CBC.test from [57c7756a8b] to [7375992b8b]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-CBC.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_CBC [expr {[lsearch -nocase [tls::ciphers] AES-256-CBC] > -1}]

tcltest::test Block_AES-256-CBC-1.1 {Encrypt AES-256-CBC} \
tcltest::test Symetric_Block_AES-256-CBC-1.1 {Encrypt AES-256-CBC} \
	-constraints AES_256_CBC \
	-body {binary encode hex [tls::encrypt -cipher AES-256-CBC -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b

tcltest::test Block_AES-256-CBC-1.2 {Decrypt AES-256-CBC} \
tcltest::test Symetric_Block_AES-256-CBC-1.2 {Decrypt AES-256-CBC} \
	-constraints AES_256_CBC \
	-body {binary encode hex [tls::decrypt -cipher AES-256-CBC -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-256-CFB.test from [6ec5673682] to [aa30e2ea13]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-CFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_CFB [expr {[lsearch -nocase [tls::ciphers] AES-256-CFB] > -1}]

tcltest::test Block_AES-256-CFB-1.1 {Encrypt AES-256-CFB} \
tcltest::test Symetric_Block_AES-256-CFB-1.1 {Encrypt AES-256-CFB} \
	-constraints AES_256_CFB \
	-body {binary encode hex [tls::encrypt -cipher AES-256-CFB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d55b1e471

tcltest::test Block_AES-256-CFB-1.2 {Decrypt AES-256-CFB} \
tcltest::test Symetric_Block_AES-256-CFB-1.2 {Decrypt AES-256-CFB} \
	-constraints AES_256_CFB \
	-body {binary encode hex [tls::decrypt -cipher AES-256-CFB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d55b1e471]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-256-CFB1.test from [8cc2def4a3] to [35b47bc17f]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-CFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_CFB1 [expr {[lsearch -nocase [tls::ciphers] AES-256-CFB1] > -1}]

tcltest::test Block_AES-256-CFB1-1.1 {Encrypt AES-256-CFB1} \
tcltest::test Symetric_Block_AES-256-CFB1-1.1 {Encrypt AES-256-CFB1} \
	-constraints AES_256_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher AES-256-CFB1 -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1]]} \
	-match exact -result 9029

tcltest::test Block_AES-256-CFB1-1.2 {Decrypt AES-256-CFB1} \
tcltest::test Symetric_Block_AES-256-CFB1-1.2 {Decrypt AES-256-CFB1} \
	-constraints AES_256_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher AES-256-CFB1 -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 9029]]} \
	-match exact -result 6bc1
︙

Modified tests/test_vectors/Symetric_Block/AES-256-CFB8.test from [8f01a4d3af] to [5930e625c8]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-CFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_CFB8 [expr {[lsearch -nocase [tls::ciphers] AES-256-CFB8] > -1}]

tcltest::test Block_AES-256-CFB8-1.1 {Encrypt AES-256-CFB8} \
tcltest::test Symetric_Block_AES-256-CFB8-1.1 {Encrypt AES-256-CFB8} \
	-constraints AES_256_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher AES-256-CFB8 -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d]]} \
	-match exact -result dc1f1a8520a64db55fcc8ac554844e889700

tcltest::test Block_AES-256-CFB8-1.2 {Decrypt AES-256-CFB8} \
tcltest::test Symetric_Block_AES-256-CFB8-1.2 {Decrypt AES-256-CFB8} \
	-constraints AES_256_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher AES-256-CFB8 -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex dc1f1a8520a64db55fcc8ac554844e889700]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d
︙

Modified tests/test_vectors/Symetric_Block/AES-256-CTR.test from [3bfdcb10cf] to [ee2ba131f2]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-CTR.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_CTR [expr {[lsearch -nocase [tls::ciphers] AES-256-CTR] > -1}]

tcltest::test Block_AES-256-CTR-1.1 {Encrypt AES-256-CTR} \
tcltest::test Symetric_Block_AES-256-CTR-1.1 {Encrypt AES-256-CTR} \
	-constraints AES_256_CTR \
	-body {binary encode hex [tls::encrypt -cipher AES-256-CTR -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result 601ec313775789a5b7a7f504bbf3d228f443e3ca4d62b59aca84e990cacaf5c52b0930daa23de94ce87017ba2d84988ddfc9c58db67aada613c2dd08457941a6

tcltest::test Block_AES-256-CTR-1.2 {Decrypt AES-256-CTR} \
tcltest::test Symetric_Block_AES-256-CTR-1.2 {Decrypt AES-256-CTR} \
	-constraints AES_256_CTR \
	-body {binary encode hex [tls::decrypt -cipher AES-256-CTR -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff] \
		 -data [binary decode hex 601ec313775789a5b7a7f504bbf3d228f443e3ca4d62b59aca84e990cacaf5c52b0930daa23de94ce87017ba2d84988ddfc9c58db67aada613c2dd08457941a6]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/AES-256-ECB.test from [c37f09ae87] to [b03bb45b92]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22
23









-
+






-
+








# Auto generated from "AES-256-ECB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_ECB [expr {[lsearch -nocase [tls::ciphers] AES-256-ECB] > -1}]

tcltest::test Block_AES-256-ECB-1.1 {Encrypt AES-256-ECB} \
tcltest::test Symetric_Block_AES-256-ECB-1.1 {Encrypt AES-256-ECB} \
	-constraints AES_256_ECB \
	-body {binary encode hex [tls::encrypt -cipher AES-256-ECB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result f3eed1bdb5d2a03c064b5a7e3db181f8591ccb10d410ed26dc5ba74a31362870b6ed21b99ca6f4f9f153e7b1beafed1d23304b7a39f9f3ff067d8d8f9e24ecc7

tcltest::test Block_AES-256-ECB-1.2 {Decrypt AES-256-ECB} \
tcltest::test Symetric_Block_AES-256-ECB-1.2 {Decrypt AES-256-ECB} \
	-constraints AES_256_ECB \
	-body {binary encode hex [tls::decrypt -cipher AES-256-ECB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -data [binary decode hex f3eed1bdb5d2a03c064b5a7e3db181f8591ccb10d410ed26dc5ba74a31362870b6ed21b99ca6f4f9f153e7b1beafed1d23304b7a39f9f3ff067d8d8f9e24ecc7]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/AES-256-OFB.test from [4f13e8c331] to [4e8362c0e2]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "AES-256-OFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint AES_256_OFB [expr {[lsearch -nocase [tls::ciphers] AES-256-OFB] > -1}]

tcltest::test Block_AES-256-OFB-1.1 {Encrypt AES-256-OFB} \
tcltest::test Symetric_Block_AES-256-OFB-1.1 {Encrypt AES-256-OFB} \
	-constraints AES_256_OFB \
	-body {binary encode hex [tls::encrypt -cipher AES-256-OFB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710]]} \
	-match exact -result dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484

tcltest::test Block_AES-256-OFB-1.2 {Decrypt AES-256-OFB} \
tcltest::test Symetric_Block_AES-256-OFB-1.2 {Decrypt AES-256-OFB} \
	-constraints AES_256_OFB \
	-body {binary encode hex [tls::decrypt -cipher AES-256-OFB -padding 0 \
		 -key [binary decode hex 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4] \
		 -iv [binary decode hex 000102030405060708090a0b0c0d0e0f] \
		 -data [binary decode hex dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710
︙

Modified tests/test_vectors/Symetric_Block/DES-CBC.test from [cb0cbf5ffa] to [93694fffed]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-CBC.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_CBC [expr {[lsearch -nocase [tls::ciphers] DES-CBC] > -1}]

tcltest::test Block_DES-CBC-1.1 {Encrypt DES-CBC} \
tcltest::test Symetric_Block_DES-CBC-1.1 {Encrypt DES-CBC} \
	-constraints DES_CBC \
	-body {binary encode hex [tls::encrypt -cipher DES-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f77206973207468652074696d6520666f7220616c6c20]]} \
	-match exact -result e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6

tcltest::test Block_DES-CBC-1.2 {Decrypt DES-CBC} \
tcltest::test Symetric_Block_DES-CBC-1.2 {Decrypt DES-CBC} \
	-constraints DES_CBC \
	-body {binary encode hex [tls::decrypt -cipher DES-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6]]} \
	-match exact -result 4e6f77206973207468652074696d6520666f7220616c6c20
︙

Modified tests/test_vectors/Symetric_Block/DES-CFB.test from [b436b3e392] to [d83e4dff8a]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-CFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_CFB [expr {[lsearch -nocase [tls::ciphers] DES-CFB] > -1}]

tcltest::test Block_DES-CFB-1.1 {Encrypt DES-CFB} \
tcltest::test Symetric_Block_DES-CFB-1.1 {Encrypt DES-CFB} \
	-constraints DES_CFB \
	-body {binary encode hex [tls::encrypt -cipher DES-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f77206973207468652074696d6520666f7220616c6c20]]} \
	-match exact -result f3096249c7f46e51a69e839b1a92f78403467133898ea622

tcltest::test Block_DES-CFB-1.2 {Decrypt DES-CFB} \
tcltest::test Symetric_Block_DES-CFB-1.2 {Decrypt DES-CFB} \
	-constraints DES_CFB \
	-body {binary encode hex [tls::decrypt -cipher DES-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex f3096249c7f46e51a69e839b1a92f78403467133898ea622]]} \
	-match exact -result 4e6f77206973207468652074696d6520666f7220616c6c20
︙

Modified tests/test_vectors/Symetric_Block/DES-CFB1.test from [4043cb42be] to [f743cbdc5c]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-CFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_CFB1 [expr {[lsearch -nocase [tls::ciphers] DES-CFB1] > -1}]

tcltest::test Block_DES-CFB1-1.1 {Encrypt DES-CFB1} \
tcltest::test Symetric_Block_DES-CFB1-1.1 {Encrypt DES-CFB1} \
	-constraints DES_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher DES-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f77]]} \
	-match exact -result cd1ec9

tcltest::test Block_DES-CFB1-1.2 {Decrypt DES-CFB1} \
tcltest::test Symetric_Block_DES-CFB1-1.2 {Decrypt DES-CFB1} \
	-constraints DES_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher DES-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex cd1ec9]]} \
	-match exact -result 4e6f77
︙

Modified tests/test_vectors/Symetric_Block/DES-CFB8.test from [49f880056a] to [c0534f2c09]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-CFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_CFB8 [expr {[lsearch -nocase [tls::ciphers] DES-CFB8] > -1}]

tcltest::test Block_DES-CFB8-1.1 {Encrypt DES-CFB8} \
tcltest::test Symetric_Block_DES-CFB8-1.1 {Encrypt DES-CFB8} \
	-constraints DES_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher DES-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f7720697320746865]]} \
	-match exact -result f31fda07011462ee187f

tcltest::test Block_DES-CFB8-1.2 {Decrypt DES-CFB8} \
tcltest::test Symetric_Block_DES-CFB8-1.2 {Decrypt DES-CFB8} \
	-constraints DES_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher DES-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex f31fda07011462ee187f]]} \
	-match exact -result 4e6f7720697320746865
︙

Modified tests/test_vectors/Symetric_Block/DES-ECB.test from [77cff59e3a] to [2538a9cfa3]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

24
25
26
27
28
29
30

31
32
33
34
35
36
37

38
39
40
41
42
43
44

45
46
47
48
49
50
51

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22

23
24
25
26
27
28
29

30
31
32
33
34
35
36

37
38
39
40
41
42
43

44
45
46
47
48
49
50
51









-
+






-
+






-
+






-
+






-
+






-
+








# Auto generated from "DES-ECB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_ECB [expr {[lsearch -nocase [tls::ciphers] DES-ECB] > -1}]

tcltest::test Block_DES-ECB-1.1 {Encrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.1 {Encrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::encrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 4e6f772069732074]]} \
	-match exact -result 3fa40e8a984d4815

tcltest::test Block_DES-ECB-1.2 {Decrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.2 {Decrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::decrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 3fa40e8a984d4815]]} \
	-match exact -result 4e6f772069732074

tcltest::test Block_DES-ECB-1.3 {Encrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.3 {Encrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::encrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 68652074696d6520]]} \
	-match exact -result 6a271787ab8883f9

tcltest::test Block_DES-ECB-1.4 {Decrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.4 {Decrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::decrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 6a271787ab8883f9]]} \
	-match exact -result 68652074696d6520

tcltest::test Block_DES-ECB-1.5 {Encrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.5 {Encrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::encrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 666f7220616c6c20]]} \
	-match exact -result 893d51ec4b563b53

tcltest::test Block_DES-ECB-1.6 {Decrypt DES-ECB} \
tcltest::test Symetric_Block_DES-ECB-1.6 {Decrypt DES-ECB} \
	-constraints DES_ECB \
	-body {binary encode hex [tls::decrypt -cipher DES-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -data [binary decode hex 893d51ec4b563b53]]} \
	-match exact -result 666f7220616c6c20

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-CBC.test from [edde17b69d] to [9129d4640f]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-CBC.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_CBC [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-CBC] > -1}]

tcltest::test Block_DES-EDE3-CBC-1.1 {Encrypt DES-EDE3-CBC} \
tcltest::test Symetric_Block_DES-EDE3-CBC-1.1 {Encrypt DES-EDE3-CBC} \
	-constraints DES_EDE3_CBC \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 2079c3d53aa763e193b79e2569ab5262516570481f25b50f73c0bda85c8e0da7

tcltest::test Block_DES-EDE3-CBC-1.2 {Decrypt DES-EDE3-CBC} \
tcltest::test Symetric_Block_DES-EDE3-CBC-1.2 {Decrypt DES-EDE3-CBC} \
	-constraints DES_EDE3_CBC \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 2079c3d53aa763e193b79e2569ab5262516570481f25b50f73c0bda85c8e0da7]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-CBC-1.3 {Encrypt DES-EDE3-CBC} \
tcltest::test Symetric_Block_DES-EDE3-CBC-1.3 {Encrypt DES-EDE3-CBC} \
	-constraints DES_EDE3_CBC \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 7401ce1eab6d003caff84bf47b36cc2154f0238f9ffecd8f6acf118392b45581

tcltest::test Block_DES-EDE3-CBC-1.4 {Decrypt DES-EDE3-CBC} \
tcltest::test Symetric_Block_DES-EDE3-CBC-1.4 {Decrypt DES-EDE3-CBC} \
	-constraints DES_EDE3_CBC \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CBC -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 7401ce1eab6d003caff84bf47b36cc2154f0238f9ffecd8f6acf118392b45581]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-CFB.test from [eb649b4076] to [8e2ca440af]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-CFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_CFB [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-CFB] > -1}]

tcltest::test Block_DES-EDE3-CFB-1.1 {Encrypt DES-EDE3-CFB} \
tcltest::test Symetric_Block_DES-EDE3-CFB-1.1 {Encrypt DES-EDE3-CFB} \
	-constraints DES_EDE3_CFB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 078bb74e59ce7ed67666de9cf95eaf3fe9ed6bb460f451528a5f9fe4ed710918

tcltest::test Block_DES-EDE3-CFB-1.2 {Decrypt DES-EDE3-CFB} \
tcltest::test Symetric_Block_DES-EDE3-CFB-1.2 {Decrypt DES-EDE3-CFB} \
	-constraints DES_EDE3_CFB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 078bb74e59ce7ed67666de9cf95eaf3fe9ed6bb460f451528a5f9fe4ed710918]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-CFB-1.3 {Encrypt DES-EDE3-CFB} \
tcltest::test Symetric_Block_DES-EDE3-CFB-1.3 {Encrypt DES-EDE3-CFB} \
	-constraints DES_EDE3_CFB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 6195b9c2c39909c52ef313667b5a66af688672a3993aeae55b931ae24ee24c5c

tcltest::test Block_DES-EDE3-CFB-1.4 {Decrypt DES-EDE3-CFB} \
tcltest::test Symetric_Block_DES-EDE3-CFB-1.4 {Decrypt DES-EDE3-CFB} \
	-constraints DES_EDE3_CFB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6195b9c2c39909c52ef313667b5a66af688672a3993aeae55b931ae24ee24c5c]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-CFB1.test from [43efa43d2e] to [6cf512668c]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-CFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_CFB1 [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-CFB1] > -1}]

tcltest::test Block_DES-EDE3-CFB1-1.1 {Encrypt DES-EDE3-CFB1} \
tcltest::test Symetric_Block_DES-EDE3-CFB1-1.1 {Encrypt DES-EDE3-CFB1} \
	-constraints DES_EDE3_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6b]]} \
	-match exact -result 5c

tcltest::test Block_DES-EDE3-CFB1-1.2 {Decrypt DES-EDE3-CFB1} \
tcltest::test Symetric_Block_DES-EDE3-CFB1-1.2 {Decrypt DES-EDE3-CFB1} \
	-constraints DES_EDE3_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 5c]]} \
	-match exact -result 6b

tcltest::test Block_DES-EDE3-CFB1-1.3 {Encrypt DES-EDE3-CFB1} \
tcltest::test Symetric_Block_DES-EDE3-CFB1-1.3 {Encrypt DES-EDE3-CFB1} \
	-constraints DES_EDE3_CFB1 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6b]]} \
	-match exact -result 66

tcltest::test Block_DES-EDE3-CFB1-1.4 {Decrypt DES-EDE3-CFB1} \
tcltest::test Symetric_Block_DES-EDE3-CFB1-1.4 {Decrypt DES-EDE3-CFB1} \
	-constraints DES_EDE3_CFB1 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 66]]} \
	-match exact -result 6b
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-CFB8.test from [32ed496a8a] to [812022114e]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-CFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_CFB8 [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-CFB8] > -1}]

tcltest::test Block_DES-EDE3-CFB8-1.1 {Encrypt DES-EDE3-CFB8} \
tcltest::test Symetric_Block_DES-EDE3-CFB8-1.1 {Encrypt DES-EDE3-CFB8} \
	-constraints DES_EDE3_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96]]} \
	-match exact -result 07951b729dc23ab4

tcltest::test Block_DES-EDE3-CFB8-1.2 {Decrypt DES-EDE3-CFB8} \
tcltest::test Symetric_Block_DES-EDE3-CFB8-1.2 {Decrypt DES-EDE3-CFB8} \
	-constraints DES_EDE3_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 07951b729dc23ab4]]} \
	-match exact -result 6bc1bee22e409f96

tcltest::test Block_DES-EDE3-CFB8-1.3 {Encrypt DES-EDE3-CFB8} \
tcltest::test Symetric_Block_DES-EDE3-CFB8-1.3 {Encrypt DES-EDE3-CFB8} \
	-constraints DES_EDE3_CFB8 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96]]} \
	-match exact -result 61d86d9aee9693fd

tcltest::test Block_DES-EDE3-CFB8-1.4 {Decrypt DES-EDE3-CFB8} \
tcltest::test Symetric_Block_DES-EDE3-CFB8-1.4 {Decrypt DES-EDE3-CFB8} \
	-constraints DES_EDE3_CFB8 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 61d86d9aee9693fd]]} \
	-match exact -result 6bc1bee22e409f96
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-CTR.test from [409677134b] to [476de6ec60]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-CTR.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_CTR [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-CTR] > -1}]

tcltest::test Block_DES-EDE3-CTR-1.1 {Encrypt DES-EDE3-CTR} \
tcltest::test Symetric_Block_DES-EDE3-CTR-1.1 {Encrypt DES-EDE3-CTR} \
	-constraints DES_EDE3_CTR \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CTR -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 078bb74e59ce7ed619aa11d25004fb65a03cedf1ba0b09baa3bc81b8f69c1da9

tcltest::test Block_DES-EDE3-CTR-1.2 {Decrypt DES-EDE3-CTR} \
tcltest::test Symetric_Block_DES-EDE3-CTR-1.2 {Decrypt DES-EDE3-CTR} \
	-constraints DES_EDE3_CTR \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CTR -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 078bb74e59ce7ed619aa11d25004fb65a03cedf1ba0b09baa3bc81b8f69c1da9]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-CTR-1.3 {Encrypt DES-EDE3-CTR} \
tcltest::test Symetric_Block_DES-EDE3-CTR-1.3 {Encrypt DES-EDE3-CTR} \
	-constraints DES_EDE3_CTR \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-CTR -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 6195b9c2c39909c5dbdf92dadbad5a5d1568482bf25c42c96d3853a8e71b010e

tcltest::test Block_DES-EDE3-CTR-1.4 {Decrypt DES-EDE3-CTR} \
tcltest::test Symetric_Block_DES-EDE3-CTR-1.4 {Decrypt DES-EDE3-CTR} \
	-constraints DES_EDE3_CTR \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-CTR -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6195b9c2c39909c5dbdf92dadbad5a5d1568482bf25c42c96d3853a8e71b010e]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-ECB.test from [b3b08b4691] to [1fedef3a3b]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

24
25
26
27
28
29
30

31
32
33
34
35
36
37

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22

23
24
25
26
27
28
29

30
31
32
33
34
35
36
37









-
+






-
+






-
+






-
+








# Auto generated from "DES-EDE3-ECB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_ECB [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-ECB] > -1}]

tcltest::test Block_DES-EDE3-ECB-1.1 {Encrypt DES-EDE3-ECB} \
tcltest::test Symetric_Block_DES-EDE3-ECB-1.1 {Encrypt DES-EDE3-ECB} \
	-constraints DES_EDE3_ECB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 714772f339841d34267fcc4bd2949cc3ee11c22a576a303876183f99c0b6de87

tcltest::test Block_DES-EDE3-ECB-1.2 {Decrypt DES-EDE3-ECB} \
tcltest::test Symetric_Block_DES-EDE3-ECB-1.2 {Decrypt DES-EDE3-ECB} \
	-constraints DES_EDE3_ECB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -data [binary decode hex 714772f339841d34267fcc4bd2949cc3ee11c22a576a303876183f99c0b6de87]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-ECB-1.3 {Encrypt DES-EDE3-ECB} \
tcltest::test Symetric_Block_DES-EDE3-ECB-1.3 {Encrypt DES-EDE3-ECB} \
	-constraints DES_EDE3_ECB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 06ede3d82884090aff322c19f0518486730576972a666e58b6c88cf107340d3d

tcltest::test Block_DES-EDE3-ECB-1.4 {Decrypt DES-EDE3-ECB} \
tcltest::test Symetric_Block_DES-EDE3-ECB-1.4 {Decrypt DES-EDE3-ECB} \
	-constraints DES_EDE3_ECB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-ECB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -data [binary decode hex 06ede3d82884090aff322c19f0518486730576972a666e58b6c88cf107340d3d]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3-OFB.test from [f575679096] to [cbde3c164f]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES-EDE3-OFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3_OFB [expr {[lsearch -nocase [tls::ciphers] DES-EDE3-OFB] > -1}]

tcltest::test Block_DES-EDE3-OFB-1.1 {Encrypt DES-EDE3-OFB} \
tcltest::test Symetric_Block_DES-EDE3-OFB-1.1 {Encrypt DES-EDE3-OFB} \
	-constraints DES_EDE3_OFB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 078bb74e59ce7ed6267e120692667da1a58662d7e04cbc642144d55c03db5aee

tcltest::test Block_DES-EDE3-OFB-1.2 {Decrypt DES-EDE3-OFB} \
tcltest::test Symetric_Block_DES-EDE3-OFB-1.2 {Decrypt DES-EDE3-OFB} \
	-constraints DES_EDE3_OFB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 078bb74e59ce7ed6267e120692667da1a58662d7e04cbc642144d55c03db5aee]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-OFB-1.3 {Encrypt DES-EDE3-OFB} \
tcltest::test Symetric_Block_DES-EDE3-OFB-1.3 {Encrypt DES-EDE3-OFB} \
	-constraints DES_EDE3_OFB \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 6195b9c2c39909c53334ba77ffdccc80e485e85f0a63e7646d8d732e33241f94

tcltest::test Block_DES-EDE3-OFB-1.4 {Decrypt DES-EDE3-OFB} \
tcltest::test Symetric_Block_DES-EDE3-OFB-1.4 {Decrypt DES-EDE3-OFB} \
	-constraints DES_EDE3_OFB \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6195b9c2c39909c53334ba77ffdccc80e485e85f0a63e7646d8d732e33241f94]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51
︙

Modified tests/test_vectors/Symetric_Block/DES-EDE3.test from [f8976db99b] to [e4ecada073]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

24
25
26
27
28
29
30

31
32
33
34
35
36
37

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15

16
17
18
19
20
21
22

23
24
25
26
27
28
29

30
31
32
33
34
35
36
37









-
+






-
+






-
+






-
+








# Auto generated from "DES-EDE3.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_EDE3 [expr {[lsearch -nocase [tls::ciphers] DES-EDE3] > -1}]

tcltest::test Block_DES-EDE3-1.1 {Encrypt DES-EDE3} \
tcltest::test Symetric_Block_DES-EDE3-1.1 {Encrypt DES-EDE3} \
	-constraints DES_EDE3 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 714772f339841d34267fcc4bd2949cc3ee11c22a576a303876183f99c0b6de87

tcltest::test Block_DES-EDE3-1.2 {Decrypt DES-EDE3} \
tcltest::test Symetric_Block_DES-EDE3-1.2 {Decrypt DES-EDE3} \
	-constraints DES_EDE3 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -data [binary decode hex 714772f339841d34267fcc4bd2949cc3ee11c22a576a303876183f99c0b6de87]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES-EDE3-1.3 {Encrypt DES-EDE3} \
tcltest::test Symetric_Block_DES-EDE3-1.3 {Encrypt DES-EDE3} \
	-constraints DES_EDE3 \
	-body {binary encode hex [tls::encrypt -cipher DES-EDE3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 06ede3d82884090aff322c19f0518486730576972a666e58b6c88cf107340d3d

tcltest::test Block_DES-EDE3-1.4 {Decrypt DES-EDE3} \
tcltest::test Symetric_Block_DES-EDE3-1.4 {Decrypt DES-EDE3} \
	-constraints DES_EDE3 \
	-body {binary encode hex [tls::decrypt -cipher DES-EDE3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -data [binary decode hex 06ede3d82884090aff322c19f0518486730576972a666e58b6c88cf107340d3d]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

# Cleanup
︙

Modified tests/test_vectors/Symetric_Block/DES-OFB.test from [d362dffe40] to [97734d59d5]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-OFB.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_OFB [expr {[lsearch -nocase [tls::ciphers] DES-OFB] > -1}]

tcltest::test Block_DES-OFB-1.1 {Encrypt DES-OFB} \
tcltest::test Symetric_Block_DES-OFB-1.1 {Encrypt DES-OFB} \
	-constraints DES_OFB \
	-body {binary encode hex [tls::encrypt -cipher DES-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 5765207468652070656f706c65206f662074686520556e69746564205374617465732c20696e206f7264657220746f20]]} \
	-match exact -result ea03351dc6e26e5538f81a3c22a637797b7641a66463fa8a0c9d1ead3ed113d70608a565602f23c421c8836e82c5f07b

tcltest::test Block_DES-OFB-1.2 {Decrypt DES-OFB} \
tcltest::test Symetric_Block_DES-OFB-1.2 {Decrypt DES-OFB} \
	-constraints DES_OFB \
	-body {binary encode hex [tls::decrypt -cipher DES-OFB -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex ea03351dc6e26e5538f81a3c22a637797b7641a66463fa8a0c9d1ead3ed113d70608a565602f23c421c8836e82c5f07b]]} \
	-match exact -result 5765207468652070656f706c65206f662074686520556e69746564205374617465732c20696e206f7264657220746f20
︙

Modified tests/test_vectors/Symetric_Block/DES-OFB1.test from [ccefc093e4] to [8dd18633d7]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-OFB1.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_OFB1 [expr {[lsearch -nocase [tls::ciphers] DES-OFB1] > -1}]

tcltest::test Block_DES-OFB1-1.1 {Encrypt DES-OFB1} \
tcltest::test Symetric_Block_DES-OFB1-1.1 {Encrypt DES-OFB1} \
	-constraints DES_OFB1 \
	-body {binary encode hex [tls::encrypt -cipher DES-OFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f77]]} \
	-match exact -result e3d34b

tcltest::test Block_DES-OFB1-1.2 {Decrypt DES-OFB1} \
tcltest::test Symetric_Block_DES-OFB1-1.2 {Decrypt DES-OFB1} \
	-constraints DES_OFB1 \
	-body {binary encode hex [tls::decrypt -cipher DES-OFB1 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex e3d34b]]} \
	-match exact -result 4e6f77
︙

Modified tests/test_vectors/Symetric_Block/DES-OFB8.test from [764174ce91] to [13ab825abf]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24









-
+







-
+








# Auto generated from "DES-OFB8.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES_OFB8 [expr {[lsearch -nocase [tls::ciphers] DES-OFB8] > -1}]

tcltest::test Block_DES-OFB8-1.1 {Encrypt DES-OFB8} \
tcltest::test Symetric_Block_DES-OFB8-1.1 {Encrypt DES-OFB8} \
	-constraints DES_OFB8 \
	-body {binary encode hex [tls::encrypt -cipher DES-OFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex 4e6f7720697320746865]]} \
	-match exact -result f34a2850c9c64985d684

tcltest::test Block_DES-OFB8-1.2 {Decrypt DES-OFB8} \
tcltest::test Symetric_Block_DES-OFB8-1.2 {Decrypt DES-OFB8} \
	-constraints DES_OFB8 \
	-body {binary encode hex [tls::decrypt -cipher DES-OFB8 -padding 0 \
		 -key [binary decode hex 0123456789abcdef] \
		 -iv [binary decode hex 1234567890abcdef] \
		 -data [binary decode hex f34a2850c9c64985d684]]} \
	-match exact -result 4e6f7720697320746865
︙

Modified tests/test_vectors/Symetric_Block/DES.test from [862208e857] to [45a26280f7]. 

1
2
3
4
5
6
7
8
9

10
11
12
13


14
15
16

17
18
19
20


21
22
23

24
25
26
27


28
29
30

31
32
33
34


35
36
37

38
39
40
41


42
43
44

45
46
47
48


49
50
51

52
53
54
55


56
57
58

59
60
61
62


63
64
65

66
67
68
69


70
71
72

73
74
75
76


77
78
79

80
81
82
83


84
85
86

87
88
89
90


91
92
93

94
95
96
97


98
99
100

101
102
103
104


105
106
107

108
109
110
111


112
113
114

115
116
117
118


119
120
121

122
123
124
125


126
127
128

129
130
131
132


133
134
135

136
137
138
139


140
141
142

143
144
145
146


147
148
149

150
151
152
153


154
155
156

157
158
159
160


161
162
163

164
165
166
167


168
169
170

171
172
173
174


175
176
177

178
179
180
181


182
183
184

185
186
187
188


189
190
191

192
193
194
195


196
197
198

199
200
201
202


203
204
205

206
207
208
209


210
211
212

213
214
215
216


217
218
219

220
221
222
223


224
225
226

227
228
229
230


231
232
233

234
235
236
237


238
239
240

241
242
243
244


245
246
247

248
249
250
251


252
253
254

255
256
257
258


259
260
261

262
263
264
265


266
267
268

269
270
271
272


273
274
275

276
277
278
279


280
281
282

283
284
285
286


287
288
289

290
291
292
293


294
295
296

297
298
299
300


301
302
303

304
305
306
307


308
309
310

311
312
313
314


315
316
317

318
319
320
321


322
323
324

325
326
327
328


329
330
331

332
333
334
335


336
337
338

339
340
341
342


343
344
345

346
347
348
349


350
351
352

353
354
355
356


357
358
359

360
361
362
363


364
365
366

367
368
369
370


371
372
373

374
375
376
377


378
379
380

381
382
383
384


385
386
387

388
389
390
391


392
393
394

395
396
397
398


399
400
401

402
403
404
405


406
407
408

409
410
411
412


413
414
415

416
417
418
419


420
421
422

423
424
425
426


427
428
429

430
431
432
433


434
435
436

437
438
439
440


441
442
443

444
445
446
447


448
449
450

451
452
453
454


455
456
457

458
459
460
461


462
463
464

465
466
467
468


469
470
471

472
473
474
475


476
477
478

479
480
481
482


483
484
485

486
487
488
489


490
491
492

493
494
495
496


497
498
499

500
501
502
503


504
505
506

507
508
509
510


511
512
513

514
515
516
517


518
519
520

521
522
523
524


525
526
527

528
529
530
531


532
533
534

535
536
537
538


539
540
541

542
543
544
545


546
547
548

549
550
551
552


553
554
555

556
557
558
559


560
561
562

563
564
565
566


567
568
569

570
571
572
573


574
575
576

577
578
579
580


581
582
583

584
585
586
587


588
589
590

591
592
593
594


595
596
597

598
599
600
601


602
603
604

605
606
607
608


609
610
611

612
613
614
615


616
617
618

619
620
621
622


623
624
625

626
627
628
629


630
631
632

633
634
635
636


637
638
639

640
641
642
643


644
645
646

647
648
649
650


651
652
653

654
655
656
657


658
659
660

661
662
663
664


665
666
667

668
669
670
671


672
673
674

675
676
677
678


679
680
681

682
683
684
685


686
687
688

689
690
691
692


693
694
695

696
697
698
699


700
701
702

703
704
705
706


707
708
709

710
711
712
713


714
715
716

717
718
719
720


721
722
723

724
725
726
727


728
729
730

731
732
733
734


735
736
737

738
739
740
741


742
743
744

745
746
747
748


749
750
751

752
753
754
755


756
757
758

759
760
761
762


763
764
765

766
767
768
769


770
771
772

773
774
775
776


777
778
779

780
781
782
783


784
785
786

787
788
789
790


791
792
793

794
795
796
797


798
799
800

801
802
803
804


805
806
807

808
809
810
811


812
813
814

815
816
817
818


819
820
821

822
823
824
825


826
827
828

829
830
831
832


833
834
835

836
837
838
839


840
841
842

843
844
845
846


847
848
849

850
851
852
853


854
855
856

857
858
859
860


861
862
863

864
865
866
867


868
869
870

871
872
873
874


875
876
877

878
879
880
881


882
883
884

885
886
887
888


889
890
891

892
893
894
895


896
897
898

899
900
901
902


903
904
905

906
907
908
909


910
911
912

913
914
915
916


917
918
919

920
921
922
923


924
925
926

927
928
929
930


931
932
933

934
935
936
937


938
939
940

941
942
943
944


945
946
947

948
949
950
951


952
953
954

955
956
957
958


959
960
961

962
963
964
965


966
967
968

969
970
971
972


973
974
975

976
977
978
979


980
981
982

983
984
985
986


987
988
989

990
991
992
993


994
995
996

997
998
999
1000


1001
1002
1003

1004
1005
1006
1007


1008
1009
1010

1011
1012
1013
1014


1015
1016
1017

1018
1019
1020
1021


1022
1023
1024

1025
1026
1027
1028


1029
1030
1031

1032
1033
1034
1035


1036
1037
1038

1039
1040
1041
1042


1043
1044
1045

1046
1047
1048
1049


1050
1051
1052

1053
1054
1055
1056


1057
1058
1059

1060
1061
1062
1063


1064
1065
1066

1067
1068
1069
1070


1071
1072
1073

1074
1075
1076
1077


1078
1079
1080

1081
1082
1083
1084


1085
1086
1087

1088
1089
1090
1091


1092
1093
1094

1095
1096
1097
1098


1099
1100
1101

1102
1103
1104
1105


1106
1107
1108

1109
1110
1111
1112


1113
1114
1115

1116
1117
1118
1119


1120
1121
1122

1123
1124
1125
1126


1127
1128
1129

1130
1131
1132
1133


1134
1135
1136

1137
1138
1139
1140


1141
1142
1143

1144
1145
1146
1147


1148
1149
1150

1151
1152
1153
1154


1155
1156
1157

1158
1159
1160
1161


1162
1163
1164

1165
1166
1167
1168


1169
1170
1171

1172
1173
1174
1175


1176
1177
1178

1179
1180
1181
1182


1183
1184
1185

1186
1187
1188
1189


1190
1191
1192

1193
1194
1195
1196


1197
1198
1199

1200
1201
1202
1203


1204
1205
1206

1207
1208
1209
1210


1211
1212
1213
1214
1215

1
2
3
4
5
6
7
8

9
10
11


12
13
14
15

16
17
18


19
20
21
22

23
24
25


26
27
28
29

30
31
32


33
34
35
36

37
38
39


40
41
42
43

44
45
46


47
48
49
50

51
52
53


54
55
56
57

58
59
60


61
62
63
64

65
66
67


68
69
70
71

72
73
74


75
76
77
78

79
80
81


82
83
84
85

86
87
88


89
90
91
92

93
94
95


96
97
98
99

100
101
102


103
104
105
106

107
108
109


110
111
112
113

114
115
116


117
118
119
120

121
122
123


124
125
126
127

128
129
130


131
132
133
134

135
136
137


138
139
140
141

142
143
144


145
146
147
148

149
150
151


152
153
154
155

156
157
158


159
160
161
162

163
164
165


166
167
168
169

170
171
172


173
174
175
176

177
178
179


180
181
182
183

184
185
186


187
188
189
190

191
192
193


194
195
196
197

198
199
200


201
202
203
204

205
206
207


208
209
210
211

212
213
214


215
216
217
218

219
220
221


222
223
224
225

226
227
228


229
230
231
232

233
234
235


236
237
238
239

240
241
242


243
244
245
246

247
248
249


250
251
252
253

254
255
256


257
258
259
260

261
262
263


264
265
266
267

268
269
270


271
272
273
274

275
276
277


278
279
280
281

282
283
284


285
286
287
288

289
290
291


292
293
294
295

296
297
298


299
300
301
302

303
304
305


306
307
308
309

310
311
312


313
314
315
316

317
318
319


320
321
322
323

324
325
326


327
328
329
330

331
332
333


334
335
336
337

338
339
340


341
342
343
344

345
346
347


348
349
350
351

352
353
354


355
356
357
358

359
360
361


362
363
364
365

366
367
368


369
370
371
372

373
374
375


376
377
378
379

380
381
382


383
384
385
386

387
388
389


390
391
392
393

394
395
396


397
398
399
400

401
402
403


404
405
406
407

408
409
410


411
412
413
414

415
416
417


418
419
420
421

422
423
424


425
426
427
428

429
430
431


432
433
434
435

436
437
438


439
440
441
442

443
444
445


446
447
448
449

450
451
452


453
454
455
456

457
458
459


460
461
462
463

464
465
466


467
468
469
470

471
472
473


474
475
476
477

478
479
480


481
482
483
484

485
486
487


488
489
490
491

492
493
494


495
496
497
498

499
500
501


502
503
504
505

506
507
508


509
510
511
512

513
514
515


516
517
518
519

520
521
522


523
524
525
526

527
528
529


530
531
532
533

534
535
536


537
538
539
540

541
542
543


544
545
546
547

548
549
550


551
552
553
554

555
556
557


558
559
560
561

562
563
564


565
566
567
568

569
570
571


572
573
574
575

576
577
578


579
580
581
582

583
584
585


586
587
588
589

590
591
592


593
594
595
596

597
598
599


600
601
602
603

604
605
606


607
608
609
610

611
612
613


614
615
616
617

618
619
620


621
622
623
624

625
626
627


628
629
630
631

632
633
634


635
636
637
638

639
640
641


642
643
644
645

646
647
648


649
650
651
652

653
654
655


656
657
658
659

660
661
662


663
664
665
666

667
668
669


670
671
672
673

674
675
676


677
678
679
680

681
682
683


684
685
686
687

688
689
690


691
692
693
694

695
696
697


698
699
700
701

702
703
704


705
706
707
708

709
710
711


712
713
714
715

716
717
718


719
720
721
722

723
724
725


726
727
728
729

730
731
732


733
734
735
736

737
738
739


740
741
742
743

744
745
746


747
748
749
750

751
752
753


754
755
756
757

758
759
760


761
762
763
764

765
766
767


768
769
770
771

772
773
774


775
776
777
778

779
780
781


782
783
784
785

786
787
788


789
790
791
792

793
794
795


796
797
798
799

800
801
802


803
804
805
806

807
808
809


810
811
812
813

814
815
816


817
818
819
820

821
822
823


824
825
826
827

828
829
830


831
832
833
834

835
836
837


838
839
840
841

842
843
844


845
846
847
848

849
850
851


852
853
854
855

856
857
858


859
860
861
862

863
864
865


866
867
868
869

870
871
872


873
874
875
876

877
878
879


880
881
882
883

884
885
886


887
888
889
890

891
892
893


894
895
896
897

898
899
900


901
902
903
904

905
906
907


908
909
910
911

912
913
914


915
916
917
918

919
920
921


922
923
924
925

926
927
928


929
930
931
932

933
934
935


936
937
938
939

940
941
942


943
944
945
946

947
948
949


950
951
952
953

954
955
956


957
958
959
960

961
962
963


964
965
966
967

968
969
970


971
972
973
974

975
976
977


978
979
980
981

982
983
984


985
986
987
988

989
990
991


992
993
994
995

996
997
998


999
1000
1001
1002

1003
1004
1005


1006
1007
1008
1009

1010
1011
1012


1013
1014
1015
1016

1017
1018
1019


1020
1021
1022
1023

1024
1025
1026


1027
1028
1029
1030

1031
1032
1033


1034
1035
1036
1037

1038
1039
1040


1041
1042
1043
1044

1045
1046
1047


1048
1049
1050
1051

1052
1053
1054


1055
1056
1057
1058

1059
1060
1061


1062
1063
1064
1065

1066
1067
1068


1069
1070
1071
1072

1073
1074
1075


1076
1077
1078
1079

1080
1081
1082


1083
1084
1085
1086

1087
1088
1089


1090
1091
1092
1093

1094
1095
1096


1097
1098
1099
1100

1101
1102
1103


1104
1105
1106
1107

1108
1109
1110


1111
1112
1113
1114

1115
1116
1117


1118
1119
1120
1121

1122
1123
1124


1125
1126
1127
1128

1129
1130
1131


1132
1133
1134
1135

1136
1137
1138


1139
1140
1141
1142

1143
1144
1145


1146
1147
1148
1149

1150
1151
1152


1153
1154
1155
1156

1157
1158
1159


1160
1161
1162
1163

1164
1165
1166


1167
1168
1169
1170

1171
1172
1173


1174
1175
1176
1177

1178
1179
1180


1181
1182
1183
1184

1185
1186
1187


1188
1189
1190
1191

1192
1193
1194


1195
1196
1197
1198

1199
1200
1201


1202
1203
1204
1205

1206
1207
1208


1209
1210
1211
1212
1213
1214
1215









-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+


-
+


-
-
+
+






# Auto generated from "DES.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES [expr {[lsearch -nocase [tls::ciphers] DES] > -1}]

tcltest::test Block_DES-1.1 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.1 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 10316E028C8F3B4A] \
		-data [binary decode hex 0000000000000000]]} \
		 -key [binary decode hex 10316E028C8F3B4A] \
		 -data [binary decode hex 0000000000000000]]} \
	-match exact -result 82dcbafbdeab6602

tcltest::test Block_DES-1.2 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.2 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 10316E028C8F3B4A] \
		-data [binary decode hex 82DCBAFBDEAB6602]]} \
		 -key [binary decode hex 10316E028C8F3B4A] \
		 -data [binary decode hex 82DCBAFBDEAB6602]]} \
	-match exact -result 0000000000000000

tcltest::test Block_DES-1.3 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.3 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 95F8A5E5DD31D900]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 95F8A5E5DD31D900]]} \
	-match exact -result 8000000000000000

tcltest::test Block_DES-1.4 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.4 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 8000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 8000000000000000]]} \
	-match exact -result 95f8a5e5dd31d900

tcltest::test Block_DES-1.5 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.5 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex DD7F121CA5015619]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex DD7F121CA5015619]]} \
	-match exact -result 4000000000000000

tcltest::test Block_DES-1.6 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.6 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 4000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 4000000000000000]]} \
	-match exact -result dd7f121ca5015619

tcltest::test Block_DES-1.7 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.7 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 2E8653104F3834EA]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 2E8653104F3834EA]]} \
	-match exact -result 2000000000000000

tcltest::test Block_DES-1.8 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.8 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 2000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 2000000000000000]]} \
	-match exact -result 2e8653104f3834ea

tcltest::test Block_DES-1.9 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.9 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 4BD388FF6CD81D4F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 4BD388FF6CD81D4F]]} \
	-match exact -result 1000000000000000

tcltest::test Block_DES-1.10 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.10 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 1000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 1000000000000000]]} \
	-match exact -result 4bd388ff6cd81d4f

tcltest::test Block_DES-1.11 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.11 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 20B9E767B2FB1456]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 20B9E767B2FB1456]]} \
	-match exact -result 0800000000000000

tcltest::test Block_DES-1.12 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.12 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0800000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0800000000000000]]} \
	-match exact -result 20b9e767b2fb1456

tcltest::test Block_DES-1.13 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.13 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 55579380D77138EF]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 55579380D77138EF]]} \
	-match exact -result 0400000000000000

tcltest::test Block_DES-1.14 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.14 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0400000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0400000000000000]]} \
	-match exact -result 55579380d77138ef

tcltest::test Block_DES-1.15 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.15 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 6CC5DEFAAF04512F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 6CC5DEFAAF04512F]]} \
	-match exact -result 0200000000000000

tcltest::test Block_DES-1.16 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.16 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0200000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0200000000000000]]} \
	-match exact -result 6cc5defaaf04512f

tcltest::test Block_DES-1.17 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.17 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0D9F279BA5D87260]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0D9F279BA5D87260]]} \
	-match exact -result 0100000000000000

tcltest::test Block_DES-1.18 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.18 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0100000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0100000000000000]]} \
	-match exact -result 0d9f279ba5d87260

tcltest::test Block_DES-1.19 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.19 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex D9031B0271BD5A0A]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex D9031B0271BD5A0A]]} \
	-match exact -result 0080000000000000

tcltest::test Block_DES-1.20 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.20 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0080000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0080000000000000]]} \
	-match exact -result d9031b0271bd5a0a

tcltest::test Block_DES-1.21 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.21 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 424250B37C3DD951]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 424250B37C3DD951]]} \
	-match exact -result 0040000000000000

tcltest::test Block_DES-1.22 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.22 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0040000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0040000000000000]]} \
	-match exact -result 424250b37c3dd951

tcltest::test Block_DES-1.23 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.23 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex B8061B7ECD9A21E5]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex B8061B7ECD9A21E5]]} \
	-match exact -result 0020000000000000

tcltest::test Block_DES-1.24 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.24 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0020000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0020000000000000]]} \
	-match exact -result b8061b7ecd9a21e5

tcltest::test Block_DES-1.25 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.25 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex F15D0F286B65BD28]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex F15D0F286B65BD28]]} \
	-match exact -result 0010000000000000

tcltest::test Block_DES-1.26 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.26 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0010000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0010000000000000]]} \
	-match exact -result f15d0f286b65bd28

tcltest::test Block_DES-1.27 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.27 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex ADD0CC8D6E5DEBA1]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex ADD0CC8D6E5DEBA1]]} \
	-match exact -result 0008000000000000

tcltest::test Block_DES-1.28 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.28 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0008000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0008000000000000]]} \
	-match exact -result add0cc8d6e5deba1

tcltest::test Block_DES-1.29 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.29 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E6D5F82752AD63D1]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E6D5F82752AD63D1]]} \
	-match exact -result 0004000000000000

tcltest::test Block_DES-1.30 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.30 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0004000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0004000000000000]]} \
	-match exact -result e6d5f82752ad63d1

tcltest::test Block_DES-1.31 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.31 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex ECBFE3BD3F591A5E]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex ECBFE3BD3F591A5E]]} \
	-match exact -result 0002000000000000

tcltest::test Block_DES-1.32 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.32 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0002000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0002000000000000]]} \
	-match exact -result ecbfe3bd3f591a5e

tcltest::test Block_DES-1.33 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.33 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex F356834379D165CD]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex F356834379D165CD]]} \
	-match exact -result 0001000000000000

tcltest::test Block_DES-1.34 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.34 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0001000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0001000000000000]]} \
	-match exact -result f356834379d165cd

tcltest::test Block_DES-1.35 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.35 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 2B9F982F20037FA9]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 2B9F982F20037FA9]]} \
	-match exact -result 0000800000000000

tcltest::test Block_DES-1.36 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.36 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000800000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000800000000000]]} \
	-match exact -result 2b9f982f20037fa9

tcltest::test Block_DES-1.37 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.37 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 889DE068A16F0BE6]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 889DE068A16F0BE6]]} \
	-match exact -result 0000400000000000

tcltest::test Block_DES-1.38 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.38 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000400000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000400000000000]]} \
	-match exact -result 889de068a16f0be6

tcltest::test Block_DES-1.39 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.39 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E19E275D846A1298]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E19E275D846A1298]]} \
	-match exact -result 0000200000000000

tcltest::test Block_DES-1.40 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.40 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000200000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000200000000000]]} \
	-match exact -result e19e275d846a1298

tcltest::test Block_DES-1.41 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.41 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 329A8ED523D71AEC]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 329A8ED523D71AEC]]} \
	-match exact -result 0000100000000000

tcltest::test Block_DES-1.42 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.42 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000100000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000100000000000]]} \
	-match exact -result 329a8ed523d71aec

tcltest::test Block_DES-1.43 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.43 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E7FCE22557D23C97]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E7FCE22557D23C97]]} \
	-match exact -result 0000080000000000

tcltest::test Block_DES-1.44 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.44 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000080000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000080000000000]]} \
	-match exact -result e7fce22557d23c97

tcltest::test Block_DES-1.45 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.45 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 12A9F5817FF2D65D]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 12A9F5817FF2D65D]]} \
	-match exact -result 0000040000000000

tcltest::test Block_DES-1.46 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.46 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000040000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000040000000000]]} \
	-match exact -result 12a9f5817ff2d65d

tcltest::test Block_DES-1.47 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.47 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex A484C3AD38DC9C19]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex A484C3AD38DC9C19]]} \
	-match exact -result 0000020000000000

tcltest::test Block_DES-1.48 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.48 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000020000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000020000000000]]} \
	-match exact -result a484c3ad38dc9c19

tcltest::test Block_DES-1.49 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.49 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex FBE00A8A1EF8AD72]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex FBE00A8A1EF8AD72]]} \
	-match exact -result 0000010000000000

tcltest::test Block_DES-1.50 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.50 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000010000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000010000000000]]} \
	-match exact -result fbe00a8a1ef8ad72

tcltest::test Block_DES-1.51 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.51 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 750D079407521363]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 750D079407521363]]} \
	-match exact -result 0000008000000000

tcltest::test Block_DES-1.52 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.52 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000008000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000008000000000]]} \
	-match exact -result 750d079407521363

tcltest::test Block_DES-1.53 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.53 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 64FEED9C724C2FAF]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 64FEED9C724C2FAF]]} \
	-match exact -result 0000004000000000

tcltest::test Block_DES-1.54 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.54 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000004000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000004000000000]]} \
	-match exact -result 64feed9c724c2faf

tcltest::test Block_DES-1.55 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.55 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex F02B263B328E2B60]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex F02B263B328E2B60]]} \
	-match exact -result 0000002000000000

tcltest::test Block_DES-1.56 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.56 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000002000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000002000000000]]} \
	-match exact -result f02b263b328e2b60

tcltest::test Block_DES-1.57 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.57 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 9D64555A9A10B852]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 9D64555A9A10B852]]} \
	-match exact -result 0000001000000000

tcltest::test Block_DES-1.58 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.58 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000001000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000001000000000]]} \
	-match exact -result 9d64555a9a10b852

tcltest::test Block_DES-1.59 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.59 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex D106FF0BED5255D7]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex D106FF0BED5255D7]]} \
	-match exact -result 0000000800000000

tcltest::test Block_DES-1.60 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.60 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000800000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000800000000]]} \
	-match exact -result d106ff0bed5255d7

tcltest::test Block_DES-1.61 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.61 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E1652C6B138C64A5]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E1652C6B138C64A5]]} \
	-match exact -result 0000000400000000

tcltest::test Block_DES-1.62 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.62 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000400000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000400000000]]} \
	-match exact -result e1652c6b138c64a5

tcltest::test Block_DES-1.63 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.63 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E428581186EC8F46]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E428581186EC8F46]]} \
	-match exact -result 0000000200000000

tcltest::test Block_DES-1.64 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.64 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000200000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000200000000]]} \
	-match exact -result e428581186ec8f46

tcltest::test Block_DES-1.65 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.65 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex AEB5F5EDE22D1A36]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex AEB5F5EDE22D1A36]]} \
	-match exact -result 0000000100000000

tcltest::test Block_DES-1.66 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.66 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000100000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000100000000]]} \
	-match exact -result aeb5f5ede22d1a36

tcltest::test Block_DES-1.67 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.67 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E943D7568AEC0C5C]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E943D7568AEC0C5C]]} \
	-match exact -result 0000000080000000

tcltest::test Block_DES-1.68 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.68 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000080000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000080000000]]} \
	-match exact -result e943d7568aec0c5c

tcltest::test Block_DES-1.69 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.69 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex DF98C8276F54B04B]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex DF98C8276F54B04B]]} \
	-match exact -result 0000000040000000

tcltest::test Block_DES-1.70 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.70 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000040000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000040000000]]} \
	-match exact -result df98c8276f54b04b

tcltest::test Block_DES-1.71 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.71 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex B160E4680F6C696F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex B160E4680F6C696F]]} \
	-match exact -result 0000000020000000

tcltest::test Block_DES-1.72 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.72 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000020000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000020000000]]} \
	-match exact -result b160e4680f6c696f

tcltest::test Block_DES-1.73 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.73 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex FA0752B07D9C4AB8]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex FA0752B07D9C4AB8]]} \
	-match exact -result 0000000010000000

tcltest::test Block_DES-1.74 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.74 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000010000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000010000000]]} \
	-match exact -result fa0752b07d9c4ab8

tcltest::test Block_DES-1.75 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.75 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex CA3A2B036DBC8502]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex CA3A2B036DBC8502]]} \
	-match exact -result 0000000008000000

tcltest::test Block_DES-1.76 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.76 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000008000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000008000000]]} \
	-match exact -result ca3a2b036dbc8502

tcltest::test Block_DES-1.77 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.77 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 5E0905517BB59BCF]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 5E0905517BB59BCF]]} \
	-match exact -result 0000000004000000

tcltest::test Block_DES-1.78 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.78 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000004000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000004000000]]} \
	-match exact -result 5e0905517bb59bcf

tcltest::test Block_DES-1.79 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.79 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 814EEB3B91D90726]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 814EEB3B91D90726]]} \
	-match exact -result 0000000002000000

tcltest::test Block_DES-1.80 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.80 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000002000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000002000000]]} \
	-match exact -result 814eeb3b91d90726

tcltest::test Block_DES-1.81 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.81 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 4D49DB1532919C9F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 4D49DB1532919C9F]]} \
	-match exact -result 0000000001000000

tcltest::test Block_DES-1.82 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.82 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000001000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000001000000]]} \
	-match exact -result 4d49db1532919c9f

tcltest::test Block_DES-1.83 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.83 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 25EB5FC3F8CF0621]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 25EB5FC3F8CF0621]]} \
	-match exact -result 0000000000800000

tcltest::test Block_DES-1.84 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.84 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000800000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000800000]]} \
	-match exact -result 25eb5fc3f8cf0621

tcltest::test Block_DES-1.85 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.85 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex AB6A20C0620D1C6F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex AB6A20C0620D1C6F]]} \
	-match exact -result 0000000000400000

tcltest::test Block_DES-1.86 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.86 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000400000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000400000]]} \
	-match exact -result ab6a20c0620d1c6f

tcltest::test Block_DES-1.87 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.87 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 79E90DBC98F92CCA]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 79E90DBC98F92CCA]]} \
	-match exact -result 0000000000200000

tcltest::test Block_DES-1.88 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.88 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000200000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000200000]]} \
	-match exact -result 79e90dbc98f92cca

tcltest::test Block_DES-1.89 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.89 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 866ECEDD8072BB0E]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 866ECEDD8072BB0E]]} \
	-match exact -result 0000000000100000

tcltest::test Block_DES-1.90 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.90 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000100000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000100000]]} \
	-match exact -result 866ecedd8072bb0e

tcltest::test Block_DES-1.91 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.91 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 8B54536F2F3E64A8]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 8B54536F2F3E64A8]]} \
	-match exact -result 0000000000080000

tcltest::test Block_DES-1.92 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.92 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000080000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000080000]]} \
	-match exact -result 8b54536f2f3e64a8

tcltest::test Block_DES-1.93 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.93 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex EA51D3975595B86B]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex EA51D3975595B86B]]} \
	-match exact -result 0000000000040000

tcltest::test Block_DES-1.94 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.94 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000040000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000040000]]} \
	-match exact -result ea51d3975595b86b

tcltest::test Block_DES-1.95 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.95 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex CAFFC6AC4542DE31]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex CAFFC6AC4542DE31]]} \
	-match exact -result 0000000000020000

tcltest::test Block_DES-1.96 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.96 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000020000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000020000]]} \
	-match exact -result caffc6ac4542de31

tcltest::test Block_DES-1.97 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.97 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 8DD45A2DDF90796C]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 8DD45A2DDF90796C]]} \
	-match exact -result 0000000000010000

tcltest::test Block_DES-1.98 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.98 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000010000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000010000]]} \
	-match exact -result 8dd45a2ddf90796c

tcltest::test Block_DES-1.99 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.99 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 1029D55E880EC2D0]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 1029D55E880EC2D0]]} \
	-match exact -result 0000000000008000

tcltest::test Block_DES-1.100 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.100 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000008000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000008000]]} \
	-match exact -result 1029d55e880ec2d0

tcltest::test Block_DES-1.101 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.101 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 5D86CB23639DBEA9]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 5D86CB23639DBEA9]]} \
	-match exact -result 0000000000004000

tcltest::test Block_DES-1.102 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.102 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000004000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000004000]]} \
	-match exact -result 5d86cb23639dbea9

tcltest::test Block_DES-1.103 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.103 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 1D1CA853AE7C0C5F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 1D1CA853AE7C0C5F]]} \
	-match exact -result 0000000000002000

tcltest::test Block_DES-1.104 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.104 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000002000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000002000]]} \
	-match exact -result 1d1ca853ae7c0c5f

tcltest::test Block_DES-1.105 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.105 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex CE332329248F3228]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex CE332329248F3228]]} \
	-match exact -result 0000000000001000

tcltest::test Block_DES-1.106 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.106 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000001000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000001000]]} \
	-match exact -result ce332329248f3228

tcltest::test Block_DES-1.107 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.107 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 8405D1ABE24FB942]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 8405D1ABE24FB942]]} \
	-match exact -result 0000000000000800

tcltest::test Block_DES-1.108 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.108 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000800]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000800]]} \
	-match exact -result 8405d1abe24fb942

tcltest::test Block_DES-1.109 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.109 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E643D78090CA4207]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E643D78090CA4207]]} \
	-match exact -result 0000000000000400

tcltest::test Block_DES-1.110 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.110 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000400]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000400]]} \
	-match exact -result e643d78090ca4207

tcltest::test Block_DES-1.111 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.111 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 48221B9937748A23]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 48221B9937748A23]]} \
	-match exact -result 0000000000000200

tcltest::test Block_DES-1.112 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.112 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000200]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000200]]} \
	-match exact -result 48221b9937748a23

tcltest::test Block_DES-1.113 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.113 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex DD7C0BBD61FAFD54]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex DD7C0BBD61FAFD54]]} \
	-match exact -result 0000000000000100

tcltest::test Block_DES-1.114 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.114 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000100]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000100]]} \
	-match exact -result dd7c0bbd61fafd54

tcltest::test Block_DES-1.115 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.115 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 2FBC291A570DB5C4]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 2FBC291A570DB5C4]]} \
	-match exact -result 0000000000000080

tcltest::test Block_DES-1.116 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.116 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000080]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000080]]} \
	-match exact -result 2fbc291a570db5c4

tcltest::test Block_DES-1.117 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.117 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex E07C30D7E4E26E12]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex E07C30D7E4E26E12]]} \
	-match exact -result 0000000000000040

tcltest::test Block_DES-1.118 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.118 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000040]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000040]]} \
	-match exact -result e07c30d7e4e26e12

tcltest::test Block_DES-1.119 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.119 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0953E2258E8E90A1]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0953E2258E8E90A1]]} \
	-match exact -result 0000000000000020

tcltest::test Block_DES-1.120 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.120 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000020]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000020]]} \
	-match exact -result 0953e2258e8e90a1

tcltest::test Block_DES-1.121 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.121 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 5B711BC4CEEBF2EE]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 5B711BC4CEEBF2EE]]} \
	-match exact -result 0000000000000010

tcltest::test Block_DES-1.122 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.122 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000010]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000010]]} \
	-match exact -result 5b711bc4ceebf2ee

tcltest::test Block_DES-1.123 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.123 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex CC083F1E6D9E85F6]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex CC083F1E6D9E85F6]]} \
	-match exact -result 0000000000000008

tcltest::test Block_DES-1.124 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.124 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000008]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000008]]} \
	-match exact -result cc083f1e6d9e85f6

tcltest::test Block_DES-1.125 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.125 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex D2FD8867D50D2DFE]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex D2FD8867D50D2DFE]]} \
	-match exact -result 0000000000000004

tcltest::test Block_DES-1.126 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.126 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000004]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000004]]} \
	-match exact -result d2fd8867d50d2dfe

tcltest::test Block_DES-1.127 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.127 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 06E7EA22CE92708F]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 06E7EA22CE92708F]]} \
	-match exact -result 0000000000000002

tcltest::test Block_DES-1.128 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.128 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000002]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000002]]} \
	-match exact -result 06e7ea22ce92708f

tcltest::test Block_DES-1.129 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.129 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 166B40B44ABA4BD6]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 166B40B44ABA4BD6]]} \
	-match exact -result 0000000000000001

tcltest::test Block_DES-1.130 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.130 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000001]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000001]]} \
	-match exact -result 166b40b44aba4bd6

tcltest::test Block_DES-1.131 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.131 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 7CA110454A1A6E57] \
		-data [binary decode hex 01A1D6D039776742]]} \
		 -key [binary decode hex 7CA110454A1A6E57] \
		 -data [binary decode hex 01A1D6D039776742]]} \
	-match exact -result 690f5b0d9a26939b

tcltest::test Block_DES-1.132 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.132 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 7CA110454A1A6E57] \
		-data [binary decode hex 690F5B0D9A26939B]]} \
		 -key [binary decode hex 7CA110454A1A6E57] \
		 -data [binary decode hex 690F5B0D9A26939B]]} \
	-match exact -result 01a1d6d039776742

tcltest::test Block_DES-1.133 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.133 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0131D9619DC1376E] \
		-data [binary decode hex 5CD54CA83DEF57DA]]} \
		 -key [binary decode hex 0131D9619DC1376E] \
		 -data [binary decode hex 5CD54CA83DEF57DA]]} \
	-match exact -result 7a389d10354bd271

tcltest::test Block_DES-1.134 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.134 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0131D9619DC1376E] \
		-data [binary decode hex 7A389D10354BD271]]} \
		 -key [binary decode hex 0131D9619DC1376E] \
		 -data [binary decode hex 7A389D10354BD271]]} \
	-match exact -result 5cd54ca83def57da

tcltest::test Block_DES-1.135 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.135 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 07A1133E4A0B2686] \
		-data [binary decode hex 0248D43806F67172]]} \
		 -key [binary decode hex 07A1133E4A0B2686] \
		 -data [binary decode hex 0248D43806F67172]]} \
	-match exact -result 868ebb51cab4599a

tcltest::test Block_DES-1.136 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.136 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 07A1133E4A0B2686] \
		-data [binary decode hex 868EBB51CAB4599A]]} \
		 -key [binary decode hex 07A1133E4A0B2686] \
		 -data [binary decode hex 868EBB51CAB4599A]]} \
	-match exact -result 0248d43806f67172

tcltest::test Block_DES-1.137 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.137 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 3849674C2602319E] \
		-data [binary decode hex 51454B582DDF440A]]} \
		 -key [binary decode hex 3849674C2602319E] \
		 -data [binary decode hex 51454B582DDF440A]]} \
	-match exact -result 7178876e01f19b2a

tcltest::test Block_DES-1.138 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.138 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 3849674C2602319E] \
		-data [binary decode hex 7178876E01F19B2A]]} \
		 -key [binary decode hex 3849674C2602319E] \
		 -data [binary decode hex 7178876E01F19B2A]]} \
	-match exact -result 51454b582ddf440a

tcltest::test Block_DES-1.139 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.139 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 04B915BA43FEB5B6] \
		-data [binary decode hex 42FD443059577FA2]]} \
		 -key [binary decode hex 04B915BA43FEB5B6] \
		 -data [binary decode hex 42FD443059577FA2]]} \
	-match exact -result af37fb421f8c4095

tcltest::test Block_DES-1.140 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.140 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 04B915BA43FEB5B6] \
		-data [binary decode hex AF37FB421F8C4095]]} \
		 -key [binary decode hex 04B915BA43FEB5B6] \
		 -data [binary decode hex AF37FB421F8C4095]]} \
	-match exact -result 42fd443059577fa2

tcltest::test Block_DES-1.141 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.141 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0113B970FD34F2CE] \
		-data [binary decode hex 059B5E0851CF143A]]} \
		 -key [binary decode hex 0113B970FD34F2CE] \
		 -data [binary decode hex 059B5E0851CF143A]]} \
	-match exact -result 86a560f10ec6d85b

tcltest::test Block_DES-1.142 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.142 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0113B970FD34F2CE] \
		-data [binary decode hex 86A560F10EC6D85B]]} \
		 -key [binary decode hex 0113B970FD34F2CE] \
		 -data [binary decode hex 86A560F10EC6D85B]]} \
	-match exact -result 059b5e0851cf143a

tcltest::test Block_DES-1.143 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.143 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0170F175468FB5E6] \
		-data [binary decode hex 0756D8E0774761D2]]} \
		 -key [binary decode hex 0170F175468FB5E6] \
		 -data [binary decode hex 0756D8E0774761D2]]} \
	-match exact -result 0cd3da020021dc09

tcltest::test Block_DES-1.144 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.144 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0170F175468FB5E6] \
		-data [binary decode hex 0CD3DA020021DC09]]} \
		 -key [binary decode hex 0170F175468FB5E6] \
		 -data [binary decode hex 0CD3DA020021DC09]]} \
	-match exact -result 0756d8e0774761d2

tcltest::test Block_DES-1.145 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.145 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 43297FAD38E373FE] \
		-data [binary decode hex 762514B829BF486A]]} \
		 -key [binary decode hex 43297FAD38E373FE] \
		 -data [binary decode hex 762514B829BF486A]]} \
	-match exact -result ea676b2cb7db2b7a

tcltest::test Block_DES-1.146 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.146 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 43297FAD38E373FE] \
		-data [binary decode hex EA676B2CB7DB2B7A]]} \
		 -key [binary decode hex 43297FAD38E373FE] \
		 -data [binary decode hex EA676B2CB7DB2B7A]]} \
	-match exact -result 762514b829bf486a

tcltest::test Block_DES-1.147 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.147 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 07A7137045DA2A16] \
		-data [binary decode hex 3BDD119049372802]]} \
		 -key [binary decode hex 07A7137045DA2A16] \
		 -data [binary decode hex 3BDD119049372802]]} \
	-match exact -result dfd64a815caf1a0f

tcltest::test Block_DES-1.148 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.148 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 07A7137045DA2A16] \
		-data [binary decode hex DFD64A815CAF1A0F]]} \
		 -key [binary decode hex 07A7137045DA2A16] \
		 -data [binary decode hex DFD64A815CAF1A0F]]} \
	-match exact -result 3bdd119049372802

tcltest::test Block_DES-1.149 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.149 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 04689104C2FD3B2F] \
		-data [binary decode hex 26955F6835AF609A]]} \
		 -key [binary decode hex 04689104C2FD3B2F] \
		 -data [binary decode hex 26955F6835AF609A]]} \
	-match exact -result 5c513c9c4886c088

tcltest::test Block_DES-1.150 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.150 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 04689104C2FD3B2F] \
		-data [binary decode hex 5C513C9C4886C088]]} \
		 -key [binary decode hex 04689104C2FD3B2F] \
		 -data [binary decode hex 5C513C9C4886C088]]} \
	-match exact -result 26955f6835af609a

tcltest::test Block_DES-1.151 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.151 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 37D06BB516CB7546] \
		-data [binary decode hex 164D5E404F275232]]} \
		 -key [binary decode hex 37D06BB516CB7546] \
		 -data [binary decode hex 164D5E404F275232]]} \
	-match exact -result 0a2aeeae3ff4ab77

tcltest::test Block_DES-1.152 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.152 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 37D06BB516CB7546] \
		-data [binary decode hex 0A2AEEAE3FF4AB77]]} \
		 -key [binary decode hex 37D06BB516CB7546] \
		 -data [binary decode hex 0A2AEEAE3FF4AB77]]} \
	-match exact -result 164d5e404f275232

tcltest::test Block_DES-1.153 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.153 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 1F08260D1AC2465E] \
		-data [binary decode hex 6B056E18759F5CCA]]} \
		 -key [binary decode hex 1F08260D1AC2465E] \
		 -data [binary decode hex 6B056E18759F5CCA]]} \
	-match exact -result ef1bf03e5dfa575a

tcltest::test Block_DES-1.154 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.154 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 1F08260D1AC2465E] \
		-data [binary decode hex EF1BF03E5DFA575A]]} \
		 -key [binary decode hex 1F08260D1AC2465E] \
		 -data [binary decode hex EF1BF03E5DFA575A]]} \
	-match exact -result 6b056e18759f5cca

tcltest::test Block_DES-1.155 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.155 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 584023641ABA6176] \
		-data [binary decode hex 004BD6EF09176062]]} \
		 -key [binary decode hex 584023641ABA6176] \
		 -data [binary decode hex 004BD6EF09176062]]} \
	-match exact -result 88bf0db6d70dee56

tcltest::test Block_DES-1.156 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.156 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 584023641ABA6176] \
		-data [binary decode hex 88BF0DB6D70DEE56]]} \
		 -key [binary decode hex 584023641ABA6176] \
		 -data [binary decode hex 88BF0DB6D70DEE56]]} \
	-match exact -result 004bd6ef09176062

tcltest::test Block_DES-1.157 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.157 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 025816164629B007] \
		-data [binary decode hex 480D39006EE762F2]]} \
		 -key [binary decode hex 025816164629B007] \
		 -data [binary decode hex 480D39006EE762F2]]} \
	-match exact -result a1f9915541020b56

tcltest::test Block_DES-1.158 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.158 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 025816164629B007] \
		-data [binary decode hex A1F9915541020B56]]} \
		 -key [binary decode hex 025816164629B007] \
		 -data [binary decode hex A1F9915541020B56]]} \
	-match exact -result 480d39006ee762f2

tcltest::test Block_DES-1.159 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.159 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 49793EBC79B3258F] \
		-data [binary decode hex 437540C8698F3CFA]]} \
		 -key [binary decode hex 49793EBC79B3258F] \
		 -data [binary decode hex 437540C8698F3CFA]]} \
	-match exact -result 6fbf1cafcffd0556

tcltest::test Block_DES-1.160 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.160 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 49793EBC79B3258F] \
		-data [binary decode hex 6FBF1CAFCFFD0556]]} \
		 -key [binary decode hex 49793EBC79B3258F] \
		 -data [binary decode hex 6FBF1CAFCFFD0556]]} \
	-match exact -result 437540c8698f3cfa

tcltest::test Block_DES-1.161 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.161 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 4FB05E1515AB73A7] \
		-data [binary decode hex 072D43A077075292]]} \
		 -key [binary decode hex 4FB05E1515AB73A7] \
		 -data [binary decode hex 072D43A077075292]]} \
	-match exact -result 2f22e49bab7ca1ac

tcltest::test Block_DES-1.162 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.162 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 4FB05E1515AB73A7] \
		-data [binary decode hex 2F22E49BAB7CA1AC]]} \
		 -key [binary decode hex 4FB05E1515AB73A7] \
		 -data [binary decode hex 2F22E49BAB7CA1AC]]} \
	-match exact -result 072d43a077075292

tcltest::test Block_DES-1.163 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.163 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 49E95D6D4CA229BF] \
		-data [binary decode hex 02FE55778117F12A]]} \
		 -key [binary decode hex 49E95D6D4CA229BF] \
		 -data [binary decode hex 02FE55778117F12A]]} \
	-match exact -result 5a6b612cc26cce4a

tcltest::test Block_DES-1.164 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.164 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 49E95D6D4CA229BF] \
		-data [binary decode hex 5A6B612CC26CCE4A]]} \
		 -key [binary decode hex 49E95D6D4CA229BF] \
		 -data [binary decode hex 5A6B612CC26CCE4A]]} \
	-match exact -result 02fe55778117f12a

tcltest::test Block_DES-1.165 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.165 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 018310DC409B26D6] \
		-data [binary decode hex 1D9D5C5018F728C2]]} \
		 -key [binary decode hex 018310DC409B26D6] \
		 -data [binary decode hex 1D9D5C5018F728C2]]} \
	-match exact -result 5f4c038ed12b2e41

tcltest::test Block_DES-1.166 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.166 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 018310DC409B26D6] \
		-data [binary decode hex 5F4C038ED12B2E41]]} \
		 -key [binary decode hex 018310DC409B26D6] \
		 -data [binary decode hex 5F4C038ED12B2E41]]} \
	-match exact -result 1d9d5c5018f728c2

tcltest::test Block_DES-1.167 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.167 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 1C587F1C13924FEF] \
		-data [binary decode hex 305532286D6F295A]]} \
		 -key [binary decode hex 1C587F1C13924FEF] \
		 -data [binary decode hex 305532286D6F295A]]} \
	-match exact -result 63fac0d034d9f793

tcltest::test Block_DES-1.168 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.168 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 1C587F1C13924FEF] \
		-data [binary decode hex 63FAC0D034D9F793]]} \
		 -key [binary decode hex 1C587F1C13924FEF] \
		 -data [binary decode hex 63FAC0D034D9F793]]} \
	-match exact -result 305532286d6f295a

tcltest::test Block_DES-1.169 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.169 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 10316E028C8F3B4A] \
		-data [binary decode hex 0000000000000000]]} \
		 -key [binary decode hex 10316E028C8F3B4A] \
		 -data [binary decode hex 0000000000000000]]} \
	-match exact -result 82dcbafbdeab6602

tcltest::test Block_DES-1.170 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.170 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 10316E028C8F3B4A] \
		-data [binary decode hex 82DCBAFBDEAB6602]]} \
		 -key [binary decode hex 10316E028C8F3B4A] \
		 -data [binary decode hex 82DCBAFBDEAB6602]]} \
	-match exact -result 0000000000000000

tcltest::test Block_DES-1.171 {Encrypt DES} \
tcltest::test Symetric_Block_DES-1.171 {Encrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::encrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 0000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 0000000000000000]]} \
	-match exact -result 8000000000000000

tcltest::test Block_DES-1.172 {Decrypt DES} \
tcltest::test Symetric_Block_DES-1.172 {Decrypt DES} \
	-constraints DES \
	-body {binary encode hex [tls::decrypt -cipher DES -padding 0 \
		-key [binary decode hex 0101010101010101] \
		-data [binary decode hex 8000000000000000]]} \
		 -key [binary decode hex 0101010101010101] \
		 -data [binary decode hex 8000000000000000]]} \
	-match exact -result 0000000000000000

# Cleanup
::tcltest::cleanupTests
return

Modified tests/test_vectors/Symetric_Block/DES3.test from [8f0c923444] to [abdc263722]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25

26
27
28
29
30
31
32
33

34
35
36
37
38
39
40

1
2
3
4
5
6
7
8

9
10
11
12
13
14
15
16

17
18
19
20
21
22
23
24

25
26
27
28
29
30
31
32

33
34
35
36
37
38
39
40









-
+







-
+







-
+







-
+








# Auto generated from "DES3.txt"
lappend auto_path [file dirname [file dirname [file dirname [file dirname [file join [pwd] [info script]]]]]]
package require tls
package require tcltest

catch {tls::provider legacy}
tcltest::testConstraint DES3 [expr {[lsearch -nocase [tls::ciphers] DES3] > -1}]

tcltest::test Block_DES3-1.1 {Encrypt DES3} \
tcltest::test Symetric_Block_DES3-1.1 {Encrypt DES3} \
	-constraints DES3 \
	-body {binary encode hex [tls::encrypt -cipher DES3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 2079c3d53aa763e193b79e2569ab5262516570481f25b50f73c0bda85c8e0da7

tcltest::test Block_DES3-1.2 {Decrypt DES3} \
tcltest::test Symetric_Block_DES3-1.2 {Decrypt DES3} \
	-constraints DES3 \
	-body {binary encode hex [tls::decrypt -cipher DES3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef01456789abcdef0123] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 2079c3d53aa763e193b79e2569ab5262516570481f25b50f73c0bda85c8e0da7]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51

tcltest::test Block_DES3-1.3 {Encrypt DES3} \
tcltest::test Symetric_Block_DES3-1.3 {Encrypt DES3} \
	-constraints DES3 \
	-body {binary encode hex [tls::encrypt -cipher DES3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51]]} \
	-match exact -result 7401ce1eab6d003caff84bf47b36cc2154f0238f9ffecd8f6acf118392b45581

tcltest::test Block_DES3-1.4 {Decrypt DES3} \
tcltest::test Symetric_Block_DES3-1.4 {Decrypt DES3} \
	-constraints DES3 \
	-body {binary encode hex [tls::decrypt -cipher DES3 -padding 0 \
		 -key [binary decode hex 0123456789abcdef23456789abcdef010123456789abcdef] \
		 -iv [binary decode hex f69f2445df4f9b17] \
		 -data [binary decode hex 7401ce1eab6d003caff84bf47b36cc2154f0238f9ffecd8f6acf118392b45581]]} \
	-match exact -result 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e51
︙

Added tests/test_vectors/Symetric_Block/IDEA-CBC.test version [8aab9b72a4].

Added tests/test_vectors/Symetric_Block/IDEA-CBC.txt version [c3d48a6bc3].

Added tests/test_vectors/Symetric_Block/IDEA-CFB.test version [c5f830e201].

Added tests/test_vectors/Symetric_Block/IDEA-CFB.txt version [ad8823e093].

Added tests/test_vectors/Symetric_Block/IDEA-ECB.test version [cfd5024d4f].

Added tests/test_vectors/Symetric_Block/IDEA-ECB.txt version [36f94fb423].

Added tests/test_vectors/Symetric_Block/IDEA-OFB.test version [921c132deb].

Added tests/test_vectors/Symetric_Block/IDEA-OFB.txt version [c4971e5d27].

Added tests/test_vectors/Symetric_Block/IDEA.test version [7d95c63e61].

Added tests/test_vectors/Symetric_Block/IDEA.txt version [a721c30475].

Modified tests/test_vectors/Symetric_Block/make_test.tcl from [738ff2bcbc] to [a0240c6935]. 

1
2
3
4
5
6
7
8

9
10
11
12
13

14
15
16
17
18
19
20

1
2
3
4
5
6
7

8
9
10
11
12

13
14
15
16
17
18
19
20








-
+




-
+








#
# Test Vectors
#

#
# Create test case and output to test file
#
proc do_test {group cipher file_num tc params fn} {
proc do_test {group cipher test_num tc params fn} {
    array set config [list Key "" IV "" Msg "" Repeat 1 Length ""]
    array set config $params

    # Test info
    set line [format "tcltest::test %s-%d.%d {%s %s} \\\n\t" $group $file_num $tc [string totitle $fn] $cipher]
    set line [format "tcltest::test %s-%d.%d {%s %s} \\\n\t" $group $test_num $tc [string totitle $fn] $cipher]

    # Test constraints
    append line [format "-constraints %s \\\n\t" [string map [list "-" "_"] $cipher]]

    # Test body
    set cmd [format "tls::%s -cipher %s -padding 0 \\\n\t\t" $fn $cipher]
︙
64
65
66
67
68
69
70
71

72
73
74
75
76
77
78

64
65
66
67
68
69
70

71
72
73
74
75
76
77
78








-
+








    #append line { -returnCodes 0}
    return $line
}

#
# Parse test vector file and get test cases config info
#
proc parse {group filename file_num cipher} {
proc parse {group filename test_num cipher} {
    set tc 0
    set params [list]

    # Open input file
    if {[catch {open $filename r} ch]} {
	return -code error $ch
    }
︙
101
102
103
104
105
106
107
108

109
110

111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

131
132
133
134
135
136
137
138
139
140
141
142
143
144

145
146
147
148
149
150
151

101
102
103
104
105
106
107

108
109

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

130
131
132
133
134
135
136
137
138
139
140
141
142
143

144
145
146
147
148
149
150
151








-
+

-
+



















-
+













-
+








	if {[string index $line 0] in [list "#" "\["]} {
	    # Skip comments and info lines
	    continue

	} elseif {$len == 0} {
	    if {[llength $params] > 0} {
		# Do test if end of params
		puts $out [do_test $group $cipher $file_num [incr tc] $params encrypt]
		puts $out [do_test $group $cipher $test_num [incr tc] $params encrypt]
		puts $out ""
		puts $out [do_test $group $cipher $file_num [incr tc] $params decrypt]
		puts $out [do_test $group $cipher $test_num [incr tc] $params decrypt]
		puts $out ""
		set params [list]
	    } else {
		# Empty line
	    }

	} else {
	    # Append args to params
	    set index [string first "=" $line]
	    if {$index > -1} {
		set key [string trim [string range $line 0 [expr {$index - 1}]]]
		set value [string trim [string range $line [expr {$index + 1}] end]]
		lappend params $key $value
	    }
	}
    }

    # Handle last test case
    if {[llength $params] > 0} {
	puts $out [do_test $group $cipher $file_num [incr tc] $params]
	puts $out [do_test $group $cipher $test_num [incr tc] $params]
	puts $out ""
    }
    
    # Cleanup
    puts $out "# Cleanup\n::tcltest::cleanupTests\nreturn"
    close $ch
    close $out
}

#
# Read all config files in directory
#
proc main {path} {
    set file_num 0
    set test_num 0
    set group [file rootname [file tail $path]]

    foreach filename [glob -directory $path *.txt] {
	puts [format "Processing %s" $filename]
	set tail [file tail $filename]
	if {[string match -nocase "Readme.txt" $tail]} {
	    continue
︙

Powered by Fossil · RSS