src/test/test_pt.c

   1 /* Copyright (c) 2001-2004, Roger Dingledine.
   2  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   3  * Copyright (c) 2007-2015, The Tor Project, Inc. */
   4 /* See LICENSE for licensing information */
   5
   6 #include "orconfig.h"
   7 #define PT_PRIVATE
   8 #define UTIL_PRIVATE
   9 #define STATEFILE_PRIVATE
  10 #define CONTROL_PRIVATE
  11 #include "or.h"
  12 #include "config.h"
  13 #include "confparse.h"
  14 #include "control.h"
  15 #include "transports.h"
  16 #include "circuitbuild.h"
  17 #include "util.h"
  18 #include "statefile.h"
  19 #include "test.h"
  20
  21 static void
  22 reset_mp(managed_proxy_t *mp)
  23 {
  24   mp->conf_state = PT_PROTO_LAUNCHED;
  25   SMARTLIST_FOREACH(mp->transports, transport_t *, t, transport_free(t));
  26   smartlist_clear(mp->transports);
  27 }
  28
  29 static void
  30 test_pt_parsing(void *arg)
  31 {
  32   char line[200];
  33   transport_t *transport = NULL;
  34   tor_addr_t test_addr;
  35
  36   managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
  37   (void)arg;
  38   mp->conf_state = PT_PROTO_INFANT;
  39   mp->transports = smartlist_new();
  40
  41   /* incomplete cmethod */
  42   strlcpy(line,"CMETHOD trebuchet",sizeof(line));
  43   tt_assert(parse_cmethod_line(line, mp) < 0);
  44
  45   reset_mp(mp);
  46
  47   /* wrong proxy type */
  48   strlcpy(line,"CMETHOD trebuchet dog 127.0.0.1:1999",sizeof(line));
  49   tt_assert(parse_cmethod_line(line, mp) < 0);
  50
  51   reset_mp(mp);
  52
  53   /* wrong addrport */
  54   strlcpy(line,"CMETHOD trebuchet socks4 abcd",sizeof(line));
  55   tt_assert(parse_cmethod_line(line, mp) < 0);
  56
  57   reset_mp(mp);
  58
  59   /* correct line */
  60   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
  61   tt_assert(parse_cmethod_line(line, mp) == 0);
  62   tt_assert(smartlist_len(mp->transports) == 1);
  63   transport = smartlist_get(mp->transports, 0);
  64   /* test registered address of transport */
  65   tor_addr_parse(&test_addr, "127.0.0.1");
  66   tt_assert(tor_addr_eq(&test_addr, &transport->addr));
  67   /* test registered port of transport */
  68   tt_assert(transport->port == 1999);
  69   /* test registered SOCKS version of transport */
  70   tt_assert(transport->socks_version == PROXY_SOCKS5);
  71   /* test registered name of transport */
  72   tt_str_op(transport->name,OP_EQ, "trebuchet");
  73
  74   reset_mp(mp);
  75
  76   /* incomplete smethod */
  77   strlcpy(line,"SMETHOD trebuchet",sizeof(line));
  78   tt_assert(parse_smethod_line(line, mp) < 0);
  79
  80   reset_mp(mp);
  81
  82   /* wrong addr type */
  83   strlcpy(line,"SMETHOD trebuchet abcd",sizeof(line));
  84   tt_assert(parse_smethod_line(line, mp) < 0);
  85
  86   reset_mp(mp);
  87
  88   /* cowwect */
  89   strlcpy(line,"SMETHOD trebuchy 127.0.0.2:2999",sizeof(line));
  90   tt_assert(parse_smethod_line(line, mp) == 0);
  91   tt_assert(smartlist_len(mp->transports) == 1);
  92   transport = smartlist_get(mp->transports, 0);
  93   /* test registered address of transport */
  94   tor_addr_parse(&test_addr, "127.0.0.2");
  95   tt_assert(tor_addr_eq(&test_addr, &transport->addr));
  96   /* test registered port of transport */
  97   tt_assert(transport->port == 2999);
  98   /* test registered name of transport */
  99   tt_str_op(transport->name,OP_EQ, "trebuchy");
 100
 101   reset_mp(mp);
 102
 103   /* Include some arguments. Good ones. */
 104   strlcpy(line,"SMETHOD trebuchet 127.0.0.1:9999 "
 105           "ARGS:counterweight=3,sling=snappy",
 106           sizeof(line));
 107   tt_assert(parse_smethod_line(line, mp) == 0);
 108   tt_int_op(1, OP_EQ, smartlist_len(mp->transports));
 109   {
 110     const transport_t *transport = smartlist_get(mp->transports, 0);
 111     tt_assert(transport);
 112     tt_str_op(transport->name, OP_EQ, "trebuchet");
 113     tt_int_op(transport->port, OP_EQ, 9999);
 114     tt_str_op(fmt_addr(&transport->addr), OP_EQ, "127.0.0.1");
 115     tt_str_op(transport->extra_info_args, OP_EQ,
 116               "counterweight=3,sling=snappy");
 117   }
 118   reset_mp(mp);
 119
 120   /* unsupported version */
 121   strlcpy(line,"VERSION 666",sizeof(line));
 122   tt_assert(parse_version(line, mp) < 0);
 123
 124   /* incomplete VERSION */
 125   strlcpy(line,"VERSION ",sizeof(line));
 126   tt_assert(parse_version(line, mp) < 0);
 127
 128   /* correct VERSION */
 129   strlcpy(line,"VERSION 1",sizeof(line));
 130   tt_assert(parse_version(line, mp) == 0);
 131
 132  done:
 133   reset_mp(mp);
 134   smartlist_free(mp->transports);
 135   tor_free(mp);
 136 }
 137
 138 static void
 139 test_pt_get_transport_options(void *arg)
 140 {
 141   char **execve_args;
 142   smartlist_t *transport_list = smartlist_new();
 143   managed_proxy_t *mp;
 144   or_options_t *options = get_options_mutable();
 145   char *opt_str = NULL;
 146   config_line_t *cl = NULL;
 147   (void)arg;
 148
 149   execve_args = tor_malloc(sizeof(char*)*2);
 150   execve_args[0] = tor_strdup("cheeseshop");
 151   execve_args[1] = NULL;
 152
 153   mp = managed_proxy_create(transport_list, execve_args, 1);
 154   tt_ptr_op(mp, OP_NE, NULL);
 155   opt_str = get_transport_options_for_server_proxy(mp);
 156   tt_ptr_op(opt_str, OP_EQ, NULL);
 157
 158   smartlist_add(mp->transports_to_launch, tor_strdup("gruyere"));
 159   smartlist_add(mp->transports_to_launch, tor_strdup("roquefort"));
 160   smartlist_add(mp->transports_to_launch, tor_strdup("stnectaire"));
 161
 162   tt_assert(options);
 163
 164   cl = tor_malloc_zero(sizeof(config_line_t));
 165   cl->value = tor_strdup("gruyere melty=10 hardness=se;ven");
 166   options->ServerTransportOptions = cl;
 167
 168   cl = tor_malloc_zero(sizeof(config_line_t));
 169   cl->value = tor_strdup("stnectaire melty=4 hardness=three");
 170   cl->next = options->ServerTransportOptions;
 171   options->ServerTransportOptions = cl;
 172
 173   cl = tor_malloc_zero(sizeof(config_line_t));
 174   cl->value = tor_strdup("pepperjack melty=12 hardness=five");
 175   cl->next = options->ServerTransportOptions;
 176   options->ServerTransportOptions = cl;
 177
 178   opt_str = get_transport_options_for_server_proxy(mp);
 179   tt_str_op(opt_str, OP_EQ,
 180             "gruyere:melty=10;gruyere:hardness=se\\;ven;"
 181             "stnectaire:melty=4;stnectaire:hardness=three");
 182
 183  done:
 184   tor_free(opt_str);
 185   config_free_lines(cl);
 186   managed_proxy_destroy(mp, 0);
 187   smartlist_free(transport_list);
 188 }
 189
 190 static void
 191 test_pt_protocol(void *arg)
 192 {
 193   char line[200];
 194
 195   managed_proxy_t *mp = tor_malloc_zero(sizeof(managed_proxy_t));
 196   (void)arg;
 197   mp->conf_state = PT_PROTO_LAUNCHED;
 198   mp->transports = smartlist_new();
 199   mp->argv = tor_calloc(2, sizeof(char *));
 200   mp->argv[0] = tor_strdup("<testcase>");
 201
 202   /* various wrong protocol runs: */
 203
 204   strlcpy(line,"VERSION 1",sizeof(line));
 205   handle_proxy_line(line, mp);
 206   tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 207
 208   strlcpy(line,"VERSION 1",sizeof(line));
 209   handle_proxy_line(line, mp);
 210   tt_assert(mp->conf_state == PT_PROTO_BROKEN);
 211
 212   reset_mp(mp);
 213
 214   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
 215   handle_proxy_line(line, mp);
 216   tt_assert(mp->conf_state == PT_PROTO_BROKEN);
 217
 218   reset_mp(mp);
 219
 220   /* correct protocol run: */
 221   strlcpy(line,"VERSION 1",sizeof(line));
 222   handle_proxy_line(line, mp);
 223   tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 224
 225   strlcpy(line,"CMETHOD trebuchet socks5 127.0.0.1:1999",sizeof(line));
 226   handle_proxy_line(line, mp);
 227   tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 228
 229   strlcpy(line,"CMETHODS DONE",sizeof(line));
 230   handle_proxy_line(line, mp);
 231   tt_assert(mp->conf_state == PT_PROTO_CONFIGURED);
 232
 233  done:
 234   reset_mp(mp);
 235   smartlist_free(mp->transports);
 236   tor_free(mp->argv[0]);
 237   tor_free(mp->argv);
 238   tor_free(mp);
 239 }
 240
 241 static void
 242 test_pt_get_extrainfo_string(void *arg)
 243 {
 244   managed_proxy_t *mp1 = NULL, *mp2 = NULL;
 245   char **argv1, **argv2;
 246   smartlist_t *t1 = smartlist_new(), *t2 = smartlist_new();
 247   int r;
 248   char *s = NULL;
 249   (void) arg;
 250
 251   argv1 = tor_malloc_zero(sizeof(char*)*3);
 252   argv1[0] = tor_strdup("ewige");
 253   argv1[1] = tor_strdup("Blumenkraft");
 254   argv1[2] = NULL;
 255   argv2 = tor_malloc_zero(sizeof(char*)*4);
 256   argv2[0] = tor_strdup("und");
 257   argv2[1] = tor_strdup("ewige");
 258   argv2[2] = tor_strdup("Schlangenkraft");
 259   argv2[3] = NULL;
 260
 261   mp1 = managed_proxy_create(t1, argv1, 1);
 262   mp2 = managed_proxy_create(t2, argv2, 1);
 263
 264   r = parse_smethod_line("SMETHOD hagbard 127.0.0.1:5555", mp1);
 265   tt_int_op(r, OP_EQ, 0);
 266   r = parse_smethod_line("SMETHOD celine 127.0.0.1:1723 ARGS:card=no-enemy",
 267                          mp2);
 268   tt_int_op(r, OP_EQ, 0);
 269
 270   /* Force these proxies to look "completed" or they won't generate output. */
 271   mp1->conf_state = mp2->conf_state = PT_PROTO_COMPLETED;
 272
 273   s = pt_get_extra_info_descriptor_string();
 274   tt_assert(s);
 275   tt_str_op(s, OP_EQ,
 276             "transport hagbard 127.0.0.1:5555\n"
 277             "transport celine 127.0.0.1:1723 card=no-enemy\n");
 278
 279  done:
 280   /* XXXX clean up better */
 281   smartlist_free(t1);
 282   smartlist_free(t2);
 283   tor_free(s);
 284 }
 285
 286 #ifdef _WIN32
 287 #define STDIN_HANDLE HANDLE
 288 #else
 289 #define STDIN_HANDLE FILE
 290 #endif
 291
 292 static smartlist_t *
 293 tor_get_lines_from_handle_replacement(STDIN_HANDLE *handle,
 294                                       enum stream_status *stream_status_out)
 295 {
 296   static int times_called = 0;
 297   smartlist_t *retval_sl = smartlist_new();
 298
 299   (void) handle;
 300   (void) stream_status_out;
 301
 302   /* Generate some dummy CMETHOD lines the first 5 times. The 6th
 303      time, send 'CMETHODS DONE' to finish configuring the proxy. */
 304   if (times_called++ != 5) {
 305     smartlist_add_asprintf(retval_sl, "SMETHOD mock%d 127.0.0.1:555%d",
 306                            times_called, times_called);
 307   } else {
 308     smartlist_add(retval_sl, tor_strdup("SMETHODS DONE"));
 309   }
 310
 311   return retval_sl;
 312 }
 313
 314 /* NOP mock */
 315 static void
 316 tor_process_handle_destroy_replacement(process_handle_t *process_handle,
 317                                        int also_terminate_process)
 318 {
 319   (void) process_handle;
 320   (void) also_terminate_process;
 321 }
 322
 323 static or_state_t *dummy_state = NULL;
 324
 325 static or_state_t *
 326 get_or_state_replacement(void)
 327 {
 328   return dummy_state;
 329 }
 330
 331 static int controlevent_n = 0;
 332 static uint16_t controlevent_event = 0;
 333 static smartlist_t *controlevent_msgs = NULL;
 334
 335 static void
 336 queue_control_event_string_replacement(uint16_t event, char *msg)
 337 {
 338   ++controlevent_n;
 339   controlevent_event = event;
 340   if (!controlevent_msgs)
 341     controlevent_msgs = smartlist_new();
 342   smartlist_add(controlevent_msgs, msg);
 343 }
 344
 345 /* Test the configure_proxy() function. */
 346 static void
 347 test_pt_configure_proxy(void *arg)
 348 {
 349   int i, retval;
 350   managed_proxy_t *mp = NULL;
 351   (void) arg;
 352
 353   dummy_state = tor_malloc_zero(sizeof(or_state_t));
 354
 355   MOCK(tor_get_lines_from_handle,
 356        tor_get_lines_from_handle_replacement);
 357   MOCK(tor_process_handle_destroy,
 358        tor_process_handle_destroy_replacement);
 359   MOCK(get_or_state,
 360        get_or_state_replacement);
 361   MOCK(queue_control_event_string,
 362        queue_control_event_string_replacement);
 363
 364   control_testing_set_global_event_mask(EVENT_TRANSPORT_LAUNCHED);
 365
 366   mp = tor_malloc_zero(sizeof(managed_proxy_t));
 367   mp->conf_state = PT_PROTO_ACCEPTING_METHODS;
 368   mp->transports = smartlist_new();
 369   mp->transports_to_launch = smartlist_new();
 370   mp->process_handle = tor_malloc_zero(sizeof(process_handle_t));
 371   mp->argv = tor_malloc_zero(sizeof(char*)*2);
 372   mp->argv[0] = tor_strdup("<testcase>");
 373   mp->is_server = 1;
 374
 375   /* Test the return value of configure_proxy() by calling it some
 376      times while it is uninitialized and then finally finalizing its
 377      configuration. */
 378   for (i = 0 ; i < 5 ; i++) {
 379     retval = configure_proxy(mp);
 380     /* retval should be zero because proxy hasn't finished configuring yet */
 381     tt_int_op(retval, OP_EQ, 0);
 382     /* check the number of registered transports */
 383     tt_assert(smartlist_len(mp->transports) == i+1);
 384     /* check that the mp is still waiting for transports */
 385     tt_assert(mp->conf_state == PT_PROTO_ACCEPTING_METHODS);
 386   }
 387
 388   /* this last configure_proxy() should finalize the proxy configuration. */
 389   retval = configure_proxy(mp);
 390   /* retval should be 1 since the proxy finished configuring */
 391   tt_int_op(retval, OP_EQ, 1);
 392   /* check the mp state */
 393   tt_assert(mp->conf_state == PT_PROTO_COMPLETED);
 394
 395   tt_int_op(controlevent_n, OP_EQ, 5);
 396   tt_int_op(controlevent_event, OP_EQ, EVENT_TRANSPORT_LAUNCHED);
 397   tt_int_op(smartlist_len(controlevent_msgs), OP_EQ, 5);
 398   smartlist_sort_strings(controlevent_msgs);
 399   tt_str_op(smartlist_get(controlevent_msgs, 0), OP_EQ,
 400             "650 TRANSPORT_LAUNCHED server mock1 127.0.0.1 5551\r\n");
 401   tt_str_op(smartlist_get(controlevent_msgs, 1), OP_EQ,
 402             "650 TRANSPORT_LAUNCHED server mock2 127.0.0.1 5552\r\n");
 403   tt_str_op(smartlist_get(controlevent_msgs, 2), OP_EQ,
 404             "650 TRANSPORT_LAUNCHED server mock3 127.0.0.1 5553\r\n");
 405   tt_str_op(smartlist_get(controlevent_msgs, 3), OP_EQ,
 406             "650 TRANSPORT_LAUNCHED server mock4 127.0.0.1 5554\r\n");
 407   tt_str_op(smartlist_get(controlevent_msgs, 4), OP_EQ,
 408             "650 TRANSPORT_LAUNCHED server mock5 127.0.0.1 5555\r\n");
 409
 410   { /* check that the transport info were saved properly in the tor state */
 411     config_line_t *transport_in_state = NULL;
 412     smartlist_t *transport_info_sl = smartlist_new();
 413     char *name_of_transport = NULL;
 414     char *bindaddr = NULL;
 415
 416     /* Get the bindaddr for "mock1" and check it against the bindaddr
 417        that the mocked tor_get_lines_from_handle() generated. */
 418     transport_in_state = get_transport_in_state_by_name("mock1");
 419     tt_assert(transport_in_state);
 420     smartlist_split_string(transport_info_sl, transport_in_state->value,
 421                            NULL, 0, 0);
 422     name_of_transport = smartlist_get(transport_info_sl, 0);
 423     bindaddr = smartlist_get(transport_info_sl, 1);
 424     tt_str_op(name_of_transport, OP_EQ, "mock1");
 425     tt_str_op(bindaddr, OP_EQ, "127.0.0.1:5551");
 426
 427     SMARTLIST_FOREACH(transport_info_sl, char *, cp, tor_free(cp));
 428     smartlist_free(transport_info_sl);
 429   }
 430
 431  done:
 432   or_state_free(dummy_state);
 433   UNMOCK(tor_get_lines_from_handle);
 434   UNMOCK(tor_process_handle_destroy);
 435   UNMOCK(get_or_state);
 436   UNMOCK(queue_control_event_string);
 437   if (controlevent_msgs) {
 438     SMARTLIST_FOREACH(controlevent_msgs, char *, cp, tor_free(cp));
 439     smartlist_free(controlevent_msgs);
 440     controlevent_msgs = NULL;
 441   }
 442   if (mp->transports) {
 443     SMARTLIST_FOREACH(mp->transports, transport_t *, t, transport_free(t));
 444     smartlist_free(mp->transports);
 445   }
 446   smartlist_free(mp->transports_to_launch);
 447   tor_free(mp->process_handle);
 448   tor_free(mp->argv[0]);
 449   tor_free(mp->argv);
 450   tor_free(mp);
 451 }
 452
 453 /* Test the get_pt_proxy_uri() function. */
 454 static void
 455 test_get_pt_proxy_uri(void *arg)
 456 {
 457   or_options_t *options = get_options_mutable();
 458   char *uri = NULL;
 459   int ret;
 460   (void) arg;
 461
 462   /* Test with no proxy. */
 463   uri = get_pt_proxy_uri();
 464   tt_assert(uri == NULL);
 465
 466   /* Test with a SOCKS4 proxy. */
 467   options->Socks4Proxy = tor_strdup("192.0.2.1:1080");
 468   ret = tor_addr_port_lookup(options->Socks4Proxy,
 469                              &options->Socks4ProxyAddr,
 470                              &options->Socks4ProxyPort);
 471   tt_int_op(ret, OP_EQ, 0);
 472   uri = get_pt_proxy_uri();
 473   tt_str_op(uri, OP_EQ, "socks4a://192.0.2.1:1080");
 474   tor_free(uri);
 475   tor_free(options->Socks4Proxy);
 476
 477   /* Test with a SOCKS5 proxy, no username/password. */
 478   options->Socks5Proxy = tor_strdup("192.0.2.1:1080");
 479   ret = tor_addr_port_lookup(options->Socks5Proxy,
 480                              &options->Socks5ProxyAddr,
 481                              &options->Socks5ProxyPort);
 482   tt_int_op(ret, OP_EQ, 0);
 483   uri = get_pt_proxy_uri();
 484   tt_str_op(uri, OP_EQ, "socks5://192.0.2.1:1080");
 485   tor_free(uri);
 486
 487   /* Test with a SOCKS5 proxy, with username/password. */
 488   options->Socks5ProxyUsername = tor_strdup("hwest");
 489   options->Socks5ProxyPassword = tor_strdup("r34n1m470r");
 490   uri = get_pt_proxy_uri();
 491   tt_str_op(uri, OP_EQ, "socks5://hwest:r34n1m470r@192.0.2.1:1080");
 492   tor_free(uri);
 493   tor_free(options->Socks5Proxy);
 494   tor_free(options->Socks5ProxyUsername);
 495   tor_free(options->Socks5ProxyPassword);
 496
 497   /* Test with a HTTPS proxy, no authenticator. */
 498   options->HTTPSProxy = tor_strdup("192.0.2.1:80");
 499   ret = tor_addr_port_lookup(options->HTTPSProxy,
 500                              &options->HTTPSProxyAddr,
 501                              &options->HTTPSProxyPort);
 502   tt_int_op(ret, OP_EQ, 0);
 503   uri = get_pt_proxy_uri();
 504   tt_str_op(uri, OP_EQ, "http://192.0.2.1:80");
 505   tor_free(uri);
 506
 507   /* Test with a HTTPS proxy, with authenticator. */
 508   options->HTTPSProxyAuthenticator = tor_strdup("hwest:r34n1m470r");
 509   uri = get_pt_proxy_uri();
 510   tt_str_op(uri, OP_EQ, "http://hwest:r34n1m470r@192.0.2.1:80");
 511   tor_free(uri);
 512   tor_free(options->HTTPSProxy);
 513   tor_free(options->HTTPSProxyAuthenticator);
 514
 515   /* Token nod to the fact that IPv6 exists. */
 516   options->Socks4Proxy = tor_strdup("[2001:db8::1]:1080");
 517   ret = tor_addr_port_lookup(options->Socks4Proxy,
 518                              &options->Socks4ProxyAddr,
 519                              &options->Socks4ProxyPort);
 520   tt_int_op(ret, OP_EQ, 0);
 521   uri = get_pt_proxy_uri();
 522   tt_str_op(uri, OP_EQ, "socks4a://[2001:db8::1]:1080");
 523   tor_free(uri);
 524   tor_free(options->Socks4Proxy);
 525
 526  done:
 527   if (uri)
 528     tor_free(uri);
 529 }
 530
 531 #define PT_LEGACY(name)                                               \
 532   { #name, test_pt_ ## name , 0, NULL, NULL }
 533
 534 struct testcase_t pt_tests[] = {
 535   PT_LEGACY(parsing),
 536   PT_LEGACY(protocol),
 537   { "get_transport_options", test_pt_get_transport_options, TT_FORK,
 538     NULL, NULL },
 539   { "get_extrainfo_string", test_pt_get_extrainfo_string, TT_FORK,
 540     NULL, NULL },
 541   { "configure_proxy",test_pt_configure_proxy, TT_FORK,
 542     NULL, NULL },
 543   { "get_pt_proxy_uri", test_get_pt_proxy_uri, TT_FORK,
 544     NULL, NULL },
 545   END_OF_TESTCASES
 546 };
 547