TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / c7ea99af4f62690cb7f5af05d92b8af24e097db4 / . / tests / suites / test_suite_blowfish.function
blob: 673b88c18d272bedc3e54cf0548dbe85a58cff32 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]1/* BEGIN_HEADER */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]2#include "polarssl/blowfish.h"
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]3/* END_HEADER */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]4
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]5/* BEGIN_DEPENDENCIES
6 * depends_on:POLARSSL_BLOWFISH_C
7 * END_DEPENDENCIES
8 */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]9
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]10/* BEGIN_CASE */
11void blowfish_encrypt_ecb( char *hex_key_string, char *hex_src_string,
12 char *hex_dst_string, int setkey_result )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]13{
14 unsigned char key_str[100];
15 unsigned char src_str[100];
16 unsigned char dst_str[100];
17 unsigned char output[100];
18 blowfish_context ctx;
19 int key_len;
20
21 memset(key_str, 0x00, 100);
22 memset(src_str, 0x00, 100);
23 memset(dst_str, 0x00, 100);
24 memset(output, 0x00, 100);
25
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]26 key_len = unhexify( key_str, hex_key_string );
27 unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]28
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]29 TEST_ASSERT( blowfish_setkey( &ctx, key_str, key_len * 8 ) == setkey_result );
30 if( setkey_result == 0 )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]31 {
32 TEST_ASSERT( blowfish_crypt_ecb( &ctx, BLOWFISH_ENCRYPT, src_str, output ) == 0 );
33 hexify( dst_str, output, 8 );
34
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]35 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]36 }
37}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]38/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]39
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]40/* BEGIN_CASE */
41void blowfish_decrypt_ecb( char *hex_key_string, char *hex_src_string,
42 char *hex_dst_string, int setkey_result )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]43{
44 unsigned char key_str[100];
45 unsigned char src_str[100];
46 unsigned char dst_str[100];
47 unsigned char output[100];
48 blowfish_context ctx;
49 int key_len;
50
51 memset(key_str, 0x00, 100);
52 memset(src_str, 0x00, 100);
53 memset(dst_str, 0x00, 100);
54 memset(output, 0x00, 100);
55
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]56 key_len = unhexify( key_str, hex_key_string );
57 unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]58
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]59 TEST_ASSERT( blowfish_setkey( &ctx, key_str, key_len * 8 ) == setkey_result );
60 if( setkey_result == 0 )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]61 {
62 TEST_ASSERT( blowfish_crypt_ecb( &ctx, BLOWFISH_DECRYPT, src_str, output ) == 0 );
63 hexify( dst_str, output, 8 );
64
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]65 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]66 }
67}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]68/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]69
Manuel Pégourié-Gonnard92cb1d32013-09-13 16:24:20 +0200[diff] [blame]70/* BEGIN_CASE depends_on:POLARSSL_CIPHER_MODE_CBC */
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]71void blowfish_encrypt_cbc( char *hex_key_string, char *hex_iv_string,
72 char *hex_src_string, char *hex_dst_string,
73 int cbc_result )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]74{
75 unsigned char key_str[100];
76 unsigned char iv_str[100];
77 unsigned char src_str[100];
78 unsigned char dst_str[100];
79 unsigned char output[100];
80 blowfish_context ctx;
81 int key_len, data_len;
82
83 memset(key_str, 0x00, 100);
84 memset(iv_str, 0x00, 100);
85 memset(src_str, 0x00, 100);
86 memset(dst_str, 0x00, 100);
87 memset(output, 0x00, 100);
88
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]89 key_len = unhexify( key_str, hex_key_string );
90 unhexify( iv_str, hex_iv_string );
91 data_len = unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]92
93 blowfish_setkey( &ctx, key_str, key_len * 8 );
94
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]95 TEST_ASSERT( blowfish_crypt_cbc( &ctx, BLOWFISH_ENCRYPT, data_len , iv_str, src_str, output ) == cbc_result );
96 if( cbc_result == 0 )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]97 {
98 hexify( dst_str, output, data_len );
99
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]100 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]101 }
102}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]103/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]104
Manuel Pégourié-Gonnard92cb1d32013-09-13 16:24:20 +0200[diff] [blame]105/* BEGIN_CASE depends_on:POLARSSL_CIPHER_MODE_CBC */
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]106void blowfish_decrypt_cbc( char *hex_key_string, char *hex_iv_string,
107 char *hex_src_string, char *hex_dst_string,
108 int cbc_result )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]109{
110 unsigned char key_str[100];
111 unsigned char iv_str[100];
112 unsigned char src_str[100];
113 unsigned char dst_str[100];
114 unsigned char output[100];
115 blowfish_context ctx;
116 int key_len, data_len;
117
118 memset(key_str, 0x00, 100);
119 memset(iv_str, 0x00, 100);
120 memset(src_str, 0x00, 100);
121 memset(dst_str, 0x00, 100);
122 memset(output, 0x00, 100);
123
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]124 key_len = unhexify( key_str, hex_key_string );
125 unhexify( iv_str, hex_iv_string );
126 data_len = unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]127
128 blowfish_setkey( &ctx, key_str, key_len * 8 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]129 TEST_ASSERT( blowfish_crypt_cbc( &ctx, BLOWFISH_DECRYPT, data_len , iv_str, src_str, output ) == cbc_result );
130 if( cbc_result == 0)
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]131 {
132 hexify( dst_str, output, data_len );
133
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]134 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]135 }
136}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]137/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]138
Manuel Pégourié-Gonnard29dcc0b2014-03-10 11:32:07 +0100[diff] [blame]139/* BEGIN_CASE depends_on:POLARSSL_CIPHER_MODE_CFB */
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]140void blowfish_encrypt_cfb64( char *hex_key_string, char *hex_iv_string,
141 char *hex_src_string, char *hex_dst_string )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]142{
143 unsigned char key_str[100];
144 unsigned char iv_str[100];
145 unsigned char src_str[100];
146 unsigned char dst_str[100];
147 unsigned char output[100];
148 blowfish_context ctx;
149 size_t iv_offset = 0;
150 int key_len, src_len;
151
152 memset(key_str, 0x00, 100);
153 memset(iv_str, 0x00, 100);
154 memset(src_str, 0x00, 100);
155 memset(dst_str, 0x00, 100);
156 memset(output, 0x00, 100);
157
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]158 key_len = unhexify( key_str, hex_key_string );
159 unhexify( iv_str, hex_iv_string );
160 src_len = unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]161
162 blowfish_setkey( &ctx, key_str, key_len * 8 );
163 TEST_ASSERT( blowfish_crypt_cfb64( &ctx, BLOWFISH_ENCRYPT, src_len, &iv_offset, iv_str, src_str, output ) == 0 );
164 hexify( dst_str, output, src_len );
165
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]166 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]167}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]168/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]169
Manuel Pégourié-Gonnard29dcc0b2014-03-10 11:32:07 +0100[diff] [blame]170/* BEGIN_CASE depends_on:POLARSSL_CIPHER_MODE_CFB */
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]171void blowfish_decrypt_cfb64( char *hex_key_string, char *hex_iv_string,
172 char *hex_src_string, char *hex_dst_string )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]173{
174 unsigned char key_str[100];
175 unsigned char iv_str[100];
176 unsigned char src_str[100];
177 unsigned char dst_str[100];
178 unsigned char output[100];
179 blowfish_context ctx;
180 size_t iv_offset = 0;
181 int key_len, src_len;
182
183 memset(key_str, 0x00, 100);
184 memset(iv_str, 0x00, 100);
185 memset(src_str, 0x00, 100);
186 memset(dst_str, 0x00, 100);
187 memset(output, 0x00, 100);
188
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]189 key_len = unhexify( key_str, hex_key_string );
190 unhexify( iv_str, hex_iv_string );
191 src_len = unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]192
193 blowfish_setkey( &ctx, key_str, key_len * 8 );
194 TEST_ASSERT( blowfish_crypt_cfb64( &ctx, BLOWFISH_DECRYPT, src_len, &iv_offset, iv_str, src_str, output ) == 0 );
195 hexify( dst_str, output, src_len );
196
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]197 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]198}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]199/* END_CASE */
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]200
Manuel Pégourié-Gonnard29dcc0b2014-03-10 11:32:07 +0100[diff] [blame]201/* BEGIN_CASE depends_on:POLARSSL_CIPHER_MODE_CTR */
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]202void blowfish_encrypt_ctr( char *hex_key_string, char *hex_iv_string,
203 char *hex_src_string, char *hex_dst_string )
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]204{
205 unsigned char key_str[100];
206 unsigned char iv_str[100];
207 unsigned char stream_str[100];
208 unsigned char src_str[100];
209 unsigned char dst_str[100];
210 unsigned char output[100];
211 blowfish_context ctx;
212 size_t iv_offset = 0;
213 int key_len, src_len;
214
215 memset(key_str, 0x00, 100);
216 memset(iv_str, 0x00, 100);
217 memset(stream_str, 0x00, 100);
218 memset(src_str, 0x00, 100);
219 memset(dst_str, 0x00, 100);
220 memset(output, 0x00, 100);
221
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]222 key_len = unhexify( key_str, hex_key_string );
223 unhexify( iv_str, hex_iv_string );
224 src_len = unhexify( src_str, hex_src_string );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]225
226 blowfish_setkey( &ctx, key_str, key_len * 8 );
227 TEST_ASSERT( blowfish_crypt_ctr( &ctx, src_len, &iv_offset, iv_str, stream_str, src_str, output ) == 0 );
228 hexify( dst_str, output, src_len );
229
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]230 TEST_ASSERT( strcmp( (char *) dst_str, hex_dst_string ) == 0 );
Paul Bakkera9379c02012-07-04 11:02:11 +0000[diff] [blame]231}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]232/* END_CASE */