src/test/test_entryconn.c

   1 /* Copyright (c) 2014-2021, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 #include "orconfig.h"
   5
   6 #define CONNECTION_PRIVATE
   7 #define CONNECTION_EDGE_PRIVATE
   8
   9 #include "core/or/or.h"
  10 #include "test/test.h"
  11
  12 #include "feature/client/addressmap.h"
  13 #include "app/config/config.h"
  14 #include "lib/confmgt/confmgt.h"
  15 #include "core/mainloop/connection.h"
  16 #include "core/or/connection_edge.h"
  17 #include "feature/nodelist/nodelist.h"
  18
  19 #include "feature/hs/hs_cache.h"
  20
  21 #include "core/or/entry_connection_st.h"
  22 #include "core/or/socks_request_st.h"
  23
  24 #include "lib/encoding/confline.h"
  25
  26 static void *
  27 entryconn_rewrite_setup(const struct testcase_t *tc)
  28 {
  29   (void)tc;
  30   entry_connection_t *ec = entry_connection_new(CONN_TYPE_AP, AF_INET);
  31   addressmap_init();
  32   return ec;
  33 }
  34
  35 static int
  36 entryconn_rewrite_teardown(const struct testcase_t *tc, void *arg)
  37 {
  38   (void)tc;
  39   entry_connection_t *ec = arg;
  40   if (ec)
  41     connection_free_minimal(ENTRY_TO_CONN(ec));
  42   addressmap_free_all();
  43   return 1;
  44 }
  45
  46 static struct testcase_setup_t test_rewrite_setup = {
  47   entryconn_rewrite_setup, entryconn_rewrite_teardown
  48 };
  49
  50 /* Simple rewrite: no changes needed */
  51 static void
  52 test_entryconn_rewrite_basic(void *arg)
  53 {
  54   entry_connection_t *ec = arg;
  55   rewrite_result_t rr;
  56
  57   tt_assert(ec->socks_request);
  58   strlcpy(ec->socks_request->address, "www.TORproject.org",
  59           sizeof(ec->socks_request->address));
  60   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
  61   connection_ap_handshake_rewrite(ec, &rr);
  62
  63   tt_int_op(rr.should_close, OP_EQ, 0);
  64   tt_int_op(rr.end_reason, OP_EQ, 0);
  65   tt_int_op(rr.automap, OP_EQ, 0);
  66   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
  67   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
  68   tt_str_op(rr.orig_address, OP_EQ, "www.torproject.org");
  69   tt_str_op(ec->socks_request->address, OP_EQ, "www.torproject.org");
  70   tt_str_op(ec->original_dest_address, OP_EQ, "www.torproject.org");
  71
  72  done:
  73   ;
  74 }
  75
  76 /* Rewrite but reject because of disallowed .exit */
  77 static void
  78 test_entryconn_rewrite_bad_dotexit(void *arg)
  79 {
  80   entry_connection_t *ec = arg;
  81   rewrite_result_t rr;
  82
  83   tt_assert(ec->socks_request);
  84   strlcpy(ec->socks_request->address, "www.TORproject.org.foo.exit",
  85           sizeof(ec->socks_request->address));
  86   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
  87   connection_ap_handshake_rewrite(ec, &rr);
  88
  89   tt_int_op(rr.should_close, OP_EQ, 1);
  90   tt_int_op(rr.end_reason, OP_EQ, END_STREAM_REASON_TORPROTOCOL);
  91
  92  done:
  93   ;
  94 }
  95
  96 /* Automap on resolve, connect to automapped address, resolve again and get
  97  * same answer. (IPv4) */
  98 static void
  99 test_entryconn_rewrite_automap_ipv4(void *arg)
 100 {
 101   entry_connection_t *ec = arg;
 102   entry_connection_t *ec2=NULL, *ec3=NULL;
 103   rewrite_result_t rr;
 104   char *msg = NULL;
 105
 106   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 107   ec3 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 108
 109   get_options_mutable()->AutomapHostsOnResolve = 1;
 110   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes, ".");
 111   parse_virtual_addr_network("127.202.0.0/16", AF_INET, 0, &msg);
 112
 113   /* Automap this on resolve. */
 114   strlcpy(ec->socks_request->address, "WWW.MIT.EDU",
 115           sizeof(ec->socks_request->address));
 116   ec->socks_request->command = SOCKS_COMMAND_RESOLVE;
 117   connection_ap_handshake_rewrite(ec, &rr);
 118
 119   tt_int_op(rr.automap, OP_EQ, 1);
 120   tt_int_op(rr.should_close, OP_EQ, 0);
 121   tt_int_op(rr.end_reason, OP_EQ, 0);
 122   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 123   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 124   tt_str_op(rr.orig_address, OP_EQ, "www.mit.edu");
 125   tt_str_op(ec->original_dest_address, OP_EQ, "www.mit.edu");
 126
 127   tt_assert(!strcmpstart(ec->socks_request->address,"127.202."));
 128
 129   /* Connect to it and make sure we get the original address back. */
 130   strlcpy(ec2->socks_request->address, ec->socks_request->address,
 131           sizeof(ec2->socks_request->address));
 132
 133   ec2->socks_request->command = SOCKS_COMMAND_CONNECT;
 134   connection_ap_handshake_rewrite(ec2, &rr);
 135
 136   tt_int_op(rr.automap, OP_EQ, 0);
 137   tt_int_op(rr.should_close, OP_EQ, 0);
 138   tt_int_op(rr.end_reason, OP_EQ, 0);
 139   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 140   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 141   tt_str_op(rr.orig_address, OP_EQ, ec->socks_request->address);
 142   tt_str_op(ec2->original_dest_address, OP_EQ, ec->socks_request->address);
 143   tt_str_op(ec2->socks_request->address, OP_EQ, "www.mit.edu");
 144
 145   /* Resolve it again, make sure the answer is the same. */
 146   strlcpy(ec3->socks_request->address, "www.MIT.EDU",
 147           sizeof(ec3->socks_request->address));
 148   ec3->socks_request->command = SOCKS_COMMAND_RESOLVE;
 149   connection_ap_handshake_rewrite(ec3, &rr);
 150
 151   tt_int_op(rr.automap, OP_EQ, 1);
 152   tt_int_op(rr.should_close, OP_EQ, 0);
 153   tt_int_op(rr.end_reason, OP_EQ, 0);
 154   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 155   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 156   tt_str_op(rr.orig_address, OP_EQ, "www.mit.edu");
 157   tt_str_op(ec3->original_dest_address, OP_EQ, "www.mit.edu");
 158
 159   tt_str_op(ec3->socks_request->address, OP_EQ,
 160             ec->socks_request->address);
 161
 162  done:
 163   connection_free_minimal(ENTRY_TO_CONN(ec2));
 164   connection_free_minimal(ENTRY_TO_CONN(ec3));
 165 }
 166
 167 /* Automap on resolve, connect to automapped address, resolve again and get
 168  * same answer. (IPv6) */
 169 static void
 170 test_entryconn_rewrite_automap_ipv6(void *arg)
 171 {
 172   (void)arg;
 173   entry_connection_t *ec =NULL;
 174   entry_connection_t *ec2=NULL, *ec3=NULL;
 175   rewrite_result_t rr;
 176   char *msg = NULL;
 177
 178   ec = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 179   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 180   ec3 = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 181
 182   get_options_mutable()->AutomapHostsOnResolve = 1;
 183   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes, ".");
 184   parse_virtual_addr_network("FE80::/32", AF_INET6, 0, &msg);
 185
 186   /* Automap this on resolve. */
 187   strlcpy(ec->socks_request->address, "WWW.MIT.EDU",
 188           sizeof(ec->socks_request->address));
 189   ec->socks_request->command = SOCKS_COMMAND_RESOLVE;
 190   connection_ap_handshake_rewrite(ec, &rr);
 191
 192   tt_int_op(rr.automap, OP_EQ, 1);
 193   tt_int_op(rr.should_close, OP_EQ, 0);
 194   tt_int_op(rr.end_reason, OP_EQ, 0);
 195   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 196   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 197   tt_str_op(rr.orig_address, OP_EQ, "www.mit.edu");
 198   tt_str_op(ec->original_dest_address, OP_EQ, "www.mit.edu");
 199
 200   /* Yes, this [ should be here. */
 201   tt_assert(!strcmpstart(ec->socks_request->address,"[fe80:"));
 202
 203   /* Connect to it and make sure we get the original address back. */
 204   strlcpy(ec2->socks_request->address, ec->socks_request->address,
 205           sizeof(ec2->socks_request->address));
 206
 207   ec2->socks_request->command = SOCKS_COMMAND_CONNECT;
 208   connection_ap_handshake_rewrite(ec2, &rr);
 209
 210   tt_int_op(rr.automap, OP_EQ, 0);
 211   tt_int_op(rr.should_close, OP_EQ, 0);
 212   tt_int_op(rr.end_reason, OP_EQ, 0);
 213   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 214   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 215   tt_str_op(rr.orig_address, OP_EQ, ec->socks_request->address);
 216   tt_str_op(ec2->original_dest_address, OP_EQ, ec->socks_request->address);
 217   tt_str_op(ec2->socks_request->address, OP_EQ, "www.mit.edu");
 218
 219   /* Resolve it again, make sure the answer is the same. */
 220   strlcpy(ec3->socks_request->address, "www.MIT.EDU",
 221           sizeof(ec3->socks_request->address));
 222   ec3->socks_request->command = SOCKS_COMMAND_RESOLVE;
 223   connection_ap_handshake_rewrite(ec3, &rr);
 224
 225   tt_int_op(rr.automap, OP_EQ, 1);
 226   tt_int_op(rr.should_close, OP_EQ, 0);
 227   tt_int_op(rr.end_reason, OP_EQ, 0);
 228   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 229   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 230   tt_str_op(rr.orig_address, OP_EQ, "www.mit.edu");
 231   tt_str_op(ec3->original_dest_address, OP_EQ, "www.mit.edu");
 232
 233   tt_str_op(ec3->socks_request->address, OP_EQ,
 234             ec->socks_request->address);
 235
 236  done:
 237   connection_free_minimal(ENTRY_TO_CONN(ec));
 238   connection_free_minimal(ENTRY_TO_CONN(ec2));
 239   connection_free_minimal(ENTRY_TO_CONN(ec3));
 240 }
 241
 242 #if 0
 243 /* FFFF not actually supported. */
 244 /* automap on resolve, reverse lookup. */
 245 static void
 246 test_entryconn_rewrite_automap_reverse(void *arg)
 247 {
 248   entry_connection_t *ec = arg;
 249   entry_connection_t *ec2=NULL;
 250   rewrite_result_t rr;
 251   char *msg = NULL;
 252
 253   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 254
 255   get_options_mutable()->AutomapHostsOnResolve = 1;
 256   get_options_mutable()->SafeLogging_ = SAFELOG_SCRUB_NONE;
 257   smartlist_add(get_options_mutable()->AutomapHostsSuffixes,
 258                 tor_strdup(".bloom"));
 259   parse_virtual_addr_network("127.80.0.0/16", AF_INET, 0, &msg);
 260
 261   /* Automap this on resolve. */
 262   strlcpy(ec->socks_request->address, "www.poldy.BLOOM",
 263           sizeof(ec->socks_request->address));
 264   ec->socks_request->command = SOCKS_COMMAND_RESOLVE;
 265   connection_ap_handshake_rewrite(ec, &rr);
 266
 267   tt_int_op(rr.automap, OP_EQ, 1);
 268   tt_int_op(rr.should_close, OP_EQ, 0);
 269   tt_int_op(rr.end_reason, OP_EQ, 0);
 270   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 271   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 272   tt_str_op(rr.orig_address, OP_EQ, "www.poldy.bloom");
 273   tt_str_op(ec->original_dest_address, OP_EQ, "www.poldy.bloom");
 274
 275   tt_assert(!strcmpstart(ec->socks_request->address,"127.80."));
 276
 277   strlcpy(ec2->socks_request->address, ec->socks_request->address,
 278           sizeof(ec2->socks_request->address));
 279   ec2->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR;
 280   connection_ap_handshake_rewrite(ec2, &rr);
 281
 282   tt_int_op(rr.automap, OP_EQ, 0);
 283   tt_int_op(rr.should_close, OP_EQ, 1);
 284   tt_int_op(rr.end_reason, OP_EQ,
 285           END_STREAM_REASON_DONE|END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
 286   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 287   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 288
 289  done:
 290   connection_free_minimal(ENTRY_TO_CONN(ec2));
 291 }
 292 #endif /* 0 */
 293
 294 /* Rewrite because of cached DNS entry. */
 295 static void
 296 test_entryconn_rewrite_cached_dns_ipv4(void *arg)
 297 {
 298   entry_connection_t *ec = arg;
 299   rewrite_result_t rr;
 300   time_t expires = time(NULL) + 3600;
 301   entry_connection_t *ec2=NULL;
 302
 303   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 304
 305   addressmap_register("www.friendly.example.com",
 306                       tor_strdup("240.240.241.241"),
 307                       expires,
 308                       ADDRMAPSRC_DNS,
 309                       0, 0, 0);
 310
 311   strlcpy(ec->socks_request->address, "www.friendly.example.com",
 312           sizeof(ec->socks_request->address));
 313   strlcpy(ec2->socks_request->address, "www.friendly.example.com",
 314           sizeof(ec2->socks_request->address));
 315
 316   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 317   ec2->socks_request->command = SOCKS_COMMAND_CONNECT;
 318
 319   ec2->entry_cfg.use_cached_ipv4_answers = 1; /* only ec2 gets this flag */
 320   connection_ap_handshake_rewrite(ec, &rr);
 321
 322   tt_int_op(rr.automap, OP_EQ, 0);
 323   tt_int_op(rr.should_close, OP_EQ, 0);
 324   tt_int_op(rr.end_reason, OP_EQ, 0);
 325   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 326   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 327   tt_str_op(rr.orig_address, OP_EQ, "www.friendly.example.com");
 328   tt_str_op(ec->socks_request->address, OP_EQ, "www.friendly.example.com");
 329
 330   connection_ap_handshake_rewrite(ec2, &rr);
 331   tt_int_op(rr.automap, OP_EQ, 0);
 332   tt_int_op(rr.should_close, OP_EQ, 0);
 333   tt_int_op(rr.end_reason, OP_EQ, 0);
 334   tt_i64_op(rr.map_expires, OP_EQ, expires);
 335   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 336   tt_str_op(rr.orig_address, OP_EQ, "www.friendly.example.com");
 337   tt_str_op(ec2->socks_request->address, OP_EQ, "240.240.241.241");
 338
 339  done:
 340   connection_free_minimal(ENTRY_TO_CONN(ec2));
 341 }
 342
 343 /* Rewrite because of cached DNS entry. */
 344 static void
 345 test_entryconn_rewrite_cached_dns_ipv6(void *arg)
 346 {
 347   entry_connection_t *ec = NULL;
 348   rewrite_result_t rr;
 349   time_t expires = time(NULL) + 3600;
 350   entry_connection_t *ec2=NULL;
 351
 352   (void)arg;
 353
 354   ec  = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 355   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 356
 357   addressmap_register("www.friendly.example.com",
 358                       tor_strdup("[::f00f]"),
 359                       expires,
 360                       ADDRMAPSRC_DNS,
 361                       0, 0, 0);
 362
 363   strlcpy(ec->socks_request->address, "www.friendly.example.com",
 364           sizeof(ec->socks_request->address));
 365   strlcpy(ec2->socks_request->address, "www.friendly.example.com",
 366           sizeof(ec2->socks_request->address));
 367
 368   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 369   ec2->socks_request->command = SOCKS_COMMAND_CONNECT;
 370
 371   ec2->entry_cfg.use_cached_ipv6_answers = 1; /* only ec2 gets this flag */
 372   connection_ap_handshake_rewrite(ec, &rr);
 373
 374   tt_int_op(rr.automap, OP_EQ, 0);
 375   tt_int_op(rr.should_close, OP_EQ, 0);
 376   tt_int_op(rr.end_reason, OP_EQ, 0);
 377   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 378   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 379   tt_str_op(rr.orig_address, OP_EQ, "www.friendly.example.com");
 380   tt_str_op(ec->socks_request->address, OP_EQ, "www.friendly.example.com");
 381
 382   connection_ap_handshake_rewrite(ec2, &rr);
 383   tt_int_op(rr.automap, OP_EQ, 0);
 384   tt_int_op(rr.should_close, OP_EQ, 0);
 385   tt_int_op(rr.end_reason, OP_EQ, 0);
 386   tt_i64_op(rr.map_expires, OP_EQ, expires);
 387   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 388   tt_str_op(rr.orig_address, OP_EQ, "www.friendly.example.com");
 389   tt_str_op(ec2->socks_request->address, OP_EQ, "[::f00f]");
 390
 391  done:
 392   connection_free_minimal(ENTRY_TO_CONN(ec));
 393   connection_free_minimal(ENTRY_TO_CONN(ec2));
 394 }
 395
 396 /* Fail to connect to unmapped address in virtual range. */
 397 static void
 398 test_entryconn_rewrite_unmapped_virtual(void *arg)
 399 {
 400   entry_connection_t *ec = arg;
 401   rewrite_result_t rr;
 402   entry_connection_t *ec2 = NULL;
 403   char *msg = NULL;
 404
 405   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET6);
 406
 407   parse_virtual_addr_network("18.202.0.0/16", AF_INET, 0, &msg);
 408   parse_virtual_addr_network("[ABCD::]/16", AF_INET6, 0, &msg);
 409
 410   strlcpy(ec->socks_request->address, "18.202.5.5",
 411           sizeof(ec->socks_request->address));
 412   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 413   connection_ap_handshake_rewrite(ec, &rr);
 414
 415   tt_int_op(rr.should_close, OP_EQ, 1);
 416   tt_int_op(rr.end_reason, OP_EQ, END_STREAM_REASON_INTERNAL);
 417   tt_int_op(rr.automap, OP_EQ, 0);
 418   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 419   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 420
 421   strlcpy(ec2->socks_request->address, "[ABCD:9::5314:9543]",
 422           sizeof(ec2->socks_request->address));
 423   ec2->socks_request->command = SOCKS_COMMAND_CONNECT;
 424   connection_ap_handshake_rewrite(ec2, &rr);
 425
 426   tt_int_op(rr.should_close, OP_EQ, 1);
 427   tt_int_op(rr.end_reason, OP_EQ, END_STREAM_REASON_INTERNAL);
 428   tt_int_op(rr.automap, OP_EQ, 0);
 429   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 430   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 431
 432  done:
 433   connection_free_minimal(ENTRY_TO_CONN(ec2));
 434 }
 435
 436 /* Rewrite because of mapaddress option */
 437 static void
 438 test_entryconn_rewrite_mapaddress(void *arg)
 439 {
 440   entry_connection_t *ec = arg;
 441   rewrite_result_t rr;
 442
 443   config_line_append(&get_options_mutable()->AddressMap,
 444                      "MapAddress", "meta metaobjects.example");
 445   config_register_addressmaps(get_options());
 446
 447   strlcpy(ec->socks_request->address, "meta",
 448           sizeof(ec->socks_request->address));
 449   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 450   connection_ap_handshake_rewrite(ec, &rr);
 451
 452   tt_int_op(rr.should_close, OP_EQ, 0);
 453   tt_int_op(rr.end_reason, OP_EQ, 0);
 454   tt_int_op(rr.automap, OP_EQ, 0);
 455   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 456   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 457   tt_str_op(ec->socks_request->address, OP_EQ, "metaobjects.example");
 458
 459  done:
 460   ;
 461 }
 462
 463 /* Reject reverse lookups of internal address. */
 464 static void
 465 test_entryconn_rewrite_reject_internal_reverse(void *arg)
 466 {
 467   entry_connection_t *ec = arg;
 468   rewrite_result_t rr;
 469
 470   strlcpy(ec->socks_request->address, "10.0.0.1",
 471           sizeof(ec->socks_request->address));
 472   ec->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR;
 473   connection_ap_handshake_rewrite(ec, &rr);
 474
 475   tt_int_op(rr.should_close, OP_EQ, 1);
 476   tt_int_op(rr.end_reason, OP_EQ, END_STREAM_REASON_SOCKSPROTOCOL |
 477             END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
 478   tt_int_op(rr.automap, OP_EQ, 0);
 479   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 480   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 481
 482  done:
 483   ;
 484 }
 485
 486 /* Rewrite into .exit because of virtual address mapping.  */
 487 static void
 488 test_entryconn_rewrite_automap_exit(void *arg)
 489 {
 490   entry_connection_t *ec = arg;
 491   entry_connection_t *ec2=NULL;
 492   rewrite_result_t rr;
 493   char *msg = NULL;
 494
 495   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 496
 497   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes,
 498                 ".EXIT");
 499   parse_virtual_addr_network("127.1.0.0/16", AF_INET, 0, &msg);
 500
 501   /* Try to automap this on resolve. */
 502   strlcpy(ec->socks_request->address, "website.example.exit",
 503           sizeof(ec->socks_request->address));
 504   ec->socks_request->command = SOCKS_COMMAND_RESOLVE;
 505   connection_ap_handshake_rewrite(ec, &rr);
 506
 507   /* Make sure it isn't allowed -- there is no longer an AllowDotExit
 508    * option. */
 509   tt_int_op(rr.automap, OP_EQ, 0);
 510   tt_int_op(rr.should_close, OP_EQ, 1);
 511   tt_int_op(rr.end_reason, OP_EQ, END_STREAM_REASON_TORPROTOCOL);
 512
 513  done:
 514   connection_free_minimal(ENTRY_TO_CONN(ec2));
 515 }
 516
 517 /* Rewrite into .exit because of mapaddress */
 518 static void
 519 test_entryconn_rewrite_mapaddress_exit(void *arg)
 520 {
 521   entry_connection_t *ec = arg;
 522   rewrite_result_t rr;
 523
 524   config_line_append(&get_options_mutable()->AddressMap,
 525                      "MapAddress", "*.example.com  *.example.com.abc.exit");
 526   config_register_addressmaps(get_options());
 527
 528   /* Automap this on resolve. */
 529   strlcpy(ec->socks_request->address, "abc.example.com",
 530           sizeof(ec->socks_request->address));
 531   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 532   connection_ap_handshake_rewrite(ec, &rr);
 533
 534   tt_int_op(rr.automap, OP_EQ, 0);
 535   tt_int_op(rr.should_close, OP_EQ, 0);
 536   tt_int_op(rr.end_reason, OP_EQ, 0);
 537   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 538   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_TORRC);
 539   tt_str_op(rr.orig_address, OP_EQ, "abc.example.com");
 540   tt_str_op(ec->socks_request->address, OP_EQ, "abc.example.com.abc.exit");
 541  done:
 542   ;
 543 }
 544
 545 /* Map foo.onion to longthing.onion, and also automap. */
 546 static void
 547 test_entryconn_rewrite_mapaddress_automap_onion(void *arg)
 548 {
 549   entry_connection_t *ec = arg;
 550   entry_connection_t *ec2 = NULL;
 551   entry_connection_t *ec3 = NULL;
 552   entry_connection_t *ec4 = NULL;
 553   rewrite_result_t rr;
 554   char *msg = NULL;
 555
 556   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 557   ec3 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 558   ec4 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 559
 560   get_options_mutable()->AutomapHostsOnResolve = 1;
 561   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes,
 562                 ".onion");
 563   parse_virtual_addr_network("192.168.0.0/16", AF_INET, 0, &msg);
 564   config_line_append(&get_options_mutable()->AddressMap,
 565                      "MapAddress", "foo.onion abcdefghijklmnop.onion");
 566   config_register_addressmaps(get_options());
 567
 568   /* Connect to foo.onion. */
 569   strlcpy(ec->socks_request->address, "foo.onion",
 570           sizeof(ec->socks_request->address));
 571   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 572   connection_ap_handshake_rewrite(ec, &rr);
 573
 574   tt_int_op(rr.automap, OP_EQ, 0);
 575   tt_int_op(rr.should_close, OP_EQ, 0);
 576   tt_int_op(rr.end_reason, OP_EQ, 0);
 577   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 578   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 579   tt_str_op(rr.orig_address, OP_EQ, "foo.onion");
 580   tt_str_op(ec->socks_request->address, OP_EQ, "abcdefghijklmnop.onion");
 581
 582   /* Okay, resolve foo.onion */
 583   strlcpy(ec2->socks_request->address, "foo.onion",
 584           sizeof(ec2->socks_request->address));
 585   ec2->socks_request->command = SOCKS_COMMAND_RESOLVE;
 586   connection_ap_handshake_rewrite(ec2, &rr);
 587
 588   tt_int_op(rr.automap, OP_EQ, 1);
 589   tt_int_op(rr.should_close, OP_EQ, 0);
 590   tt_int_op(rr.end_reason, OP_EQ, 0);
 591   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 592   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 593   tt_str_op(rr.orig_address, OP_EQ, "foo.onion");
 594   tt_assert(!strcmpstart(ec2->socks_request->address, "192.168."));
 595
 596   /* Now connect */
 597   strlcpy(ec3->socks_request->address, ec2->socks_request->address,
 598           sizeof(ec3->socks_request->address));
 599   ec3->socks_request->command = SOCKS_COMMAND_CONNECT;
 600   connection_ap_handshake_rewrite(ec3, &rr);
 601   tt_int_op(rr.automap, OP_EQ, 0);
 602   tt_int_op(rr.should_close, OP_EQ, 0);
 603   tt_int_op(rr.end_reason, OP_EQ, 0);
 604   tt_assert(!strcmpstart(ec3->socks_request->address,
 605                          "abcdefghijklmnop.onion"));
 606
 607   /* Now resolve abcefghijklmnop.onion. */
 608   strlcpy(ec4->socks_request->address, "abcdefghijklmnop.onion",
 609           sizeof(ec4->socks_request->address));
 610   ec4->socks_request->command = SOCKS_COMMAND_RESOLVE;
 611   connection_ap_handshake_rewrite(ec4, &rr);
 612
 613   tt_int_op(rr.automap, OP_EQ, 1);
 614   tt_int_op(rr.should_close, OP_EQ, 0);
 615   tt_int_op(rr.end_reason, OP_EQ, 0);
 616   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 617   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 618   tt_str_op(rr.orig_address, OP_EQ, "abcdefghijklmnop.onion");
 619   tt_assert(!strcmpstart(ec4->socks_request->address, "192.168."));
 620   /* XXXX doesn't work
 621    tt_str_op(ec4->socks_request->address, OP_EQ, ec2->socks_request->address);
 622   */
 623
 624  done:
 625   connection_free_minimal(ENTRY_TO_CONN(ec2));
 626   connection_free_minimal(ENTRY_TO_CONN(ec3));
 627   connection_free_minimal(ENTRY_TO_CONN(ec4));
 628 }
 629
 630 static void
 631 test_entryconn_rewrite_mapaddress_automap_onion_common(entry_connection_t *ec,
 632                                                        int map_to_onion,
 633                                                        int map_to_address)
 634 {
 635   entry_connection_t *ec2 = NULL;
 636   entry_connection_t *ec3 = NULL;
 637   rewrite_result_t rr;
 638
 639   ec2 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 640   ec3 = entry_connection_new(CONN_TYPE_AP, AF_INET);
 641
 642   /* Connect to irc.example.com */
 643   strlcpy(ec->socks_request->address, "irc.example.com",
 644           sizeof(ec->socks_request->address));
 645   ec->socks_request->command = SOCKS_COMMAND_CONNECT;
 646   connection_ap_handshake_rewrite(ec, &rr);
 647
 648   tt_int_op(rr.automap, OP_EQ, 0);
 649   tt_int_op(rr.should_close, OP_EQ, 0);
 650   tt_int_op(rr.end_reason, OP_EQ, 0);
 651   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 652   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 653   tt_str_op(rr.orig_address, OP_EQ, "irc.example.com");
 654   tt_str_op(ec->socks_request->address, OP_EQ,
 655             map_to_onion ? "abcdefghijklmnop.onion" : "irc.example.com");
 656
 657   /* Okay, resolve irc.example.com */
 658   strlcpy(ec2->socks_request->address, "irc.example.com",
 659           sizeof(ec2->socks_request->address));
 660   ec2->socks_request->command = SOCKS_COMMAND_RESOLVE;
 661   connection_ap_handshake_rewrite(ec2, &rr);
 662
 663   tt_int_op(rr.automap, OP_EQ, map_to_onion && map_to_address);
 664   tt_int_op(rr.should_close, OP_EQ, 0);
 665   tt_int_op(rr.end_reason, OP_EQ, 0);
 666   tt_i64_op(rr.map_expires, OP_EQ, TIME_MAX);
 667   tt_int_op(rr.exit_source, OP_EQ, ADDRMAPSRC_NONE);
 668   tt_str_op(rr.orig_address, OP_EQ, "irc.example.com");
 669   if (map_to_onion && map_to_address)
 670     tt_assert(!strcmpstart(ec2->socks_request->address, "192.168."));
 671
 672   /* Now connect */
 673   strlcpy(ec3->socks_request->address, ec2->socks_request->address,
 674           sizeof(ec3->socks_request->address));
 675   ec3->socks_request->command = SOCKS_COMMAND_CONNECT;
 676   connection_ap_handshake_rewrite(ec3, &rr);
 677   tt_int_op(rr.automap, OP_EQ, 0);
 678   tt_int_op(rr.should_close, OP_EQ, 0);
 679   tt_int_op(rr.end_reason, OP_EQ, 0);
 680   if (map_to_onion)
 681     tt_assert(!strcmpstart(ec3->socks_request->address,
 682                            "abcdefghijklmnop.onion"));
 683
 684  done:
 685   connection_free_minimal(ENTRY_TO_CONN(ec2));
 686   connection_free_minimal(ENTRY_TO_CONN(ec3));
 687 }
 688
 689 /* This time is the same, but we start with a mapping from a non-onion
 690  * address. */
 691 static void
 692 test_entryconn_rewrite_mapaddress_automap_onion2(void *arg)
 693 {
 694   char *msg = NULL;
 695   get_options_mutable()->AutomapHostsOnResolve = 1;
 696   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes,
 697                 ".onion");
 698   parse_virtual_addr_network("192.168.0.0/16", AF_INET, 0, &msg);
 699   config_line_append(&get_options_mutable()->AddressMap,
 700                      "MapAddress", "irc.example.com abcdefghijklmnop.onion");
 701   config_register_addressmaps(get_options());
 702
 703   test_entryconn_rewrite_mapaddress_automap_onion_common(arg, 1, 1);
 704 }
 705
 706 /* Same as above, with automapped turned off */
 707 static void
 708 test_entryconn_rewrite_mapaddress_automap_onion3(void *arg)
 709 {
 710   config_line_append(&get_options_mutable()->AddressMap,
 711                      "MapAddress", "irc.example.com abcdefghijklmnop.onion");
 712   config_register_addressmaps(get_options());
 713
 714   test_entryconn_rewrite_mapaddress_automap_onion_common(arg, 1, 0);
 715 }
 716
 717 /* As above, with no mapping. */
 718 static void
 719 test_entryconn_rewrite_mapaddress_automap_onion4(void *arg)
 720 {
 721   char *msg = NULL;
 722   get_options_mutable()->AutomapHostsOnResolve = 1;
 723   smartlist_add_strdup(get_options_mutable()->AutomapHostsSuffixes,
 724                 ".onion");
 725   parse_virtual_addr_network("192.168.0.0/16", AF_INET, 0, &msg);
 726
 727   test_entryconn_rewrite_mapaddress_automap_onion_common(arg, 0, 1);
 728 }
 729
 730 /** Test that rewrite functions can handle v3 onion addresses */
 731 static void
 732 test_entryconn_rewrite_onion_v3(void *arg)
 733 {
 734   int retval;
 735   entry_connection_t *conn = arg;
 736
 737   (void) arg;
 738
 739   hs_cache_init();
 740
 741   /* Make a SOCKS request */
 742   conn->socks_request->command = SOCKS_COMMAND_CONNECT;
 743   strlcpy(conn->socks_request->address,
 744           "git.25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid.onion",
 745           sizeof(conn->socks_request->address));
 746
 747   /* Make an onion connection using the SOCKS request */
 748   conn->entry_cfg.onion_traffic = 1;
 749   ENTRY_TO_CONN(conn)->state = AP_CONN_STATE_SOCKS_WAIT;
 750   tt_assert(!ENTRY_TO_EDGE_CONN(conn)->hs_ident);
 751
 752   /* Handle SOCKS and rewrite! */
 753   retval = connection_ap_handshake_rewrite_and_attach(conn, NULL, NULL);
 754   tt_int_op(retval, OP_EQ, 0);
 755
 756   /* Check connection state after rewrite. It should be in waiting for
 757    * descriptor state. */
 758   tt_int_op(ENTRY_TO_CONN(conn)->state, OP_EQ, AP_CONN_STATE_RENDDESC_WAIT);
 759   /* check that the address got rewritten */
 760   tt_str_op(conn->socks_request->address, OP_EQ,
 761             "25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid");
 762   /* check that HS information got attached to the connection */
 763   tt_assert(ENTRY_TO_EDGE_CONN(conn)->hs_ident);
 764
 765  done:
 766   hs_free_all();
 767   /* 'conn' is cleaned by handler */
 768 }
 769
 770 #define REWRITE(name)                           \
 771   { #name, test_entryconn_##name, TT_FORK, &test_rewrite_setup, NULL }
 772
 773 struct testcase_t entryconn_tests[] = {
 774   REWRITE(rewrite_basic),
 775   REWRITE(rewrite_bad_dotexit),
 776   REWRITE(rewrite_automap_ipv4),
 777   REWRITE(rewrite_automap_ipv6),
 778   // REWRITE(rewrite_automap_reverse),
 779   REWRITE(rewrite_cached_dns_ipv4),
 780   REWRITE(rewrite_cached_dns_ipv6),
 781   REWRITE(rewrite_unmapped_virtual),
 782   REWRITE(rewrite_mapaddress),
 783   REWRITE(rewrite_reject_internal_reverse),
 784   REWRITE(rewrite_automap_exit),
 785   REWRITE(rewrite_mapaddress_exit),
 786   REWRITE(rewrite_mapaddress_automap_onion),
 787   REWRITE(rewrite_mapaddress_automap_onion2),
 788   REWRITE(rewrite_mapaddress_automap_onion3),
 789   REWRITE(rewrite_mapaddress_automap_onion4),
 790   REWRITE(rewrite_onion_v3),
 791
 792   END_OF_TESTCASES
 793 };