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];
23 SilcMessageSignedPayload sig;
25 if (argc > 1 && !strcmp(argv[1], "-d")) {
27 silc_log_debug_hexdump(TRUE);
28 silc_log_set_debug_string("*message*");
31 silc_cipher_register_default();
32 silc_hash_register_default();
33 silc_hmac_register_default();
34 silc_pkcs_register_default();
36 SILC_LOG_DEBUG(("Load keypair"));
37 if (!silc_load_key_pair("pubkey.pub", "privkey.prv", "",
38 &public_key, &private_key)) {
39 SILC_LOG_DEBUG(("Create keypair"));
40 if (!silc_create_key_pair("rsa", 2048, "pubkey.pub", "privkey.prv",
41 NULL, "", &public_key, &private_key, FALSE))
45 SILC_LOG_DEBUG(("Alloc RNG"));
46 rng = silc_rng_alloc();
49 SILC_LOG_DEBUG(("Alloc AES"));
50 if (!silc_cipher_alloc("aes-128-cbc", &key))
53 SILC_LOG_DEBUG(("Alloc SHA-256"));
54 if (!silc_hash_alloc("sha256", &hash))
57 SILC_LOG_DEBUG(("Alloc HMAC"));
58 if (!silc_hmac_alloc("hmac-sha256-96", hash, &hmac))
61 SILC_LOG_DEBUG(("Set static key: '1234567890123456'"));
62 if (!silc_cipher_set_key(key, "1234567890123456", 16 * 8))
64 SILC_LOG_DEBUG(("Set HMAC key: '1234567890123456'"));
65 silc_hmac_set_key(hmac, "1234567890123456", 16);
67 /* Simple private message */
68 SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
70 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
71 SILC_MESSAGE_FLAG_UTF8 |
72 SILC_MESSAGE_FLAG_ACK,
73 msg, strlen(msg), TRUE, TRUE,
74 key, hmac, rng, NULL, NULL, NULL, NULL);
77 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
78 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
79 message = silc_message_payload_parse(silc_buffer_data(buf),
80 silc_buffer_len(buf), TRUE, TRUE,
84 flags = silc_message_get_flags(message);
85 SILC_LOG_DEBUG(("Flags: %x", flags));
86 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
88 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
90 if (!(flags & SILC_MESSAGE_FLAG_ACK))
92 data = silc_message_get_data(message, &data_len);
93 SILC_LOG_HEXDUMP(("Data"), data, data_len);
94 if (data_len != strlen(msg) || memcmp(data, msg, strlen(msg)))
96 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
98 silc_message_payload_free(message);
100 /* Simple private message */
101 SILC_LOG_DEBUG(("Encoding private message len %d (static key)", 10));
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,
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 != 10 || memcmp(data, msg, 10))
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 */
133 SILC_LOG_DEBUG(("Encoding private message len %d (static key)", 1));
134 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
135 SILC_MESSAGE_FLAG_UTF8 |
136 SILC_MESSAGE_FLAG_ACK,
138 key, hmac, rng, NULL, NULL, NULL, buf);
141 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
142 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
143 message = silc_message_payload_parse(silc_buffer_data(buf),
144 silc_buffer_len(buf), TRUE, TRUE,
148 flags = silc_message_get_flags(message);
149 SILC_LOG_DEBUG(("Flags: %x", flags));
150 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
152 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
154 if (!(flags & SILC_MESSAGE_FLAG_ACK))
156 data = silc_message_get_data(message, &data_len);
157 SILC_LOG_HEXDUMP(("Data"), data, data_len);
158 if (data_len != 1 || memcmp(data, msg, 1))
160 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
161 silc_hmac_len(hmac));
162 silc_message_payload_free(message);
164 /* Simple private message */
165 for (i = 0; i < sizeof(tmp); i++)
166 tmp[i] = (32 + i) & 127;
167 SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
169 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
170 SILC_MESSAGE_FLAG_UTF8 |
171 SILC_MESSAGE_FLAG_ACK,
172 tmp, sizeof(tmp), TRUE, TRUE,
173 key, hmac, rng, NULL, NULL, NULL, buf);
176 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
177 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
178 message = silc_message_payload_parse(silc_buffer_data(buf),
179 silc_buffer_len(buf), TRUE, TRUE,
183 flags = silc_message_get_flags(message);
184 SILC_LOG_DEBUG(("Flags: %x", flags));
185 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
187 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
189 if (!(flags & SILC_MESSAGE_FLAG_ACK))
191 data = silc_message_get_data(message, &data_len);
192 SILC_LOG_HEXDUMP(("Data"), data, data_len);
193 if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
195 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
196 silc_hmac_len(hmac));
197 silc_message_payload_free(message);
199 /* Digitally signed private message */
200 for (i = 0; i < sizeof(tmp); i++)
201 tmp[i] = (32 + i) & 127;
202 SILC_LOG_DEBUG(("Encoding private message len %d (static key) SIGNED",
204 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
205 SILC_MESSAGE_FLAG_UTF8 |
206 SILC_MESSAGE_FLAG_ACK |
207 SILC_MESSAGE_FLAG_SIGNED,
208 tmp, sizeof(tmp), TRUE, TRUE,
210 public_key, private_key, hash, buf);
213 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
214 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
215 message = silc_message_payload_parse(silc_buffer_data(buf),
216 silc_buffer_len(buf), TRUE, TRUE,
220 flags = silc_message_get_flags(message);
221 SILC_LOG_DEBUG(("Flags: %x", flags));
222 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
224 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
226 if (!(flags & SILC_MESSAGE_FLAG_ACK))
228 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
230 data = silc_message_get_data(message, &data_len);
231 SILC_LOG_HEXDUMP(("Data"), data, data_len);
232 if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
234 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
235 silc_hmac_len(hmac));
236 SILC_LOG_DEBUG(("Get signature"));
237 sig = silc_message_get_signature(message);
240 SILC_LOG_DEBUG(("Verifying signature"));
241 if (silc_message_signed_verify(sig, message, public_key, hash) !=
244 SILC_LOG_DEBUG(("Signature Ok"));
245 SILC_LOG_DEBUG(("Get public key"));
246 pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
249 SILC_LOG_DEBUG(("Verify public key"));
250 if (!silc_pkcs_public_key_compare(public_key, pk2))
252 SILC_LOG_DEBUG(("Public key Ok"));
253 silc_pkcs_public_key_free(pk2);
254 silc_message_payload_free(message);
256 /* Digitally signed channel message */
257 for (i = 0; i < sizeof(tmp) / 2; i++)
258 tmp[i] = (32 + i) & 127;
259 SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED",
261 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
262 SILC_MESSAGE_FLAG_UTF8 |
263 SILC_MESSAGE_FLAG_ACK |
264 SILC_MESSAGE_FLAG_SIGNED,
265 tmp, sizeof(tmp) / 2, TRUE, FALSE,
267 public_key, private_key, hash, buf);
270 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
271 SILC_LOG_DEBUG(("Parsing channel messsage (static key)"));
272 message = silc_message_payload_parse(silc_buffer_data(buf),
273 silc_buffer_len(buf), FALSE, TRUE,
277 flags = silc_message_get_flags(message);
278 SILC_LOG_DEBUG(("Flags: %x", flags));
279 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
281 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
283 if (!(flags & SILC_MESSAGE_FLAG_ACK))
285 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
287 data = silc_message_get_data(message, &data_len);
288 SILC_LOG_HEXDUMP(("Data"), data, data_len);
289 if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
291 SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
292 silc_hmac_len(hmac));
293 SILC_LOG_DEBUG(("Get signature"));
294 sig = silc_message_get_signature(message);
297 SILC_LOG_DEBUG(("Verifying signature"));
298 if (silc_message_signed_verify(sig, message, public_key, hash) !=
301 SILC_LOG_DEBUG(("Signature Ok"));
302 SILC_LOG_DEBUG(("Get public key"));
303 pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
306 SILC_LOG_DEBUG(("Verify public key"));
307 if (!silc_pkcs_public_key_compare(public_key, pk2))
309 SILC_LOG_DEBUG(("Public key Ok"));
310 silc_pkcs_public_key_free(pk2);
311 silc_message_payload_free(message);
313 /* Digitally signed private message (no encryption) */
314 for (i = 0; i < sizeof(tmp) / 2; i++)
315 tmp[i] = (32 + i) & 127;
316 SILC_LOG_DEBUG(("Encoding private message len %d SIGNED",
318 buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
319 SILC_MESSAGE_FLAG_UTF8 |
320 SILC_MESSAGE_FLAG_ACK |
321 SILC_MESSAGE_FLAG_SIGNED,
322 tmp, sizeof(tmp) / 2, FALSE, TRUE,
324 public_key, private_key, hash, buf);
327 SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
328 SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
329 message = silc_message_payload_parse(silc_buffer_data(buf),
330 silc_buffer_len(buf), TRUE, FALSE,
334 flags = silc_message_get_flags(message);
335 SILC_LOG_DEBUG(("Flags: %x", flags));
336 if (!(flags & SILC_MESSAGE_FLAG_ACTION))
338 if (!(flags & SILC_MESSAGE_FLAG_UTF8))
340 if (!(flags & SILC_MESSAGE_FLAG_ACK))
342 if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
344 data = silc_message_get_data(message, &data_len);
345 SILC_LOG_HEXDUMP(("Data"), data, data_len);
346 if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
348 SILC_LOG_DEBUG(("Get signature"));
349 sig = silc_message_get_signature(message);
352 SILC_LOG_DEBUG(("Verifying signature"));
353 if (silc_message_signed_verify(sig, message, public_key, hash) !=
356 SILC_LOG_DEBUG(("Signature Ok"));
357 SILC_LOG_DEBUG(("Get public key"));
358 pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
361 SILC_LOG_DEBUG(("Verify public key"));
362 if (!silc_pkcs_public_key_compare(public_key, pk2))
364 SILC_LOG_DEBUG(("Public key Ok"));
365 silc_pkcs_public_key_free(pk2);
366 silc_message_payload_free(message);
370 SILC_LOG_DEBUG(("Cleanup"));
371 silc_pkcs_public_key_free(public_key);
372 silc_pkcs_private_key_free(private_key);
373 silc_cipher_free(key);
374 silc_hash_free(hash);
378 silc_cipher_unregister_all();
379 silc_hash_unregister_all();
380 silc_hmac_unregister_all();
381 silc_pkcs_unregister_all();
383 SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
384 fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");