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], *tmp2;
  20   SilcUInt32 data_len;
  21   SilcUInt16 flags;
  22   int i, n;
  23
  24   if (argc > 1 && !strcmp(argv[1], "-d")) {
  25     silc_log_debug(TRUE);
  26     silc_log_debug_hexdump(TRUE);
  27     silc_log_set_debug_string("*message*");
  28   }
  29
  30   silc_cipher_register_default();
  31   silc_hash_register_default();
  32   silc_hmac_register_default();
  33   silc_pkcs_register_default();
  34
  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))
  41       goto err;
  42   }
  43
  44   SILC_LOG_DEBUG(("Alloc RNG"));
  45   rng = silc_rng_alloc();
  46   silc_rng_init(rng);
  47
  48   SILC_LOG_DEBUG(("Alloc AES"));
  49   if (!silc_cipher_alloc("aes-128-cbc", &key))
  50     goto err;
  51
  52   SILC_LOG_DEBUG(("Alloc SHA-256"));
  53   if (!silc_hash_alloc("sha256", &hash))
  54     goto err;
  55
  56   SILC_LOG_DEBUG(("Alloc HMAC"));
  57   if (!silc_hmac_alloc("hmac-sha256-96", hash, &hmac))
  58     goto err;
  59
  60   SILC_LOG_DEBUG(("Set static key: '1234567890123456'"));
  61   if (!silc_cipher_set_key(key, "1234567890123456", 16 * 8))
  62     goto err;
  63   SILC_LOG_DEBUG(("Set HMAC key: '1234567890123456'"));
  64   silc_hmac_set_key(hmac, "1234567890123456", 16);
  65
  66   /* Simple private message */
  67   SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
  68                   strlen(msg)));
  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);
  74   if (!buf)
  75     goto err;
  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);
  81   if (!message)
  82     goto err;
  83   flags = silc_message_get_flags(message);
  84   SILC_LOG_DEBUG(("Flags: %x", flags));
  85   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
  86     goto err;
  87   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
  88     goto err;
  89   if (!(flags & SILC_MESSAGE_FLAG_ACK))
  90     goto err;
  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)))
  94     goto err;
  95   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
  96                    silc_hmac_len(hmac));
  97   silc_message_payload_free(message);
  98
  99   /* Simple private message */
 100   n = 10;
 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,
 105                                     msg, n, 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, NULL, FALSE, NULL);
 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 != n || memcmp(data, msg, n))
 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   n = 1;
 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,
 138                                     msg, n, TRUE, TRUE,
 139                                     key, hmac, rng, NULL, NULL, NULL, buf);
 140   if (!buf)
 141     goto err;
 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);
 147   if (!message)
 148     goto err;
 149   flags = silc_message_get_flags(message);
 150   SILC_LOG_DEBUG(("Flags: %x", flags));
 151   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 152     goto err;
 153   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 154     goto err;
 155   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 156     goto err;
 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))
 160     goto err;
 161   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
 162                    silc_hmac_len(hmac));
 163   silc_message_payload_free(message);
 164
 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)",
 169                   sizeof(tmp)));
 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);
 175   if (!buf)
 176     goto err;
 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);
 182   if (!message)
 183     goto err;
 184   flags = silc_message_get_flags(message);
 185   SILC_LOG_DEBUG(("Flags: %x", flags));
 186   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 187     goto err;
 188   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 189     goto err;
 190   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 191     goto err;
 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)))
 195     goto err;
 196   SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
 197                    silc_hmac_len(hmac));
 198   silc_message_payload_free(message);
 199
 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",
 204                   sizeof(tmp)));
 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,
 210                                     key, hmac, rng,
 211                                     public_key, private_key, hash, buf);
 212   if (!buf)
 213     goto err;
 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);
 219   if (!message)
 220     goto err;
 221   flags = silc_message_get_flags(message);
 222   SILC_LOG_DEBUG(("Flags: %x", flags));
 223   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 224     goto err;
 225   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 226     goto err;
 227   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 228     goto err;
 229   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 230     goto err;
 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)))
 234     goto err;
 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) !=
 239       SILC_AUTH_OK)
 240     goto err;
 241   SILC_LOG_DEBUG(("Signature Ok"));
 242   SILC_LOG_DEBUG(("Get public key"));
 243   pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
 244   if (!pk2)
 245     goto err;
 246   SILC_LOG_DEBUG(("Verify public key"));
 247   if (!silc_pkcs_public_key_compare(public_key, pk2))
 248     goto err;
 249   SILC_LOG_DEBUG(("Public key Ok"));
 250   silc_pkcs_public_key_free(pk2);
 251   silc_message_payload_free(message);
 252
 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",
 257                   sizeof(tmp) / 2));
 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,
 263                                     key, hmac, rng,
 264                                     public_key, private_key, hash, buf);
 265   if (!buf)
 266     goto err;
 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);
 272   if (!message)
 273     goto err;
 274   flags = silc_message_get_flags(message);
 275   SILC_LOG_DEBUG(("Flags: %x", flags));
 276   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 277     goto err;
 278   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 279     goto err;
 280   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 281     goto err;
 282   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 283     goto err;
 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))
 287     goto err;
 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) !=
 292       SILC_AUTH_OK)
 293     goto err;
 294   SILC_LOG_DEBUG(("Signature Ok"));
 295   SILC_LOG_DEBUG(("Get public key"));
 296   pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
 297   if (!pk2)
 298     goto err;
 299   SILC_LOG_DEBUG(("Verify public key"));
 300   if (!silc_pkcs_public_key_compare(public_key, pk2))
 301     goto err;
 302   SILC_LOG_DEBUG(("Public key Ok"));
 303   silc_pkcs_public_key_free(pk2);
 304   silc_message_payload_free(message);
 305
 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",
 310                   sizeof(tmp) / 2));
 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,
 316                                     NULL, NULL, rng,
 317                                     public_key, private_key, hash, buf);
 318   if (!buf)
 319     goto err;
 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);
 325   if (!message)
 326     goto err;
 327   flags = silc_message_get_flags(message);
 328   SILC_LOG_DEBUG(("Flags: %x", flags));
 329   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 330     goto err;
 331   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 332     goto err;
 333   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 334     goto err;
 335   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 336     goto err;
 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))
 340     goto err;
 341   SILC_LOG_DEBUG(("Verifying signature"));
 342   if (silc_message_signed_verify(message, public_key, hash) !=
 343       SILC_AUTH_OK)
 344     goto err;
 345   SILC_LOG_DEBUG(("Signature Ok"));
 346   SILC_LOG_DEBUG(("Get public key"));
 347   pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
 348   if (!pk2)
 349     goto err;
 350   SILC_LOG_DEBUG(("Verify public key"));
 351   if (!silc_pkcs_public_key_compare(public_key, pk2))
 352     goto err;
 353   SILC_LOG_DEBUG(("Public key Ok"));
 354   silc_pkcs_public_key_free(pk2);
 355   silc_message_payload_free(message);
 356
 357   /* Digitally signed channel message (LARGE) */
 358   n = 65550;
 359   tmp2 = silc_malloc(n);
 360   if (!tmp2)
 361     goto err;
 362   SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED LARGE",
 363                   n));
 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,
 369                                     key, hmac, rng,
 370                                     public_key, private_key, hash, buf);
 371   if (!buf)
 372     goto err;
 373   SILC_LOG_DEBUG(("Message length: %d", silc_buffer_len(buf)));
 374   if (silc_buffer_len(buf) > SILC_PACKET_MAX_LEN)
 375     goto err;
 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);
 380   if (!message)
 381     goto err;
 382   flags = silc_message_get_flags(message);
 383   SILC_LOG_DEBUG(("Flags: %x", flags));
 384   if (!(flags & SILC_MESSAGE_FLAG_ACTION))
 385     goto err;
 386   if (!(flags & SILC_MESSAGE_FLAG_UTF8))
 387     goto err;
 388   if (!(flags & SILC_MESSAGE_FLAG_ACK))
 389     goto err;
 390   if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
 391     goto err;
 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)
 395     goto err;
 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) !=
 400       SILC_AUTH_OK)
 401     goto err;
 402   SILC_LOG_DEBUG(("Signature Ok"));
 403   SILC_LOG_DEBUG(("Get public key"));
 404   pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
 405   if (!pk2)
 406     goto err;
 407   SILC_LOG_DEBUG(("Verify public key"));
 408   if (!silc_pkcs_public_key_compare(public_key, pk2))
 409     goto err;
 410   SILC_LOG_DEBUG(("Public key Ok"));
 411   silc_pkcs_public_key_free(pk2);
 412   silc_message_payload_free(message);
 413   silc_free(tmp2);
 414
 415
 416   success = TRUE;
 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);
 422   silc_rng_free(rng);
 423
 424  err:
 425   silc_cipher_unregister_all();
 426   silc_hash_unregister_all();
 427   silc_hmac_unregister_all();
 428   silc_pkcs_unregister_all();
 429
 430   SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
 431   fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
 432
 433   return success;
 434 }