src/test/test_parsecommon.c

   1 /* Copyright (c) 2001-2004, Roger Dingledine.
   2  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   3  * Copyright (c) 2007-2018, The Tor Project, Inc. */
   4 /* See LICENSE for licensing information */
   5
   6 #include "core/or/or.h"
   7 #include "test/test.h"
   8 #include "lib/memarea/memarea.h"
   9 #include "lib/encoding/binascii.h"
  10 #include "feature/dirparse/parsecommon.h"
  11 #include "test/log_test_helpers.h"
  12
  13 static void
  14 test_parsecommon_tokenize_string_null(void *arg)
  15 {
  16
  17   memarea_t *area = memarea_new();
  18   smartlist_t *tokens = smartlist_new();
  19
  20   (void)arg;
  21
  22   const char *str_with_null = "a\0bccccccccc";
  23
  24   int retval =
  25   tokenize_string(area, str_with_null,
  26                   str_with_null + 3,
  27                   tokens, NULL, 0);
  28
  29   tt_int_op(retval, OP_EQ, -1);
  30
  31  done:
  32   memarea_drop_all(area);
  33   smartlist_free(tokens);
  34   return;
  35 }
  36
  37 static void
  38 test_parsecommon_get_next_token_success(void *arg)
  39 {
  40   memarea_t *area = memarea_new();
  41   const char *str = "uptime 1024";
  42   const char *end = str + strlen(str);
  43   const char **s = &str;
  44   token_rule_t table = T01("uptime", K_UPTIME, GE(1), NO_OBJ);
  45   (void)arg;
  46
  47   directory_token_t *token = get_next_token(area, s, end, &table);
  48
  49   tt_int_op(token->tp, OP_EQ, K_UPTIME);
  50   tt_int_op(token->n_args, OP_EQ, 1);
  51   tt_str_op(*(token->args), OP_EQ, "1024");
  52   tt_assert(!token->object_type);
  53   tt_int_op(token->object_size, OP_EQ, 0);
  54   tt_assert(!token->object_body);
  55
  56   tt_ptr_op(*s, OP_EQ, end);
  57
  58  done:
  59   memarea_drop_all(area);
  60   return;
  61 }
  62
  63 static void
  64 test_parsecommon_get_next_token_concat_args(void *arg)
  65 {
  66   memarea_t *area = memarea_new();
  67   const char *str = "proto A=1 B=2";
  68   const char *end = str + strlen(str);
  69   const char **s = &str;
  70   token_rule_t rule = T01("proto", K_PROTO, CONCAT_ARGS, NO_OBJ);
  71   (void)arg;
  72
  73   directory_token_t *token = get_next_token(area, s, end, &rule);
  74
  75   tt_int_op(token->tp, OP_EQ, K_PROTO);
  76   tt_int_op(token->n_args, OP_EQ, 1);
  77   tt_str_op(*(token->args), OP_EQ, "A=1 B=2");
  78
  79  done:
  80   memarea_drop_all(area);
  81 }
  82
  83 static void
  84 test_parsecommon_get_next_token_parse_keys(void *arg)
  85 {
  86   (void)arg;
  87
  88   memarea_t *area = memarea_new();
  89   const char *str =
  90     "onion-key\n"
  91     "-----BEGIN RSA PUBLIC KEY-----\n"
  92     "MIGJAoGBAMDdIya33BfNlHOkzoTKSTT8EjD64waMfUr372syVHiFjHhObwKwGA5u\n"
  93     "sHaMIe9r+Ij/4C1dKyuXkcz3DOl6gWNhTD7dZ89I+Okoh1jWe30jxCiAcywC22p5\n"
  94     "XLhrDkX1A63Z7XCH9ltwU2WMqWsVM98N2GR6MTujP7wtqdLExYN1AgMBAAE=\n"
  95     "-----END RSA PUBLIC KEY-----\n";
  96
  97   const char *end = str + strlen(str);
  98   const char **s = (const char **)&str;
  99   directory_token_t *token = NULL;
 100   directory_token_t *token2 = NULL;
 101
 102   token_rule_t rule = T1("onion-key", R_IPO_ONION_KEY, NO_ARGS, NEED_KEY_1024);
 103
 104   token = get_next_token(area, s, end, &rule);
 105
 106   tt_int_op(token->tp, OP_EQ, R_IPO_ONION_KEY);
 107   tt_int_op(token->n_args, OP_EQ, 0);
 108   tt_str_op(token->object_type, OP_EQ, "RSA PUBLIC KEY");
 109   tt_int_op(token->object_size, OP_EQ, 0);
 110   tt_assert(!token->object_body);
 111   tt_assert(token->key);
 112   tt_assert(!token->error);
 113
 114   const char *str2 =
 115     "client-key\n"
 116     "-----BEGIN RSA PRIVATE KEY-----\n"
 117     "MIICXAIBAAKBgQCwS810a2auH2PQchOBz9smNgjlDu31aq0IYlUohSYbhcv5AJ+d\n"
 118     "DY0nfZWzS+mZPwzL3UiEnTt6PVv7AgoZ5V9ZJWJTKIURjJpkK0mstfJKHKIZhf84\n"
 119     "pmFfRej9GQViB6NLtp1obOXJgJixSlMfw9doDI4NoAnEISCyH/tD77Qs2wIDAQAB\n"
 120     "AoGAbDg8CKkdQOnX9c7xFpCnsE8fKqz9eddgHHNwXw1NFTwOt+2gDWKSMZmv2X5S\n"
 121     "CVZg3owZxf5W0nT0D6Ny2+6nliak7foYAvkD0BsCiBhgftwC0zAo6k5rIbUKB3PJ\n"
 122     "QLFXgpJhqWuXkODyt/hS/GTernR437WVSEGp1bnALqiFabECQQDaqHOxzoWY/nvH\n"
 123     "KrfUi8EhqCnqERlRHwrW0MQZ1RPvF16OPPma+xa+ht/amfh3vYN5tZY82Zm43gGl\n"
 124     "XWL5cZhNAkEAzmdSootYVnqLLLRMfHKXnO1XbaEcA/08MDNKGlSclBJixFenE8jX\n"
 125     "iQsUbHwMJuGONvzWpRGPBP2f8xBd28ZtxwJARY+LZshtpfNniz/ixYJESaHG28je\n"
 126     "xfjbKOW3TQSFV+2WTifFvHEeljQwKMoMyoMGvYRwLCGJjs9JtMLVxsdFjQJBAKwD\n"
 127     "3BBvBQ39TuPQ1zWX4tb7zjMlY83HTFP3Sriq71tP/1QWoL2SUl56B2lp8E6vB/C3\n"
 128     "wsMK4SCNprHRYAd7VZ0CQDKn6Zhd11P94PLs0msybFEh1VXr6CEW/BrxBgbL4ls6\n"
 129     "dbX5XO0z4Ra8gYXgObgimhyMDYO98Idt5+Z3HIdyrSc=\n"
 130     "-----END RSA PRIVATE KEY-----\n";
 131
 132   const char *end2 = str2 + strlen(str2);
 133   const char **s2 = (const char **)&str2;
 134
 135   token_rule_t rule2 = T01("client-key", C_CLIENT_KEY, NO_ARGS,
 136                            NEED_SKEY_1024);
 137
 138   token2 = get_next_token(area, s2, end2, &rule2);
 139
 140   tt_int_op(token2->tp, OP_EQ, C_CLIENT_KEY);
 141   tt_int_op(token2->n_args, OP_EQ, 0);
 142   tt_str_op(token2->object_type, OP_EQ, "RSA PRIVATE KEY");
 143   tt_int_op(token2->object_size, OP_EQ, 0);
 144   tt_assert(!token2->object_body);
 145   tt_assert(token2->key);
 146   tt_assert(!token->error);
 147
 148  done:
 149   if (token) token_clear(token);
 150   if (token2) token_clear(token2);
 151   memarea_drop_all(area);
 152 }
 153
 154 static void
 155 test_parsecommon_get_next_token_object(void *arg)
 156 {
 157   memarea_t *area = memarea_new();
 158
 159   const char *str =
 160     "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
 161     "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
 162     "-----BEGIN SIGNATURE-----\n"
 163     "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
 164     "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
 165     "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
 166     "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
 167     "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
 168     "Ua9DEZB9KbJHVX1rGShrLA==\n"
 169     "-----END SIGNATURE-----\n";
 170
 171   const char *end = str + strlen(str);
 172   const char **s = &str;
 173   token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
 174                         GE(2), NEED_OBJ);
 175   (void)arg;
 176
 177   directory_token_t *token = get_next_token(area, s, end, &rule);
 178
 179   tt_int_op(token->tp, OP_EQ, K_DIRECTORY_SIGNATURE);
 180   tt_int_op(token->n_args, OP_EQ, 2);
 181   tt_str_op(token->args[0], OP_EQ,
 182                   "0232AF901C31A04EE9848595AF9BB7620D4C5B2E");
 183   tt_str_op(token->args[1], OP_EQ,
 184                   "CD1FD971855430880D3C31E0331C5C55800C2F79");
 185
 186   tt_assert(!token->error);
 187
 188   char decoded[256];
 189   const char *signature =
 190     "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
 191     "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
 192     "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
 193     "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
 194     "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
 195     "Ua9DEZB9KbJHVX1rGShrLA==\n";
 196   tt_assert(signature);
 197   size_t signature_len = strlen(signature);
 198   base64_decode(decoded, sizeof(decoded), signature, signature_len);
 199
 200   tt_str_op(token->object_type, OP_EQ, "SIGNATURE");
 201   tt_int_op(token->object_size, OP_EQ, 256);
 202   tt_mem_op(token->object_body, OP_EQ, decoded, 256);
 203
 204   tt_assert(!token->key);
 205
 206  done:
 207   memarea_drop_all(area);
 208 }
 209
 210 static void
 211 test_parsecommon_get_next_token_err_too_many_args(void *arg)
 212 {
 213   memarea_t *area = memarea_new();
 214   const char *str = "uptime 1024 1024 1024";
 215   const char *end = str + strlen(str);
 216   const char **s = &str;
 217   token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
 218   (void)arg;
 219
 220   directory_token_t *token = get_next_token(area, s, end, &table);
 221
 222   tt_int_op(token->tp, OP_EQ, ERR_);
 223   tt_str_op(token->error, OP_EQ, "Too many arguments to uptime");
 224
 225  done:
 226   memarea_drop_all(area);
 227   return;
 228 }
 229
 230 static void
 231 test_parsecommon_get_next_token_err_too_few_args(void *arg)
 232 {
 233   memarea_t *area = memarea_new();
 234   const char *str = "uptime";
 235   const char *end = str + strlen(str);
 236   const char **s = &str;
 237   token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
 238   (void)arg;
 239
 240   directory_token_t *token = get_next_token(area, s, end, &table);
 241
 242   tt_int_op(token->tp, OP_EQ, ERR_);
 243   tt_str_op(token->error, OP_EQ, "Too few arguments to uptime");
 244
 245  done:
 246   memarea_drop_all(area);
 247   return;
 248 }
 249
 250 static void
 251 test_parsecommon_get_next_token_err_obj_missing_endline(void *arg)
 252 {
 253   memarea_t *area = memarea_new();
 254
 255   const char *str =
 256     "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
 257     "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
 258     "-----BEGIN SIGNATURE-----\n"
 259     "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
 260     "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
 261     "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
 262     "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
 263     "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
 264     "Ua9DEZB9KbJHVX1rGShrLA==\n";
 265
 266   const char *end = str + strlen(str);
 267   const char **s = &str;
 268   token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
 269                         GE(2), NEED_OBJ);
 270   (void)arg;
 271
 272   directory_token_t *token = get_next_token(area, s, end, &rule);
 273
 274   tt_int_op(token->tp, OP_EQ, ERR_);
 275   tt_str_op(token->error, OP_EQ, "Malformed object: missing object end line");
 276
 277  done:
 278   memarea_drop_all(area);
 279   return;
 280 }
 281
 282 static void
 283 test_parsecommon_get_next_token_err_bad_beginline(void *arg)
 284 {
 285   memarea_t *area = memarea_new();
 286
 287   const char *str =
 288     "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
 289     "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
 290     "-----BEGIN SIGNATURE-Z---\n"
 291     "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
 292     "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
 293     "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
 294     "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
 295     "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
 296     "Ua9DEZB9KbJHVX1rGShrLA==\n"
 297     "-----END SIGNATURE-----\n";
 298
 299   const char *end = str + strlen(str);
 300   const char **s = &str;
 301   token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
 302                         GE(2), NEED_OBJ);
 303   (void)arg;
 304
 305   directory_token_t *token = get_next_token(area, s, end, &rule);
 306
 307   tt_int_op(token->tp, OP_EQ, ERR_);
 308   tt_str_op(token->error, OP_EQ, "Malformed object: bad begin line");
 309
 310  done:
 311   memarea_drop_all(area);
 312   return;
 313 }
 314
 315 static void
 316 test_parsecommon_get_next_token_err_tag_mismatch(void *arg)
 317 {
 318   memarea_t *area = memarea_new();
 319
 320   const char *str =
 321     "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
 322     "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
 323     "-----BEGIN SIGNATURE-----\n"
 324     "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
 325     "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
 326     "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
 327     "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
 328     "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
 329     "Ua9DEZB9KbJHVX1rGShrLA==\n"
 330     "-----END SOMETHINGELSE-----\n";
 331
 332   const char *end = str + strlen(str);
 333   const char **s = &str;
 334   token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
 335                         GE(2), NEED_OBJ);
 336   (void)arg;
 337
 338   directory_token_t *token = get_next_token(area, s, end, &rule);
 339
 340   tt_int_op(token->tp, OP_EQ, ERR_);
 341   tt_str_op(token->error, OP_EQ,
 342             "Malformed object: mismatched end tag SIGNATURE");
 343
 344  done:
 345   memarea_drop_all(area);
 346   return;
 347 }
 348
 349 static void
 350 test_parsecommon_get_next_token_err_bad_base64(void *arg)
 351 {
 352   memarea_t *area = memarea_new();
 353
 354   const char *str =
 355     "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
 356     "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
 357     "-----BEGIN SIGNATURE-----\n"
 358     "%%@%%%%%%%!!!'\n"
 359     "-----END SIGNATURE-----\n";
 360
 361   const char *end = str + strlen(str);
 362   const char **s = &str;
 363   token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
 364                         GE(2), NEED_OBJ);
 365   (void)arg;
 366
 367   directory_token_t *token = get_next_token(area, s, end, &rule);
 368
 369   tt_int_op(token->tp, OP_EQ, ERR_);
 370   tt_str_op(token->error, OP_EQ, "Malformed object: bad base64-encoded data");
 371
 372  done:
 373   memarea_drop_all(area);
 374   return;
 375 }
 376
 377 #define PARSECOMMON_TEST(name) \
 378   { #name, test_parsecommon_ ## name, 0, NULL, NULL }
 379
 380 struct testcase_t parsecommon_tests[] = {
 381   PARSECOMMON_TEST(tokenize_string_null),
 382   PARSECOMMON_TEST(get_next_token_success),
 383   PARSECOMMON_TEST(get_next_token_concat_args),
 384   PARSECOMMON_TEST(get_next_token_parse_keys),
 385   PARSECOMMON_TEST(get_next_token_object),
 386   PARSECOMMON_TEST(get_next_token_err_too_many_args),
 387   PARSECOMMON_TEST(get_next_token_err_too_few_args),
 388   PARSECOMMON_TEST(get_next_token_err_obj_missing_endline),
 389   PARSECOMMON_TEST(get_next_token_err_bad_beginline),
 390   PARSECOMMON_TEST(get_next_token_err_tag_mismatch),
 391   PARSECOMMON_TEST(get_next_token_err_bad_base64),
 392   END_OF_TESTCASES
 393 };
 394