Esempio n. 1
0
  /**
   * makes a connection to a hidden service
   *
   * @param sp hostname, port to connect to and other stuff
   * @return some socket-thing
   */
  private TCPStream connectToHidden(TCPStreamProperties spo) throws IOException {
    // check, if tor is still in startup-phase
    checkStartup();
    Circuit myRendezvousCirc = null;
    Server hiddenServer;
    Node hiddenNode = null;

    // String address, x, y;
    String z;
    // Iterator it, i, i2;
    byte[] cookie = new byte[20];
    // boolean notFound;
    int j;

    z = (String) Encoding.parseHiddenAddress(spo.hostname).get("z");

    // Do we already have a connection to this address?
    if (hiddenServiceCircuits.containsKey(z)) {
      // TODO assess suitability of this circuit
      System.out.println("Reusing existing circuit");
      TCPStreamProperties tcpProps = new TCPStreamProperties("", spo.port);
      try {
        return new TCPStream(hiddenServiceCircuits.get(z), tcpProps);
      } catch (TorNoAnswerException e) {
        // Create a new circuit instead
        e.printStackTrace();
      } catch (TorException e) {
        // Create a new circuit instead
        e.printStackTrace();
      }
    }

    // get a copy from the service descriptor (either local cache or
    // retrieve form network)
    ServiceDescriptor sd = (ServiceDescriptor) cachedServiceDescriptors.get(z);
    if (sd == null || (!sd.checkTimeStampValidity())) {
      sd = ServiceDescriptor.loadFromDirectory(z, this);
      cachedServiceDescriptors.put(z, sd); // cache it
    }

    boolean establishedRendezvous = false;
    j = 0; // attempts counted
    // spo.connect_retries try to establish rendezvous
    while ((j < spo.connect_retries) && (!establishedRendezvous)) {
      j++;
      try {
        myRendezvousCirc = fnh.provideSuitableNewCircuit(new TCPStreamProperties());
        String rendezvousName =
            myRendezvousCirc.route[myRendezvousCirc.route_established - 1].server.nickname;

        Logger.logGeneral(
            Logger.INFO,
            "Tor.connectToHidden: establishing rendezvous point for "
                + z
                + " at "
                + rendezvousName);
        Random rnd = new Random();
        rnd.nextBytes(cookie);

        myRendezvousCirc.send_cell(new CellRelayEstablishRendezvous(myRendezvousCirc, cookie));
        myRendezvousCirc.streamHistory.add(spo.hostname);

        // wait for answer
        CellRelay rendezvousACK =
            myRendezvousCirc.queue.receiveRelayCell(CellRelay.CELL_RELAY_RENDEZVOUS_ESTABLISHED);
        if (rendezvousACK.length > 0) {
          throw new TorException("Tor.connectToHidden: Got NACK from RENDEZVOUS Point");
        }
        myRendezvousCirc.sd = sd;

        hiddenServer = new Server(this, sd.publicKey);
        hiddenNode = new Node(hiddenServer); // between HS and
        // Rendezvous point

        establishedRendezvous = true;

      } catch (IOException e) {
        e.printStackTrace();
      } catch (TorException e) {
        e.printStackTrace();
      }
    }

    if (!establishedRendezvous) {
      Logger.logGeneral(
          Logger.WARNING, "Tor.connectToHidden: coudn't establishing rendezvous point for " + z);
      throw new IOException("Tor.connectToHidden: coudn't establishing rendezvous point for " + z);
    }

    Iterator<IntroductionPoint> it3 = sd.introPoints.iterator();
    String rendezvousName =
        myRendezvousCirc.route[myRendezvousCirc.route.length - 1].server.nickname;

    while (it3.hasNext()) {
      IntroductionPoint iPoint = (IntroductionPoint) it3.next();
      Logger.logGeneral(
          Logger.INFO,
          "Tor.connectToHidden: contacting introduction point "
              + iPoint.getNickname()
              + " for "
              + z);

      // introduce rendezvous to the node
      TCPStreamProperties spIntro = new TCPStreamProperties();

      spIntro.exitPolicyRequired = false;
      //            Server sr = iPoint.getSrv();
      spIntro.setCustomExitpoint(iPoint.getNickname());

      try {
        // make new circ where the last node is intro point
        Circuit myIntroCirc = new Circuit(this, fnh, dir, spIntro);

        // System.out.println(" LAST NODE IS... " +
        // myIntroCirc.route[myIntroCirc.route.length-1].server.name);

        // and CellIntro1 data encrypted with PK of Hidden Service, and _not_ of the introPoint
        myIntroCirc.send_cell(
            new CellRelayIntroduce1(myIntroCirc, cookie, sd, rendezvousName, hiddenNode));

        // wait for ack
        CellRelay introACK =
            myIntroCirc.queue.receiveRelayCell(CellRelay.CELL_RELAY_COMMAND_INTRODUCE_ACK);
        if (introACK.length > 0)
          throw new TorException("Tor.connectToHidden: Got NACK from Introduction Point");
        // introduce ACK is received
        Logger.logGeneral(Logger.RAW_DATA, "Tor.connectToHidden: Got ACK from Intro Point");

        myIntroCirc.close(true);

        // wait for answer from the hidden service (RENDEZVOUS2)
        int oldTimeout = myRendezvousCirc.queue.timeout;
        if (oldTimeout < 120 * 1000) myRendezvousCirc.queue.timeout = 120 * 1000;
        CellRelay r2Relay =
            myRendezvousCirc.queue.receiveRelayCell(CellRelay.CELL_RELAY_RENDEZVOUS2);
        myRendezvousCirc.queue.timeout = oldTimeout;
        // finish diffie-hellman
        byte[] dh_gy = new byte[148];
        System.arraycopy(r2Relay.data, 0, dh_gy, 0, 148);
        hiddenNode.finish_dh(dh_gy);

        myRendezvousCirc.addNode(hiddenNode);

        Logger.logGeneral(
            Logger.INFO, "Tor.connectToHidden: succesfully established rendezvous with " + z);
        // address in begin cell set to "";
        TCPStreamProperties tcpProps = new TCPStreamProperties("", spo.port);

        if (hiddenServiceCircuits.containsKey(z)) hiddenServiceCircuits.remove(z);
        hiddenServiceCircuits.put(z, myRendezvousCirc);

        // connect
        return new TCPStream(myRendezvousCirc, tcpProps);
      } catch (TorException e) {
        e.printStackTrace();
      } catch (InterruptedException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    // all intros failed...
    // perhaps there is something wrong with out cached service descriptor
    cachedServiceDescriptors.remove(z);
    throw new IOException("Tor.connectToHidden: couldn't connect to an introduction point of " + z);
  }
Esempio n. 2
0
  /**
   * initializes a new hidden service
   *
   * @param service all data needed to init the thingy
   */
  public String setupHiddenService(HiddenServiceProperties service)
      throws IOException, TorException {

    if (service.handler == null)
      throw new TorException("Tor.provideHiddenService: need a handler for incoming connections");

    Logger.logHiddenService(
        Logger.INFO, "Tor.provideHiddenService: setting up hidden service " + service.getName());
    // check, if tor is still in startup-phase
    checkStartup();

    // Store the service
    String url = service.getName();
    hiddenServices.put(url, service);

    // Update hidden service status
    service.setStatus(HiddenServiceProperties.STATUS_STARTED, true);
    // establish choosen introduction points
    Iterator<IntroductionPoint> i = service.introPoints.iterator();
    while (i.hasNext()) {
      IntroductionPoint ip = i.next();
      String ip_name = ip.getSrv().nickname;
      Logger.logHiddenService(
          Logger.INFO, "Tor.provideHiddenService: establish introduction point at " + ip_name);
      // create circuit properties to end the circuit at the
      // intro-point
      TCPStreamProperties sp_intro = new TCPStreamProperties();
      sp_intro.setCustomExitpoint(ip_name);
      establishIntroductionPoint(service, sp_intro);
    }
    // choose additional random introduction points, if none given
    while (service.introPoints.size() < service.minimum_number_of_intro_points) {
      TCPStreamProperties sp_intro = new TCPStreamProperties();
      sp_intro.connect_retries = 1;
      Circuit c = establishIntroductionPoint(service, sp_intro);
      if (c != null) {
        String ip_name = c.route[c.route_established - 1].server.nickname;
        Logger.logHiddenService(
            Logger.INFO, "Tor.provideHiddenService: establish introduction point at " + ip_name);
        service.addIntroPoint(ip_name, dir);
      }
      ;
    }
    // Update hidden service status
    service.setStatus(HiddenServiceProperties.STATUS_INTROPOINTS, true);
    // advertise introduction points
    int advertise_success = 0;
    Iterator<String> i2 = config.trustedServers.keySet().iterator();
    while (i2.hasNext()) {
      String nick = i2.next();
      HashMap<String, Object> trustedServer = config.trustedServers.get(nick);
      String address = (String) trustedServer.get("ip");
      int port = ((Integer) trustedServer.get("port")).intValue();
      int tries = 2;
      while (tries > 0) {
        Logger.logHiddenService(
            Logger.VERBOSE,
            "Tor.provideHiddenService: advertise service at "
                + nick
                + " ("
                + address
                + ":"
                + port
                + ")");
        TCPStreamProperties sp = new TCPStreamProperties(address, port);
        TCPStream stream = null;
        // advertise data for hidden service's rendevouz anonymously
        try {
          stream = connect(sp);
          // advertise service-descriptor with HTTP-POST
          byte[] body = service.sd_v0.toByteArray();
          String headerStr =
              "POST /tor/rendezvous/publish HTTP/1.0\r\n"
                  + "Content-Length: "
                  + body.length
                  + "\r\n"
                  + "\r\n";
          byte[] header = headerStr.getBytes();
          byte[] out = new byte[header.length + body.length];
          System.arraycopy(header, 0, out, 0, header.length);
          System.arraycopy(body, 0, out, header.length, body.length);
          String answer =
              StreamsAndHTTP.HTTPBinaryRequest(
                  stream.getOutputStream(), stream.getInputStream(), out);
          // analyse answer
          if (!answer.startsWith("HTTP/1.0 200 "))
            throw new TorException(
                "Tor.provideHiddenService: no success posting service descriptor " + answer);
          Logger.logHiddenService(Logger.INFO, "Successfully advertised at " + nick);
          stream.close();
          ++advertise_success;
          if (advertise_success > 1) {
            // Update hidden service status
            service.setStatus(HiddenServiceProperties.STATUS_ADVERTISED, true);
          }
          break;
        } catch (Exception e) {
          Logger.logHiddenService(
              Logger.WARNING,
              "Tor.provideHiddenService: error advertising service at "
                  + nick
                  + " ("
                  + address
                  + ":"
                  + port
                  + ")\n"
                  + e.getMessage());
        }
        if (--tries <= 0)
          Logger.logHiddenService(
              Logger.WARNING,
              "Tor.provideHiddenService: final error advertising service at "
                  + nick
                  + " ("
                  + address
                  + ":"
                  + port
                  + ")");
      }
    }
    // at least one advertisement?
    if (advertise_success < 1)
      throw new TorException("Tor.provideHiddenService: no successful advertisement");
    // success
    return url;
  }