TclTLS
Check-in [c12c859d2f]
Login
HomeTimelineDownloadBrowse SourceBranchesTagsTicketsWiki
EuroTcl/OpenACS 11 - 12 JULY 2024, VIENNA
Overview
Comment:Added SM4 cipher test vectors
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | crypto
Files: files | file ages | folders
SHA3-256: c12c859d2f5e321c499caed00a39b2c2929257615e295da9bf164526c3c36cfe
User & Date: bohagan on 2024-04-09 01:07:25
Other Links: branch diff | manifest | tags
Context
2024-04-09
03:21
Added remaining Camellia cipher test vectors check-in: 51d59fd360 user: bohagan tags: crypto
01:07
Added SM4 cipher test vectors check-in: c12c859d2f user: bohagan tags: crypto
2024-04-08
21:30
Added ARIA cipher test vectors check-in: 2a6486178c user: bohagan tags: crypto
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Added tests/test_vectors/Symetric_Block/SM4-CBC.test version [fa1ce880f1]. 













































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4-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 SM4_CBC [expr {[lsearch -nocase [tls::ciphers] SM4-CBC] > -1}]

tcltest::test Symetric_Block_SM4-CBC-1.1 {Encrypt SM4-CBC} \
	-constraints SM4_CBC \
	-body {binary encode hex [tls::encrypt -cipher SM4-CBC -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result 78ebb11cc40b0a48312aaeb2040244cb4cb7016951909226979b0d15dc6a8f6d

tcltest::test Symetric_Block_SM4-CBC-1.2 {Decrypt SM4-CBC} \
	-constraints SM4_CBC \
	-body {binary encode hex [tls::decrypt -cipher SM4-CBC -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex 78EBB11CC40B0A48312AAEB2040244CB4CB7016951909226979B0D15DC6A8F6D]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

tcltest::test Symetric_Block_SM4-CBC-1.3 {Encrypt SM4-CBC} \
	-constraints SM4_CBC \
	-body {binary encode hex [tls::encrypt -cipher SM4-CBC -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result 0d3a6ddc2d21c698857215587b7bb59a91f2c147911a4144665e1fa1d40bae38

tcltest::test Symetric_Block_SM4-CBC-1.4 {Decrypt SM4-CBC} \
	-constraints SM4_CBC \
	-body {binary encode hex [tls::decrypt -cipher SM4-CBC -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex 0D3A6DDC2D21C698857215587B7BB59A91F2C147911A4144665E1FA1D40BAE38]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4-CBC.txt version [29b8a5369c].



















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4-CBC cipher from: https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.2.2.  SM4-CBC Examples

# A.2.2.1.  Example 1
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = 0123456789ABCDEFFEDCBA9876543210
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = 78EBB11CC40B0A48312AAEB2040244CB4CB7016951909226979B0D15DC6A8F6D

# A.2.2.2.  Example 2
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = FEDCBA98765432100123456789ABCDEF
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = 0D3A6DDC2D21C698857215587B7BB59A91F2C147911A4144665E1FA1D40BAE38








Added tests/test_vectors/Symetric_Block/SM4-CFB.test version [29cccb3138].















































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4-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 SM4_CFB [expr {[lsearch -nocase [tls::ciphers] SM4-CFB] > -1}]

tcltest::test Symetric_Block_SM4-CFB-1.1 {Encrypt SM4-CFB} \
	-constraints SM4_CFB \
	-body {binary encode hex [tls::encrypt -cipher SM4-CFB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result ac3236cb861dd316e6413b4e3c7524b769d4c54ed433b9a0346009beb37b2b3f

tcltest::test Symetric_Block_SM4-CFB-1.2 {Decrypt SM4-CFB} \
	-constraints SM4_CFB \
	-body {binary encode hex [tls::decrypt -cipher SM4-CFB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AC3236CB861DD316E6413B4E3C7524B769D4C54ED433B9A0346009BEB37B2B3F]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

tcltest::test Symetric_Block_SM4-CFB-1.3 {Encrypt SM4-CFB} \
	-constraints SM4_CFB \
	-body {binary encode hex [tls::encrypt -cipher SM4-CFB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result 5dcccd25a84ba16560d7f265887068490d9b86ff20c3bfe115ffa02ca6192cc5

tcltest::test Symetric_Block_SM4-CFB-1.4 {Decrypt SM4-CFB} \
	-constraints SM4_CFB \
	-body {binary encode hex [tls::decrypt -cipher SM4-CFB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex 5DCCCD25A84BA16560D7F265887068490D9B86FF20C3BFE115FFA02CA6192CC5]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4-CFB.txt version [52e155fa40].



















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4-CFB cipher from: https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.2.4.  SM4-CFB Examples

# A.2.4.1.  Example 1
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = 0123456789ABCDEFFEDCBA9876543210
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = AC3236CB861DD316E6413B4E3C7524B769D4C54ED433B9A0346009BEB37B2B3F

# A.2.4.2.  Example 2
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = FEDCBA98765432100123456789ABCDEF
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = 5DCCCD25A84BA16560D7F265887068490D9B86FF20C3BFE115FFA02CA6192CC5








Added tests/test_vectors/Symetric_Block/SM4-CTR.test version [ce5732b46d].















































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4-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 SM4_CTR [expr {[lsearch -nocase [tls::ciphers] SM4-CTR] > -1}]

tcltest::test Symetric_Block_SM4-CTR-1.1 {Encrypt SM4-CTR} \
	-constraints SM4_CTR \
	-body {binary encode hex [tls::encrypt -cipher SM4-CTR -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB]]} \
	-match exact -result ac3236cb970cc20791364c395a1342d1a3cbc1878c6f30cd074cce385cdd70c7f234bc0e24c11980fd1286310ce37b926e02fcd0faa0baf38b2933851d824514

tcltest::test Symetric_Block_SM4-CTR-1.2 {Decrypt SM4-CTR} \
	-constraints SM4_CTR \
	-body {binary encode hex [tls::decrypt -cipher SM4-CTR -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AC3236CB970CC20791364C395A1342D1A3CBC1878C6F30CD074CCE385CDD70C7F234BC0E24C11980FD1286310CE37B926E02FCD0FAA0BAF38B2933851D824514]]} \
	-match exact -result aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccddddddddddddddddeeeeeeeeeeeeeeeeffffffffffffffffaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb

tcltest::test Symetric_Block_SM4-CTR-1.3 {Encrypt SM4-CTR} \
	-constraints SM4_CTR \
	-body {binary encode hex [tls::encrypt -cipher SM4-CTR -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB]]} \
	-match exact -result 5dcccd25b95ab07417a08512ee160e2f8f661521cbbab44cc87138445bc29e5c0ae0297205d62704173b21239b887f6c8cb5b800917a2488284bde9e16ea2906

tcltest::test Symetric_Block_SM4-CTR-1.4 {Decrypt SM4-CTR} \
	-constraints SM4_CTR \
	-body {binary encode hex [tls::decrypt -cipher SM4-CTR -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex 5DCCCD25B95AB07417A08512EE160E2F8F661521CBBAB44CC87138445BC29E5C0AE0297205D62704173B21239B887F6C8CB5B800917A2488284BDE9E16EA2906]]} \
	-match exact -result aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccddddddddddddddddeeeeeeeeeeeeeeeeffffffffffffffffaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4-CTR.txt version [6db0a51cf6].



















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4-CTR cipher from: https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.2.5.  SM4-CTR Examples

# A.2.5.1.  Example 1
Plaintext = AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB
Key = 0123456789ABCDEFFEDCBA9876543210
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = AC3236CB970CC20791364C395A1342D1A3CBC1878C6F30CD074CCE385CDD70C7F234BC0E24C11980FD1286310CE37B926E02FCD0FAA0BAF38B2933851D824514

# A.2.5.2.  Example 2
Plaintext = AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB
Key = FEDCBA98765432100123456789ABCDEF
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = 5DCCCD25B95AB07417A08512EE160E2F8F661521CBBAB44CC87138445BC29E5C0AE0297205D62704173B21239B887F6C8CB5B800917A2488284BDE9E16EA2906








Added tests/test_vectors/Symetric_Block/SM4-ECB.test version [1240f8c454].











































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4-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 SM4_ECB [expr {[lsearch -nocase [tls::ciphers] SM4-ECB] > -1}]

tcltest::test Symetric_Block_SM4-ECB-1.1 {Encrypt SM4-ECB} \
	-constraints SM4_ECB \
	-body {binary encode hex [tls::encrypt -cipher SM4-ECB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result 5ec8143de509cff7b5179f8f474b86192f1d305a7fb17df985f81c8482192304

tcltest::test Symetric_Block_SM4-ECB-1.2 {Decrypt SM4-ECB} \
	-constraints SM4_ECB \
	-body {binary encode hex [tls::decrypt -cipher SM4-ECB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data [binary decode hex 5EC8143DE509CFF7B5179F8F474B86192F1D305A7FB17DF985F81C8482192304]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

tcltest::test Symetric_Block_SM4-ECB-1.3 {Encrypt SM4-ECB} \
	-constraints SM4_ECB \
	-body {binary encode hex [tls::encrypt -cipher SM4-ECB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result c5876897e4a59bbba72a10c83872245b12dd90bc2d200692b529a4155ac9e600

tcltest::test Symetric_Block_SM4-ECB-1.4 {Decrypt SM4-ECB} \
	-constraints SM4_ECB \
	-body {binary encode hex [tls::decrypt -cipher SM4-ECB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data [binary decode hex C5876897E4A59BBBA72A10C83872245B12DD90BC2D200692B529A4155AC9E600]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4-ECB.txt version [f13eb5f686].

















1
2
3
4
5
6
7
8
9
10
11
12
13

+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4-ECB cipher from https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.2.1.  SM4-ECB Examples

# A.2.1.1.  Example 1
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = 0123456789ABCDEFFEDCBA9876543210
Ciphertext = 5EC8143DE509CFF7B5179F8F474B86192F1D305A7FB17DF985F81C8482192304

# A.2.1.2.  Example 2
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = FEDCBA98765432100123456789ABCDEF
Ciphertext = C5876897E4A59BBBA72A10C83872245B12DD90BC2D200692B529A4155AC9E600








Added tests/test_vectors/Symetric_Block/SM4-OFB.test version [59f4805856].















































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4-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 SM4_OFB [expr {[lsearch -nocase [tls::ciphers] SM4-OFB] > -1}]

tcltest::test Symetric_Block_SM4-OFB-1.1 {Encrypt SM4-OFB} \
	-constraints SM4_OFB \
	-body {binary encode hex [tls::encrypt -cipher SM4-OFB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result ac3236cb861dd316e6413b4e3c7524b71d01aca2487ca582cbf5463e6698539b

tcltest::test Symetric_Block_SM4-OFB-1.2 {Decrypt SM4-OFB} \
	-constraints SM4_OFB \
	-body {binary encode hex [tls::decrypt -cipher SM4-OFB -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AC3236CB861DD316E6413B4E3C7524B71D01ACA2487CA582CBF5463E6698539B]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

tcltest::test Symetric_Block_SM4-OFB-1.3 {Encrypt SM4-OFB} \
	-constraints SM4_OFB \
	-body {binary encode hex [tls::encrypt -cipher SM4-OFB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB]]} \
	-match exact -result 5dcccd25a84ba16560d7f2658870684933fa16bd5cd9c856cacaa1e101897a97

tcltest::test Symetric_Block_SM4-OFB-1.4 {Decrypt SM4-OFB} \
	-constraints SM4_OFB \
	-body {binary encode hex [tls::decrypt -cipher SM4-OFB -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -iv [binary decode hex 000102030405060708090A0B0C0D0E0F] \
		 -data [binary decode hex 5DCCCD25A84BA16560D7F2658870684933FA16BD5CD9C856CACAA1E101897A97]]} \
	-match exact -result aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffaaaaaaaabbbbbbbb

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4-OFB.txt version [5aa9f2a666].



















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4-OFB cipher from: https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.2.3.  SM4-OFB Examples

# A.2.3.1.  Example 1
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = 0123456789ABCDEFFEDCBA9876543210
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = AC3236CB861DD316E6413B4E3C7524B71D01ACA2487CA582CBF5463E6698539B

# A.2.3.2.  Example 2
Plaintext = AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDDEEEEEEEEFFFFFFFFAAAAAAAABBBBBBBB
Key = FEDCBA98765432100123456789ABCDEF
IV = 000102030405060708090A0B0C0D0E0F
Ciphertext = 5DCCCD25A84BA16560D7F2658870684933FA16BD5CD9C856CACAA1E101897A97








Added tests/test_vectors/Symetric_Block/SM4.test version [51ff79a1ea].







































































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

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# Auto generated from "SM4.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 SM4 [expr {[lsearch -nocase [tls::ciphers] SM4] > -1}]

tcltest::test Symetric_Block_SM4-1.1 {Encrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [tls::encrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data [binary decode hex 0123456789ABCDEFFEDCBA9876543210]]} \
	-match exact -result 681edf34d206965e86b3e94f536e4246

tcltest::test Symetric_Block_SM4-1.2 {Decrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [tls::decrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data [binary decode hex 681EDF34D206965E86B3E94F536E4246]]} \
	-match exact -result 0123456789abcdeffedcba9876543210

tcltest::test Symetric_Block_SM4-1.3 {Encrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [set data [binary decode hex 0123456789ABCDEFFEDCBA9876543210];for {set i 0} {$i < 1000000} {incr i} {set data [tls::encrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data $data]};set data]} \
	-match exact -result 595298c7c6fd271f0402f804c33d3f66

tcltest::test Symetric_Block_SM4-1.4 {Decrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [set data [binary decode hex 595298C7C6FD271F0402F804C33D3F66];for {set i 0} {$i < 1000000} {incr i} {set data [tls::decrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex 0123456789ABCDEFFEDCBA9876543210] \
		 -data $data]};set data]} \
	-match exact -result 0123456789abcdeffedcba9876543210

tcltest::test Symetric_Block_SM4-1.5 {Encrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [tls::encrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data [binary decode hex 000102030405060708090A0B0C0D0E0F]]} \
	-match exact -result f766678f13f01adeac1b3ea955adb594

tcltest::test Symetric_Block_SM4-1.6 {Decrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [tls::decrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data [binary decode hex F766678F13F01ADEAC1B3EA955ADB594]]} \
	-match exact -result 000102030405060708090a0b0c0d0e0f

tcltest::test Symetric_Block_SM4-1.7 {Encrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [set data [binary decode hex 000102030405060708090A0B0C0D0E0F];for {set i 0} {$i < 1000000} {incr i} {set data [tls::encrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data $data]};set data]} \
	-match exact -result 379a96d0a6a5a5060fb460c75d1879ed

tcltest::test Symetric_Block_SM4-1.8 {Decrypt SM4} \
	-constraints SM4 \
	-body {binary encode hex [set data [binary decode hex 379A96D0A6A5A5060FB460C75D1879ED];for {set i 0} {$i < 1000000} {incr i} {set data [tls::decrypt -cipher SM4 -padding 0 \
		 -key [binary decode hex FEDCBA98765432100123456789ABCDEF] \
		 -data $data]};set data]} \
	-match exact -result 000102030405060708090a0b0c0d0e0f

# Cleanup
::tcltest::cleanupTests
return








Added tests/test_vectors/Symetric_Block/SM4.txt version [a892501bc8].



























1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

# SM4 cipher from: https://datatracker.ietf.org/doc/html/draft-ribose-cfrg-sm4-10

# A.1.  Example 1 (GB/T 32907-2016 Example 1)
Plaintext = 0123456789ABCDEFFEDCBA9876543210
Key = 0123456789ABCDEFFEDCBA9876543210
Ciphertext = 681EDF34D206965E86B3E94F536E4246

# A.1.3.  Example 3 (GB/T 32907-2016 Example 2 Encryption)
Plaintext = 0123456789ABCDEFFEDCBA9876543210
Key = 0123456789ABCDEFFEDCBA9876543210
Iterations = 1000000
Ciphertext = 595298C7C6FD271F0402F804C33D3F66

# A.1.4.  Example 4
Plaintext = 000102030405060708090A0B0C0D0E0F
Key = FEDCBA98765432100123456789ABCDEF
Ciphertext = F766678F13F01ADEAC1B3EA955ADB594

# A.1.6.  Example 6
Plaintext = 000102030405060708090A0B0C0D0E0F
Key = FEDCBA98765432100123456789ABCDEF
Iterations = 1000000
Ciphertext = 379A96D0A6A5A5060FB460C75D1879ED








Modified tests/test_vectors/Symetric_Block/make_test.tcl
from [79b8785f12]
to [b4dbcd9fd1].




︙


16
17
18
19
20
21
22
23

24
25
26
27
28
29
30

16
17
18
19
20
21
22

23
24
25
26
27
28
29
30








-
+








    return $data
}

#
# Create test case and output to test file
#
proc do_test {group cipher test_num tc params fn} {
    array set config [list repeat 1]
    array set config [list iterations 1 repeat 1]
    array set config $params

    # Test info
    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]]




︙


42
43
44
45
46
47
48

49




50
51
52
53
54
55
56

42
43
44
45
46
47
48
49

50
51
52
53
54
55
56
57
58
59
60








+
-
+
+
+
+









    # Add test parameters
    foreach {param names type} [list -key [list key] s -iv [list iv nonce] s -data $list1 s] {
	foreach name $names {
	    if {[info exists config($name)]} {
		set data [get_value $type $config($name)]
		if {$data ne ""} {
		    if {$param ne "-data" || $config(iterations) == 1} {
		    append cmd " " $param " " $data " \\\n\t\t"
			append cmd " " $param " " $data " \\\n\t\t"
		    } else {
			set cmd [string cat "set data " $data ";for \{set i 0\} \{\$i < " $config(iterations) "\} \{incr i\} \{set data \[" $cmd " " $param " \$data\]\};set data"]
		    }
		}
		break
	    }
	}
    }
    append line [format {-body {binary encode hex [%s]}} [string trimright $cmd " \\\n\t"]]
    append line " \\\n\t"




︙


154
155
156
157
158
159
160
161

162
163
164
165
166
167
168
169

158
159
160
161
162
163
164

165
166
167
168
169
170
171
172
173








-
+









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

	set cipher [file rootname [file tail $filename]]
	set cipher [string trim [file rootname [file tail $filename]]]
	set id [format "%s_%s" $group $cipher]
	set test_num [incr test_ids($id)]
	parse $id $filename $test_num $cipher
    }
}

main [pwd]
exit

















Powered by Fossil · RSS