src/tools/tor-resolve.c

   1 /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson
   2  * Copyright (c) 2007-2019, The Tor Project, Inc.
   3  */
   4 /* See LICENSE for licensing information */
   5
   6 #include "orconfig.h"
   7
   8 #include "lib/arch/bytes.h"
   9 #include "lib/log/log.h"
  10 #include "lib/malloc/malloc.h"
  11 #include "lib/net/address.h"
  12 #include "lib/net/resolve.h"
  13 #include "lib/net/socket.h"
  14 #include "lib/sandbox/sandbox.h"
  15 #include "lib/string/util_string.h"
  16
  17 #include "lib/net/socks5_status.h"
  18 #include "trunnel/socks5.h"
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #ifdef HAVE_NETINET_IN_H
  26 #include <netinet/in.h>
  27 #endif
  28 #ifdef HAVE_ARPA_INET_H
  29 #include <arpa/inet.h>
  30 #endif
  31 #ifdef HAVE_SYS_SOCKET_H
  32 #include <sys/socket.h>
  33 #endif
  34 #ifdef HAVE_SYS_TYPES_H
  35 #include <sys/types.h> /* Must be included before sys/stat.h for Ultrix */
  36 #endif
  37 #ifdef HAVE_ERRNO_H
  38 #include <errno.h>
  39 #endif
  40
  41 #ifdef _WIN32
  42 #include <winsock2.h>
  43 #include <ws2tcpip.h>
  44 #endif
  45
  46 #define RESPONSE_LEN_4 8
  47 #define log_sock_error(act, _s)                                         \
  48   STMT_BEGIN log_fn(LOG_ERR, LD_NET, "Error while %s: %s", act,         \
  49               tor_socket_strerror(tor_socket_errno(_s))); STMT_END
  50
  51 static void usage(void) ATTR_NORETURN;
  52
  53 /**
  54  * Set <b>out</b> to a pointer to newly allocated buffer containing
  55  * SOCKS4a RESOLVE request with <b>username</b> and <b>hostname</b>.
  56  * Return number of bytes in the buffer if succeeded or -1 if failed.
  57  */
  58 static ssize_t
  59 build_socks4a_resolve_request(uint8_t **out,
  60                               const char *username,
  61                               const char *hostname)
  62 {
  63   tor_assert(out);
  64   tor_assert(username);
  65   tor_assert(hostname);
  66
  67   const char *errmsg = NULL;
  68   uint8_t *output = NULL;
  69   socks4_client_request_t *rq = socks4_client_request_new();
  70
  71   socks4_client_request_set_version(rq, 4);
  72   socks4_client_request_set_command(rq, CMD_RESOLVE);
  73   socks4_client_request_set_port(rq, 0);
  74   socks4_client_request_set_addr(rq, 0x00000001u);
  75   socks4_client_request_set_username(rq, username);
  76   socks4_client_request_set_socks4a_addr_hostname(rq, hostname);
  77
  78   errmsg = socks4_client_request_check(rq);
  79   if (errmsg) {
  80     goto cleanup;
  81   }
  82
  83   ssize_t encoded_len = socks4_client_request_encoded_len(rq);
  84   if (encoded_len <= 0) {
  85     errmsg = "socks4_client_request_encoded_len failed";
  86     goto cleanup;
  87   }
  88
  89   output = tor_malloc(encoded_len);
  90   memset(output, 0, encoded_len);
  91
  92   encoded_len = socks4_client_request_encode(output, encoded_len, rq);
  93   if (encoded_len <= 0) {
  94     errmsg = "socks4_client_request_encode failed";
  95     goto cleanup;
  96   }
  97
  98   *out = output;
  99
 100  cleanup:
 101   socks4_client_request_free(rq);
 102   if (errmsg) {
 103     log_err(LD_NET, "build_socks4a_resolve_request failed: %s", errmsg);
 104     *out = NULL;
 105     tor_free(output);
 106   }
 107   return errmsg ? -1 : encoded_len;
 108 }
 109
 110 #define SOCKS5_ATYPE_HOSTNAME 0x03
 111 #define SOCKS5_ATYPE_IPV4     0x01
 112 #define SOCKS5_ATYPE_IPV6     0x04
 113
 114 /**
 115  * Set <b>out</b> to pointer to newly allocated buffer containing
 116  * SOCKS5 RESOLVE/RESOLVE_PTR request with given <b>hostname<b>.
 117  * Generate a reverse request if <b>reverse</b> is true.
 118  * Return the number of bytes in the buffer if succeeded or -1 if failed.
 119  */
 120 static ssize_t
 121 build_socks5_resolve_request(uint8_t **out,
 122                              const char *hostname,
 123                              int reverse)
 124 {
 125   const char *errmsg = NULL;
 126   uint8_t *outbuf = NULL;
 127   int is_ip_address;
 128   tor_addr_t addr;
 129   size_t addrlen;
 130   int ipv6;
 131   is_ip_address = tor_addr_parse(&addr, hostname) != -1;
 132   if (!is_ip_address && reverse) {
 133     log_err(LD_GENERAL, "Tried to do a reverse lookup on a non-IP!");
 134     return -1;
 135   }
 136   ipv6 = reverse && tor_addr_family(&addr) == AF_INET6;
 137   addrlen = reverse ? (ipv6 ? 16 : 4) : 1 + strlen(hostname);
 138   if (addrlen > UINT8_MAX) {
 139     log_err(LD_GENERAL, "Hostname is too long!");
 140     return -1;
 141   }
 142
 143   socks5_client_request_t *rq = socks5_client_request_new();
 144
 145   socks5_client_request_set_version(rq, 5);
 146   /* RESOLVE_PTR or RESOLVE */
 147   socks5_client_request_set_command(rq, reverse ? CMD_RESOLVE_PTR :
 148                                                   CMD_RESOLVE);
 149   socks5_client_request_set_reserved(rq, 0);
 150
 151   uint8_t atype = SOCKS5_ATYPE_HOSTNAME;
 152   if (reverse)
 153     atype = ipv6 ? SOCKS5_ATYPE_IPV6 : SOCKS5_ATYPE_IPV4;
 154
 155   socks5_client_request_set_atype(rq, atype);
 156
 157   switch (atype) {
 158     case SOCKS5_ATYPE_IPV4: {
 159       socks5_client_request_set_dest_addr_ipv4(rq,
 160                                         tor_addr_to_ipv4h(&addr));
 161     } break;
 162     case SOCKS5_ATYPE_IPV6: {
 163       uint8_t *ipv6_array =
 164         socks5_client_request_getarray_dest_addr_ipv6(rq);
 165
 166       tor_assert(ipv6_array);
 167
 168       memcpy(ipv6_array, tor_addr_to_in6_addr8(&addr), 16);
 169     } break;
 170
 171     case SOCKS5_ATYPE_HOSTNAME: {
 172       domainname_t *dn = domainname_new();
 173       domainname_set_len(dn, addrlen - 1);
 174       domainname_setlen_name(dn, addrlen - 1);
 175       char *dn_buf = domainname_getarray_name(dn);
 176       memcpy(dn_buf, hostname, addrlen - 1);
 177
 178       errmsg = domainname_check(dn);
 179
 180       if (errmsg) {
 181         domainname_free(dn);
 182         goto cleanup;
 183       } else {
 184         socks5_client_request_set_dest_addr_domainname(rq, dn);
 185       }
 186     } break;
 187     default:
 188       tor_assert_unreached();
 189       break;
 190   }
 191
 192   socks5_client_request_set_dest_port(rq, 0);
 193
 194   errmsg = socks5_client_request_check(rq);
 195   if (errmsg) {
 196     goto cleanup;
 197   }
 198
 199   ssize_t encoded_len = socks5_client_request_encoded_len(rq);
 200   if (encoded_len < 0) {
 201     errmsg = "Cannot predict encoded length";
 202     goto cleanup;
 203   }
 204
 205   outbuf = tor_malloc(encoded_len);
 206   memset(outbuf, 0, encoded_len);
 207
 208   encoded_len = socks5_client_request_encode(outbuf, encoded_len, rq);
 209   if (encoded_len < 0) {
 210     errmsg = "encoding failed";
 211     goto cleanup;
 212   }
 213
 214   *out = outbuf;
 215
 216  cleanup:
 217   socks5_client_request_free(rq);
 218   if (errmsg) {
 219     tor_free(outbuf);
 220     log_err(LD_NET, "build_socks5_resolve_request failed with error: %s",
 221             errmsg);
 222   }
 223
 224   return errmsg ? -1 : encoded_len;
 225 }
 226
 227 /** Set *<b>out</b> to a newly allocated SOCKS4a resolve request with
 228  * <b>username</b> and <b>hostname</b> as provided.  Return the number
 229  * of bytes in the request. */
 230 static ssize_t
 231 build_socks_resolve_request(uint8_t **out,
 232                             const char *username,
 233                             const char *hostname,
 234                             int reverse,
 235                             int version)
 236 {
 237   tor_assert(out);
 238   tor_assert(username);
 239   tor_assert(hostname);
 240
 241   tor_assert(version == 4 || version == 5);
 242
 243   if (version == 4) {
 244     return build_socks4a_resolve_request(out, username, hostname);
 245   } else if (version == 5) {
 246     return build_socks5_resolve_request(out, hostname, reverse);
 247   }
 248
 249   tor_assert_unreached();
 250   return -1;
 251 }
 252
 253 static void
 254 onion_warning(const char *hostname)
 255 {
 256   log_warn(LD_NET,
 257         "%s is a hidden service; those don't have IP addresses. "
 258         "You can use the AutomapHostsOnResolve option to have Tor return a "
 259         "fake address for hidden services.  Or you can have your "
 260         "application send the address to Tor directly; we recommend an "
 261         "application that uses SOCKS 5 with hostnames.",
 262            hostname);
 263 }
 264
 265 /** Given a <b>len</b>-byte SOCKS4a response in <b>response</b>, set
 266  * *<b>addr_out</b> to the address it contains (in host order).
 267  * Return 0 on success, -1 on error.
 268  */
 269 static int
 270 parse_socks4a_resolve_response(const char *hostname,
 271                                const char *response, size_t len,
 272                                tor_addr_t *addr_out)
 273 {
 274   int result = 0;
 275   uint8_t status;
 276   tor_assert(response);
 277   tor_assert(addr_out);
 278
 279   socks4_server_reply_t *reply;
 280
 281   ssize_t parsed = socks4_server_reply_parse(&reply,
 282                                              (const uint8_t *)response,
 283                                              len);
 284
 285   if (parsed == -1) {
 286     log_warn(LD_PROTOCOL, "Failed parsing SOCKS4a response");
 287     result = -1; goto cleanup;
 288   }
 289
 290   if (parsed == -2) {
 291     log_warn(LD_PROTOCOL,"Truncated socks response.");
 292     result = -1; goto cleanup;
 293   }
 294
 295   if (socks4_server_reply_get_version(reply) != 0) { /* version: 0 */
 296     log_warn(LD_PROTOCOL,"Nonzero version in socks response: bad format.");
 297     result = -1; goto cleanup;
 298   }
 299   if (socks4_server_reply_get_port(reply) != 0) { /* port: 0 */
 300     log_warn(LD_PROTOCOL,"Nonzero port in socks response: bad format.");
 301     result = -1; goto cleanup;
 302   }
 303   status = socks4_server_reply_get_status(reply);
 304   if (status != 90) {
 305     log_warn(LD_NET,"Got status response '%d': socks request failed.", status);
 306     if (!strcasecmpend(hostname, ".onion")) {
 307       onion_warning(hostname);
 308       result = -1; goto cleanup;
 309     }
 310     result = -1; goto cleanup;
 311   }
 312
 313   tor_addr_from_ipv4h(addr_out, socks4_server_reply_get_addr(reply));
 314
 315  cleanup:
 316   socks4_server_reply_free(reply);
 317   return result;
 318 }
 319
 320 /* It would be nice to let someone know what SOCKS5 issue a user may have */
 321 static const char *
 322 socks5_reason_to_string(char reason)
 323 {
 324   switch (reason) {
 325     case SOCKS5_SUCCEEDED:
 326       return "succeeded";
 327     case SOCKS5_GENERAL_ERROR:
 328       return "general error";
 329     case SOCKS5_NOT_ALLOWED:
 330       return "not allowed";
 331     case SOCKS5_NET_UNREACHABLE:
 332       return "network is unreachable";
 333     case SOCKS5_HOST_UNREACHABLE:
 334       return "host is unreachable";
 335     case SOCKS5_CONNECTION_REFUSED:
 336       return "connection refused";
 337     case SOCKS5_TTL_EXPIRED:
 338       return "ttl expired";
 339     case SOCKS5_COMMAND_NOT_SUPPORTED:
 340       return "command not supported";
 341     case SOCKS5_ADDRESS_TYPE_NOT_SUPPORTED:
 342       return "address type not supported";
 343     default:
 344       return "unknown SOCKS5 code";
 345   }
 346 }
 347
 348 /** Send a resolve request for <b>hostname</b> to the Tor listening on
 349  * <b>sockshost</b>:<b>socksport</b>.  Store the resulting IPv4
 350  * address (in host order) into *<b>result_addr</b>.
 351  */
 352 static int
 353 do_resolve(const char *hostname,
 354            const tor_addr_t *sockshost, uint16_t socksport,
 355            int reverse, int version,
 356            tor_addr_t *result_addr, char **result_hostname)
 357 {
 358   int s = -1;
 359   struct sockaddr_storage ss;
 360   socklen_t socklen;
 361   uint8_t *req = NULL;
 362   ssize_t len = 0;
 363
 364   tor_assert(hostname);
 365   tor_assert(result_addr);
 366   tor_assert(version == 4 || version == 5);
 367
 368   tor_addr_make_unspec(result_addr);
 369   *result_hostname = NULL;
 370
 371   s = tor_open_socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
 372   if (s<0) {
 373     log_sock_error("creating_socket", -1);
 374     return -1;
 375   }
 376
 377   socklen = tor_addr_to_sockaddr(sockshost, socksport,
 378                                  (struct sockaddr *)&ss, sizeof(ss));
 379
 380   if (connect(s, (struct sockaddr*)&ss, socklen)) {
 381     log_sock_error("connecting to SOCKS host", s);
 382     goto err;
 383   }
 384
 385   if (version == 5) {
 386     socks5_client_version_t *v = socks5_client_version_new();
 387
 388     socks5_client_version_set_version(v, 5);
 389     socks5_client_version_set_n_methods(v, 1);
 390     socks5_client_version_setlen_methods(v, 1);
 391     socks5_client_version_set_methods(v, 0, 0x00);
 392
 393     tor_assert(!socks5_client_version_check(v));
 394     ssize_t encoded_len = socks5_client_version_encoded_len(v);
 395     tor_assert(encoded_len > 0);
 396
 397     uint8_t *buf = tor_malloc(encoded_len);
 398     encoded_len = socks5_client_version_encode(buf, encoded_len, v);
 399     tor_assert(encoded_len > 0);
 400
 401     socks5_client_version_free(v);
 402
 403     if (write_all_to_socket(s, (const char *)buf,
 404                             encoded_len) != encoded_len) {
 405       log_err(LD_NET, "Error sending SOCKS5 method list.");
 406       tor_free(buf);
 407
 408       goto err;
 409     }
 410
 411     tor_free(buf);
 412
 413     uint8_t method_buf[2];
 414
 415     if (read_all_from_socket(s, (char *)method_buf, 2) != 2) {
 416       log_err(LD_NET, "Error reading SOCKS5 methods.");
 417       goto err;
 418     }
 419
 420     socks5_server_method_t *m;
 421     ssize_t parsed = socks5_server_method_parse(&m, method_buf,
 422                                                 sizeof(method_buf));
 423
 424     if (parsed < 2) {
 425       log_err(LD_NET, "Failed to parse SOCKS5 method selection "
 426                       "message");
 427       goto err;
 428     }
 429
 430     uint8_t method = socks5_server_method_get_method(m);
 431
 432     socks5_server_method_free(m);
 433
 434     if (method != 0x00) {
 435       log_err(LD_NET, "Unrecognized socks authentication method: %u",
 436               (unsigned)method);
 437       goto err;
 438     }
 439   }
 440
 441   if ((len = build_socks_resolve_request(&req, "", hostname, reverse,
 442                                          version))<0) {
 443     log_err(LD_BUG,"Error generating SOCKS request");
 444     tor_assert(!req);
 445     goto err;
 446   }
 447   if (write_all_to_socket(s, (const char *)req, len) != len) {
 448     log_sock_error("sending SOCKS request", s);
 449     tor_free(req);
 450     goto err;
 451   }
 452   tor_free(req);
 453
 454   if (version == 4) {
 455     char reply_buf[RESPONSE_LEN_4];
 456     if (read_all_from_socket(s, reply_buf, RESPONSE_LEN_4) != RESPONSE_LEN_4) {
 457       log_err(LD_NET, "Error reading SOCKS4 response.");
 458       goto err;
 459     }
 460     if (parse_socks4a_resolve_response(hostname,
 461                                        reply_buf, RESPONSE_LEN_4,
 462                                        result_addr)<0) {
 463       goto err;
 464     }
 465   } else {
 466     uint8_t reply_buf[512];
 467
 468     len = read_all_from_socket(s, (char *)reply_buf,
 469                                sizeof(reply_buf));
 470
 471     socks5_server_reply_t *reply;
 472
 473     ssize_t parsed = socks5_server_reply_parse(&reply,
 474                                                reply_buf,
 475                                                len);
 476     if (parsed == -1) {
 477       log_err(LD_NET, "Failed parsing SOCKS5 response");
 478       goto err;
 479     }
 480
 481     if (parsed == -2) {
 482       log_err(LD_NET, "Truncated SOCKS5 response");
 483       goto err;
 484     }
 485
 486     /* Give a user some useful feedback about SOCKS5 errors */
 487     uint8_t reply_field = socks5_server_reply_get_reply(reply);
 488     if (reply_field != 0) {
 489       log_warn(LD_NET,"Got SOCKS5 status response '%u': %s",
 490                (unsigned)reply_field,
 491                socks5_reason_to_string(reply_field));
 492       if (reply_field == 4 && !strcasecmpend(hostname, ".onion")) {
 493         onion_warning(hostname);
 494       }
 495
 496       socks5_server_reply_free(reply);
 497       goto err;
 498     }
 499
 500     uint8_t atype = socks5_server_reply_get_atype(reply);
 501
 502     if (atype == SOCKS5_ATYPE_IPV4) {
 503       /* IPv4 address */
 504       tor_addr_from_ipv4h(result_addr,
 505         socks5_server_reply_get_bind_addr_ipv4(reply));
 506     } else if (atype == SOCKS5_ATYPE_IPV6) {
 507       /* IPv6 address */
 508       tor_addr_from_ipv6_bytes(result_addr,
 509         (const char *)socks5_server_reply_getarray_bind_addr_ipv6(reply));
 510     } else if (atype == SOCKS5_ATYPE_HOSTNAME) {
 511       /* Domain name */
 512       domainname_t *dn =
 513         socks5_server_reply_get_bind_addr_domainname(reply);
 514
 515       *result_hostname = tor_strdup(domainname_getstr_name(dn));
 516     }
 517
 518     socks5_server_reply_free(reply);
 519   }
 520
 521   tor_close_socket(s);
 522   return 0;
 523  err:
 524   tor_close_socket(s);
 525   return -1;
 526 }
 527
 528 /** Print a usage message and exit. */
 529 static void
 530 usage(void)
 531 {
 532   puts("Syntax: tor-resolve [-4] [-5] [-v] [-x] [-p port] "
 533        "hostname [sockshost[:socksport]]");
 534   exit(1);
 535 }
 536
 537 /** Entry point to tor-resolve */
 538 int
 539 main(int argc, char **argv)
 540 {
 541   tor_addr_t sockshost;
 542   uint16_t socksport = 0, port_option = 0;
 543   int isSocks4 = 0, isVerbose = 0, isReverse = 0;
 544   char **arg;
 545   int n_args;
 546   tor_addr_t result;
 547   char *result_hostname = NULL;
 548
 549   init_logging(1);
 550   sandbox_disable_getaddrinfo_cache();
 551
 552   arg = &argv[1];
 553   n_args = argc-1;
 554
 555   if (!n_args)
 556     usage();
 557
 558   if (!strcmp(arg[0],"--version")) {
 559     printf("Tor version %s.\n",VERSION);
 560     return 0;
 561   }
 562   while (n_args && *arg[0] == '-') {
 563     if (!strcmp("-v", arg[0]))
 564       isVerbose = 1;
 565     else if (!strcmp("-4", arg[0]))
 566       isSocks4 = 1;
 567     else if (!strcmp("-5", arg[0]))
 568       isSocks4 = 0;
 569     else if (!strcmp("-x", arg[0]))
 570       isReverse = 1;
 571     else if (!strcmp("-p", arg[0])) {
 572       int p;
 573       if (n_args < 2) {
 574         fprintf(stderr, "No arguments given to -p\n");
 575         usage();
 576       }
 577       p = atoi(arg[1]);
 578       if (p<1 || p > 65535) {
 579         fprintf(stderr, "-p requires a number between 1 and 65535\n");
 580         usage();
 581       }
 582       port_option = (uint16_t) p;
 583       ++arg; /* skip the port */
 584       --n_args;
 585     } else {
 586       fprintf(stderr, "Unrecognized flag '%s'\n", arg[0]);
 587       usage();
 588     }
 589     ++arg;
 590     --n_args;
 591   }
 592
 593   if (isSocks4 && isReverse) {
 594     fprintf(stderr, "Reverse lookups not supported with SOCKS4a\n");
 595     usage();
 596   }
 597
 598   log_severity_list_t *severities =
 599     tor_malloc_zero(sizeof(log_severity_list_t));
 600   if (isVerbose)
 601     set_log_severity_config(LOG_DEBUG, LOG_ERR, severities);
 602   else
 603     set_log_severity_config(LOG_WARN, LOG_ERR, severities);
 604   add_stream_log(severities, "<stderr>", fileno(stderr));
 605   tor_free(severities);
 606
 607   if (n_args == 1) {
 608     log_debug(LD_CONFIG, "defaulting to localhost");
 609     tor_addr_from_ipv4h(&sockshost, 0x7f000001u); /* localhost */
 610     if (port_option) {
 611       log_debug(LD_CONFIG, "Using port %d", (int)port_option);
 612       socksport = port_option;
 613     } else {
 614       log_debug(LD_CONFIG, "defaulting to port 9050");
 615       socksport = 9050; /* 9050 */
 616     }
 617   } else if (n_args == 2) {
 618     if (tor_addr_port_lookup(arg[1], &sockshost, &socksport)<0) {
 619       fprintf(stderr, "Couldn't parse/resolve address %s", arg[1]);
 620       return 1;
 621     }
 622     if (socksport && port_option && socksport != port_option) {
 623       log_warn(LD_CONFIG, "Conflicting ports; using %d, not %d",
 624                (int)socksport, (int)port_option);
 625     } else if (port_option) {
 626       socksport = port_option;
 627     } else if (!socksport) {
 628       log_debug(LD_CONFIG, "defaulting to port 9050");
 629       socksport = 9050;
 630     }
 631   } else {
 632     usage();
 633   }
 634
 635   if (network_init()<0) {
 636     log_err(LD_BUG,"Error initializing network; exiting.");
 637     return 1;
 638   }
 639
 640   if (do_resolve(arg[0], &sockshost, socksport, isReverse,
 641                  isSocks4 ? 4 : 5, &result,
 642                  &result_hostname))
 643     return 1;
 644
 645   if (result_hostname) {
 646     printf("%s\n", result_hostname);
 647   } else {
 648     printf("%s\n", fmt_addr(&result));
 649   }
 650   return 0;
 651 }