lib/silccore/tests/test_silcmessage.c

   1 /* SILC Message Payload tests */
   2
   3 #include "silc.h"
   4 #include "silcapputil.h"
   5
   6 SilcPublicKey public_key, pk2;
   7 SilcPrivateKey private_key;
   8 SilcCipher key;
   9 SilcHash hash;
  10 SilcHmac hmac;
  11 SilcRng rng;
  12
  13 int main(int argc, char **argv)
  14 {
  15   SilcBool success = FALSE;
  16   SilcMessagePayload message;
  17   SilcBuffer buf;
  18   const char *msg = "FOOBAR MESSAGE";
  19   unsigned char *data, tmp[1023];
  20   SilcUInt32 data_len;
  21   SilcUInt16 flags;
  22   int i;
  23   SilcMessageSignedPayload sig;
  24
  25   if (argc > 1 && !strcmp(argv[1], "-d")) {
  26     silc_log_debug(TRUE);
  27     silc_log_debug_hexdump(TRUE);
  28     silc_log_set_debug_string("*message*");
  29   }
  30
  31   silc_cipher_register_default();
  32   silc_hash_register_default();
  33   silc_hmac_register_default();
  34   silc_pkcs_register_default();
  35
  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))
  42       goto err;
  43   }
  44
  45   SILC_LOG_DEBUG(("Alloc RNG"));
  46   rng = silc_rng_alloc();
  47   silc_rng_init(rng);
  48
  49   SILC_LOG_DEBUG(("Alloc AES"));
  50   if (!silc_cipher_alloc("aes-128-cbc", &key))
  51     goto err;
  52
  53   SILC_LOG_DEBUG(("Alloc SHA-256"));
  54   if (!silc_hash_alloc("sha256", &hash))
  55     goto err;
  56
  57   SILC_LOG_DEBUG(("Alloc HMAC"));
  58   if (!silc_hmac_alloc("hmac-sha256-96", hash, &hmac))
  59     goto err;
  60
  61   SILC_LOG_DEBUG(("Set static key: '1234567890123456'"));
  62   if (!silc_cipher_set_key(key, "1234567890123456", 16 * 8))
  63     goto err;
  64   SILC_LOG_DEBUG(("Set HMAC key: '1234567890123456'"));
  65   silc_hmac_set_key(hmac, "1234567890123456", 16);
  66
  67   /* Simple private message */
  68   SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
  69                   strlen(msg)));
  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);
  75   if (!buf)
  76     goto err;
  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,
  81                                        key, hmac);
  82   if (!message)
  83     goto err;
  84   flags = silc_message_get_flags(message);
  85   SILC_LOG_DEBUG(("Flags: %x", flags));
  86   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
  87     goto err;
  88   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
  89     goto err;
  90   if (!(flags & SILC_MESSAGE_FLAG_ACK))
  91     goto err;
  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)))
  95     goto err;
  96   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
  97                    silc_hmac_len(hmac));
  98   silc_message_payload_free(message);
  99
 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,
 105                                     msg, 10, TRUE, TRUE,
 106                                     key, hmac, rng, NULL, NULL, NULL, buf);
 107   if (!buf)
 108     goto err;
 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);
 114   if (!message)
 115     goto err;
 116   flags = silc_message_get_flags(message);
 117   SILC_LOG_DEBUG(("Flags: %x", flags));
 118   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 119     goto err;
 120   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 121     goto err;
 122   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 123     goto err;
 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))
 127     goto err;
 128   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
 129                    silc_hmac_len(hmac));
 130   silc_message_payload_free(message);
 131
 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,
 137                                     msg, 1, TRUE, TRUE,
 138                                     key, hmac, rng, NULL, NULL, NULL, buf);
 139   if (!buf)
 140     goto err;
 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,
 145                                        key, hmac);
 146   if (!message)
 147     goto err;
 148   flags = silc_message_get_flags(message);
 149   SILC_LOG_DEBUG(("Flags: %x", flags));
 150   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 151     goto err;
 152   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 153     goto err;
 154   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 155     goto err;
 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))
 159     goto err;
 160   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
 161                    silc_hmac_len(hmac));
 162   silc_message_payload_free(message);
 163
 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)",
 168                   sizeof(tmp)));
 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);
 174   if (!buf)
 175     goto err;
 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,
 180                                        key, hmac);
 181   if (!message)
 182     goto err;
 183   flags = silc_message_get_flags(message);
 184   SILC_LOG_DEBUG(("Flags: %x", flags));
 185   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 186     goto err;
 187   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 188     goto err;
 189   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 190     goto err;
 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)))
 194     goto err;
 195   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
 196                    silc_hmac_len(hmac));
 197   silc_message_payload_free(message);
 198
 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",
 203                   sizeof(tmp)));
 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,
 209                                     key, hmac, rng,
 210                                     public_key, private_key, hash, buf);
 211   if (!buf)
 212     goto err;
 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,
 217                                        key, hmac);
 218   if (!message)
 219     goto err;
 220   flags = silc_message_get_flags(message);
 221   SILC_LOG_DEBUG(("Flags: %x", flags));
 222   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 223     goto err;
 224   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 225     goto err;
 226   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 227     goto err;
 228   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 229     goto err;
 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)))
 233     goto err;
 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);
 238   if (!sig)
 239     goto err;
 240   SILC_LOG_DEBUG(("Verifying signature"));
 241   if (silc_message_signed_verify(sig, message, public_key, hash) !=
 242       SILC_AUTH_OK)
 243     goto err;
 244   SILC_LOG_DEBUG(("Signature Ok"));
 245   SILC_LOG_DEBUG(("Get public key"));
 246   pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
 247   if (!pk2)
 248     goto err;
 249   SILC_LOG_DEBUG(("Verify public key"));
 250   if (!silc_pkcs_public_key_compare(public_key, pk2))
 251     goto err;
 252   SILC_LOG_DEBUG(("Public key Ok"));
 253   silc_pkcs_public_key_free(pk2);
 254   silc_message_payload_free(message);
 255
 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",
 260                   sizeof(tmp) / 2));
 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,
 266                                     key, hmac, rng,
 267                                     public_key, private_key, hash, buf);
 268   if (!buf)
 269     goto err;
 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,
 274                                        key, hmac);
 275   if (!message)
 276     goto err;
 277   flags = silc_message_get_flags(message);
 278   SILC_LOG_DEBUG(("Flags: %x", flags));
 279   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 280     goto err;
 281   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 282     goto err;
 283   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 284     goto err;
 285   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 286     goto err;
 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))
 290     goto err;
 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);
 295   if (!sig)
 296     goto err;
 297   SILC_LOG_DEBUG(("Verifying signature"));
 298   if (silc_message_signed_verify(sig, message, public_key, hash) !=
 299       SILC_AUTH_OK)
 300     goto err;
 301   SILC_LOG_DEBUG(("Signature Ok"));
 302   SILC_LOG_DEBUG(("Get public key"));
 303   pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
 304   if (!pk2)
 305     goto err;
 306   SILC_LOG_DEBUG(("Verify public key"));
 307   if (!silc_pkcs_public_key_compare(public_key, pk2))
 308     goto err;
 309   SILC_LOG_DEBUG(("Public key Ok"));
 310   silc_pkcs_public_key_free(pk2);
 311   silc_message_payload_free(message);
 312
 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",
 317                   sizeof(tmp) / 2));
 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,
 323                                     NULL, NULL, rng,
 324                                     public_key, private_key, hash, buf);
 325   if (!buf)
 326     goto err;
 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,
 331                                        NULL, NULL);
 332   if (!message)
 333     goto err;
 334   flags = silc_message_get_flags(message);
 335   SILC_LOG_DEBUG(("Flags: %x", flags));
 336   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 337     goto err;
 338   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 339     goto err;
 340   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 341     goto err;
 342   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 343     goto err;
 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))
 347     goto err;
 348   SILC_LOG_DEBUG(("Get signature"));
 349   sig = silc_message_get_signature(message);
 350   if (!sig)
 351     goto err;
 352   SILC_LOG_DEBUG(("Verifying signature"));
 353   if (silc_message_signed_verify(sig, message, public_key, hash) !=
 354       SILC_AUTH_OK)
 355     goto err;
 356   SILC_LOG_DEBUG(("Signature Ok"));
 357   SILC_LOG_DEBUG(("Get public key"));
 358   pk2 = silc_message_signed_get_public_key(sig, NULL, NULL);
 359   if (!pk2)
 360     goto err;
 361   SILC_LOG_DEBUG(("Verify public key"));
 362   if (!silc_pkcs_public_key_compare(public_key, pk2))
 363     goto err;
 364   SILC_LOG_DEBUG(("Public key Ok"));
 365   silc_pkcs_public_key_free(pk2);
 366   silc_message_payload_free(message);
 367
 368
 369   success = TRUE;
 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);
 375   silc_rng_free(rng);
 376
 377  err:
 378   silc_cipher_unregister_all();
 379   silc_hash_unregister_all();
 380   silc_hmac_unregister_all();
 381   silc_pkcs_unregister_all();
 382
 383   SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
 384   fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
 385
 386   return success;
 387 }