1 /* SILC Message Payload tests */
4 #include "silcapputil.h"
6 SilcPublicKey public_key, pk2;
7 SilcPrivateKey private_key;
13 int main(int argc, char **argv)
15 SilcBool success = FALSE;
16 SilcMessagePayload message;
18 const char *msg = "FOOBAR MESSAGE";
19 unsigned char *data, tmp[1023], *tmp2;
24 if (argc > 1 && !strcmp(argv[1], "-d")) {
26 silc_log_debug_hexdump(TRUE);
27 silc_log_set_debug_string("*message*");
30 silc_cipher_register_default();
31 silc_hash_register_default();
32 silc_hmac_register_default();
33 silc_pkcs_register_default();
35 SILC_LOG_DEBUG(("Load keypair"));
36 if (!silc_load_key_pair("pubkey.pub", "privkey.prv", "",
37 &public_key, &private_key)) {
38 SILC_LOG_DEBUG(("Create keypair"));
39 if (!silc_create_key_pair("rsa", 2048, "pubkey.pub", "privkey.prv",
40 NULL, "", &public_key, &private_key, FALSE))
44 SILC_LOG_DEBUG(("Alloc RNG"));
45 rng = silc_rng_alloc();
48 SILC_LOG_DEBUG(("Alloc AES"));
49 if (!silc_cipher_alloc("aes-128-cbc", &key))
52 SILC_LOG_DEBUG(("Alloc SHA-256"));
53 if (!silc_hash_alloc("sha256", &hash))
56 SILC_LOG_DEBUG(("Alloc HMAC"));
57 if (!silc_hmac_alloc("hmac-sha256-96", hash, &hmac))
60 SILC_LOG_DEBUG(("Set static key: '1234567890123456'"));
61 if (!silc_cipher_set_key(key, "1234567890123456", 16 * 8))
63 SILC_LOG_DEBUG(("Set HMAC key: '1234567890123456'"));
64 silc_hmac_set_key(hmac, "1234567890123456", 16);
66 /* Simple private message */
67 SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
69 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
70 SILC_MESSAGE_FLAG_UTF8 |
71 SILC_MESSAGE_FLAG_ACK,
72 msg, strlen(msg), TRUE, TRUE,
73 key, hmac, rng, NULL, NULL, NULL, NULL);
76 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
77 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
78 message = silc_message_payload_parse(silc_buffer_data(buf),
79 silc_buffer_len(buf), TRUE, TRUE,
80 key, hmac, NULL, FALSE, NULL);
83 flags = silc_message_get_flags(message);
84 SILC_LOG_DEBUG(("Flags: %x", flags));
85 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
87 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
89 if (!(flags & SILC_MESSAGE_FLAG_ACK))
91 data = silc_message_get_data(message, &data_len);
92 SILC_LOG_HEXDUMP(("Data"), data, data_len);
93 if (data_len != strlen(msg) || memcmp(data, msg, strlen(msg)))
95 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
97 silc_message_payload_free(message);
99 /* Simple private message */
101 SILC_LOG_DEBUG(("Encoding private message len %d (static key)", n));
102 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
103 SILC_MESSAGE_FLAG_UTF8 |
104 SILC_MESSAGE_FLAG_ACK,
106 key, hmac, rng, NULL, NULL, NULL, buf);
109 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
110 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
111 message = silc_message_payload_parse(silc_buffer_data(buf),
112 silc_buffer_len(buf), TRUE, TRUE,
113 key, hmac, NULL, FALSE, NULL);
116 flags = silc_message_get_flags(message);
117 SILC_LOG_DEBUG(("Flags: %x", flags));
118 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
120 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
122 if (!(flags & SILC_MESSAGE_FLAG_ACK))
124 data = silc_message_get_data(message, &data_len);
125 SILC_LOG_HEXDUMP(("Data"), data, data_len);
126 if (data_len != n || memcmp(data, msg, n))
128 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
129 silc_hmac_len(hmac));
130 silc_message_payload_free(message);
132 /* Simple private message */
134 SILC_LOG_DEBUG(("Encoding private message len %d (static key)", n));
135 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
136 SILC_MESSAGE_FLAG_UTF8 |
137 SILC_MESSAGE_FLAG_ACK,
139 key, hmac, rng, NULL, NULL, NULL, buf);
142 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
143 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
144 message = silc_message_payload_parse(silc_buffer_data(buf),
145 silc_buffer_len(buf), TRUE, TRUE,
146 key, hmac, NULL, FALSE, NULL);
149 flags = silc_message_get_flags(message);
150 SILC_LOG_DEBUG(("Flags: %x", flags));
151 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
153 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
155 if (!(flags & SILC_MESSAGE_FLAG_ACK))
157 data = silc_message_get_data(message, &data_len);
158 SILC_LOG_HEXDUMP(("Data"), data, data_len);
159 if (data_len != n || memcmp(data, msg, n))
161 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
162 silc_hmac_len(hmac));
163 silc_message_payload_free(message);
165 /* Simple private message */
166 for (i = 0; i < sizeof(tmp); i++)
167 tmp[i] = (32 + i) & 127;
168 SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
170 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
171 SILC_MESSAGE_FLAG_UTF8 |
172 SILC_MESSAGE_FLAG_ACK,
173 tmp, sizeof(tmp), TRUE, TRUE,
174 key, hmac, rng, NULL, NULL, NULL, buf);
177 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
178 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
179 message = silc_message_payload_parse(silc_buffer_data(buf),
180 silc_buffer_len(buf), TRUE, TRUE,
181 key, hmac, NULL, FALSE, NULL);
184 flags = silc_message_get_flags(message);
185 SILC_LOG_DEBUG(("Flags: %x", flags));
186 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
188 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
190 if (!(flags & SILC_MESSAGE_FLAG_ACK))
192 data = silc_message_get_data(message, &data_len);
193 SILC_LOG_HEXDUMP(("Data"), data, data_len);
194 if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
196 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
197 silc_hmac_len(hmac));
198 silc_message_payload_free(message);
200 /* Digitally signed private message */
201 for (i = 0; i < sizeof(tmp); i++)
202 tmp[i] = (32 + i) & 127;
203 SILC_LOG_DEBUG(("Encoding private message len %d (static key) SIGNED",
205 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
206 SILC_MESSAGE_FLAG_UTF8 |
207 SILC_MESSAGE_FLAG_ACK |
208 SILC_MESSAGE_FLAG_SIGNED,
209 tmp, sizeof(tmp), TRUE, TRUE,
211 public_key, private_key, hash, buf);
214 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
215 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
216 message = silc_message_payload_parse(silc_buffer_data(buf),
217 silc_buffer_len(buf), TRUE, TRUE,
218 key, hmac, NULL, FALSE, NULL);
221 flags = silc_message_get_flags(message);
222 SILC_LOG_DEBUG(("Flags: %x", flags));
223 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
225 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
227 if (!(flags & SILC_MESSAGE_FLAG_ACK))
229 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
231 data = silc_message_get_data(message, &data_len);
232 SILC_LOG_HEXDUMP(("Data"), data, data_len);
233 if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
235 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
236 silc_hmac_len(hmac));
237 SILC_LOG_DEBUG(("Verifying signature"));
238 if (silc_message_signed_verify(message, public_key, hash) !=
241 SILC_LOG_DEBUG(("Signature Ok"));
242 SILC_LOG_DEBUG(("Get public key"));
243 pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
246 SILC_LOG_DEBUG(("Verify public key"));
247 if (!silc_pkcs_public_key_compare(public_key, pk2))
249 SILC_LOG_DEBUG(("Public key Ok"));
250 silc_pkcs_public_key_free(pk2);
251 silc_message_payload_free(message);
253 /* Digitally signed channel message */
254 for (i = 0; i < sizeof(tmp) / 2; i++)
255 tmp[i] = (32 + i) & 127;
256 SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED",
258 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
259 SILC_MESSAGE_FLAG_UTF8 |
260 SILC_MESSAGE_FLAG_ACK |
261 SILC_MESSAGE_FLAG_SIGNED,
262 tmp, sizeof(tmp) / 2, TRUE, FALSE,
264 public_key, private_key, hash, buf);
267 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
268 SILC_LOG_DEBUG(("Parsing channel messsage (static key)"));
269 message = silc_message_payload_parse(silc_buffer_data(buf),
270 silc_buffer_len(buf), FALSE, TRUE,
271 key, hmac, NULL, FALSE, NULL);
274 flags = silc_message_get_flags(message);
275 SILC_LOG_DEBUG(("Flags: %x", flags));
276 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
278 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
280 if (!(flags & SILC_MESSAGE_FLAG_ACK))
282 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
284 data = silc_message_get_data(message, &data_len);
285 SILC_LOG_HEXDUMP(("Data"), data, data_len);
286 if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
288 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
289 silc_hmac_len(hmac));
290 SILC_LOG_DEBUG(("Verifying signature"));
291 if (silc_message_signed_verify(message, public_key, hash) !=
294 SILC_LOG_DEBUG(("Signature Ok"));
295 SILC_LOG_DEBUG(("Get public key"));
296 pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
299 SILC_LOG_DEBUG(("Verify public key"));
300 if (!silc_pkcs_public_key_compare(public_key, pk2))
302 SILC_LOG_DEBUG(("Public key Ok"));
303 silc_pkcs_public_key_free(pk2);
304 silc_message_payload_free(message);
306 /* Digitally signed private message (no encryption) */
307 for (i = 0; i < sizeof(tmp) / 2; i++)
308 tmp[i] = (32 + i) & 127;
309 SILC_LOG_DEBUG(("Encoding private message len %d SIGNED",
311 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
312 SILC_MESSAGE_FLAG_UTF8 |
313 SILC_MESSAGE_FLAG_ACK |
314 SILC_MESSAGE_FLAG_SIGNED,
315 tmp, sizeof(tmp) / 2, FALSE, TRUE,
317 public_key, private_key, hash, buf);
320 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
321 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
322 message = silc_message_payload_parse(silc_buffer_data(buf),
323 silc_buffer_len(buf), TRUE, FALSE,
324 NULL, NULL, NULL, FALSE, NULL);
327 flags = silc_message_get_flags(message);
328 SILC_LOG_DEBUG(("Flags: %x", flags));
329 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
331 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
333 if (!(flags & SILC_MESSAGE_FLAG_ACK))
335 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
337 data = silc_message_get_data(message, &data_len);
338 SILC_LOG_HEXDUMP(("Data"), data, data_len);
339 if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
341 SILC_LOG_DEBUG(("Verifying signature"));
342 if (silc_message_signed_verify(message, public_key, hash) !=
345 SILC_LOG_DEBUG(("Signature Ok"));
346 SILC_LOG_DEBUG(("Get public key"));
347 pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
350 SILC_LOG_DEBUG(("Verify public key"));
351 if (!silc_pkcs_public_key_compare(public_key, pk2))
353 SILC_LOG_DEBUG(("Public key Ok"));
354 silc_pkcs_public_key_free(pk2);
355 silc_message_payload_free(message);
357 /* Digitally signed channel message (LARGE) */
359 tmp2 = silc_malloc(n);
362 SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED LARGE",
364 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
365 SILC_MESSAGE_FLAG_UTF8 |
366 SILC_MESSAGE_FLAG_ACK |
367 SILC_MESSAGE_FLAG_SIGNED,
368 tmp2, n, TRUE, FALSE,
370 public_key, private_key, hash, buf);
373 SILC_LOG_DEBUG(("Message length: %d", silc_buffer_len(buf)));
374 if (silc_buffer_len(buf) > SILC_PACKET_MAX_LEN)
376 SILC_LOG_DEBUG(("Parsing channel messsage (static key)"));
377 message = silc_message_payload_parse(silc_buffer_data(buf),
378 silc_buffer_len(buf), FALSE, TRUE,
379 key, hmac, NULL, FALSE, NULL);
382 flags = silc_message_get_flags(message);
383 SILC_LOG_DEBUG(("Flags: %x", flags));
384 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
386 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
388 if (!(flags & SILC_MESSAGE_FLAG_ACK))
390 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
392 data = silc_message_get_data(message, &data_len);
393 SILC_LOG_DEBUG(("Data len: %d", data_len));
394 if (silc_buffer_len(buf) > SILC_PACKET_MAX_LEN)
396 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
397 silc_hmac_len(hmac));
398 SILC_LOG_DEBUG(("Verifying signature"));
399 if (silc_message_signed_verify(message, public_key, hash) !=
402 SILC_LOG_DEBUG(("Signature Ok"));
403 SILC_LOG_DEBUG(("Get public key"));
404 pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
407 SILC_LOG_DEBUG(("Verify public key"));
408 if (!silc_pkcs_public_key_compare(public_key, pk2))
410 SILC_LOG_DEBUG(("Public key Ok"));
411 silc_pkcs_public_key_free(pk2);
412 silc_message_payload_free(message);
417 SILC_LOG_DEBUG(("Cleanup"));
418 silc_pkcs_public_key_free(public_key);
419 silc_pkcs_private_key_free(private_key);
420 silc_cipher_free(key);
421 silc_hash_free(hash);
425 silc_cipher_unregister_all();
426 silc_hash_unregister_all();
427 silc_hmac_unregister_all();
428 silc_pkcs_unregister_all();
430 SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
431 fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");