Exemplo n.º 1
0
  private void finishKex() throws IOException {
    if (sessionId == null) sessionId = kxs.H;

    establishKeyMaterial();

    /* Tell the other side that we start using the new material */

    PacketNewKeys ign = new PacketNewKeys();
    tm.sendKexMessage(ign.getPayload());

    BlockCipher cbc;
    MAC mac;
    ICompressor comp;

    try {
      cbc =
          BlockCipherFactory.createCipher(
              kxs.np.enc_algo_client_to_server,
              true,
              km.enc_key_client_to_server,
              km.initial_iv_client_to_server);

      mac = new MAC(kxs.np.mac_algo_client_to_server, km.integrity_key_client_to_server);

      comp = CompressionFactory.createCompressor(kxs.np.comp_algo_client_to_server);

    } catch (IllegalArgumentException e1) {
      throw new IOException("Fatal error during MAC startup!");
    }

    tm.changeSendCipher(cbc, mac);
    tm.changeSendCompression(comp);
    tm.kexFinished();
  }
Exemplo n.º 2
0
  public synchronized void handleMessage(byte[] msg, int msglen) throws IOException {
    PacketKexInit kip;

    if (msg == null) {
      synchronized (accessLock) {
        connectionClosed = true;
        accessLock.notifyAll();
        return;
      }
    }

    if ((kxs == null) && (msg[0] != Packets.SSH_MSG_KEXINIT))
      throw new IOException("Unexpected KEX message (type " + msg[0] + ")");

    if (ignore_next_kex_packet) {
      ignore_next_kex_packet = false;
      return;
    }

    if (msg[0] == Packets.SSH_MSG_KEXINIT) {
      if ((kxs != null) && (kxs.state != 0))
        throw new IOException("Unexpected SSH_MSG_KEXINIT message during on-going kex exchange!");

      if (kxs == null) {
        /*
         * Ah, OK, peer wants to do KEX. Let's be nice and play
         * together.
         */
        kxs = new KexState();
        kxs.dhgexParameters = nextKEXdhgexParameters;
        kip = new PacketKexInit(nextKEXcryptoWishList, rnd);
        kxs.localKEX = kip;
        tm.sendKexMessage(kip.getPayload());
      }

      kip = new PacketKexInit(msg, 0, msglen);
      kxs.remoteKEX = kip;

      kxs.np =
          mergeKexParameters(kxs.localKEX.getKexParameters(), kxs.remoteKEX.getKexParameters());

      if (kxs.np == null) throw new IOException("Cannot negotiate, proposals do not match.");

      if (kxs.remoteKEX.isFirst_kex_packet_follows() && (kxs.np.guessOK == false)) {
        /*
         * Guess was wrong, we need to ignore the next kex packet.
         */

        ignore_next_kex_packet = true;
      }

      if (kxs.np.kex_algo.equals("diffie-hellman-group-exchange-sha1")) {
        if (kxs.dhgexParameters.getMin_group_len() == 0
            || csh.server_versioncomment.matches("OpenSSH_2\\.([0-4]\\.|5\\.[0-2]).*")) {
          PacketKexDhGexRequestOld dhgexreq = new PacketKexDhGexRequestOld(kxs.dhgexParameters);
          tm.sendKexMessage(dhgexreq.getPayload());

        } else {
          PacketKexDhGexRequest dhgexreq = new PacketKexDhGexRequest(kxs.dhgexParameters);
          tm.sendKexMessage(dhgexreq.getPayload());
        }
        kxs.state = 1;
        return;
      }

      if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1")
          || kxs.np.kex_algo.equals("diffie-hellman-group14-sha1")) {
        kxs.dhx = new DhExchange();

        if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1")) kxs.dhx.init(1, rnd);
        else kxs.dhx.init(14, rnd);

        PacketKexDHInit kp = new PacketKexDHInit(kxs.dhx.getE());
        tm.sendKexMessage(kp.getPayload());
        kxs.state = 1;
        return;
      }

      throw new IllegalStateException("Unkown KEX method!");
    }

    if (msg[0] == Packets.SSH_MSG_NEWKEYS) {
      if (km == null)
        throw new IOException("Peer sent SSH_MSG_NEWKEYS, but I have no key material ready!");

      BlockCipher cbc;
      MAC mac;
      ICompressor comp;

      try {
        cbc =
            BlockCipherFactory.createCipher(
                kxs.np.enc_algo_server_to_client,
                false,
                km.enc_key_server_to_client,
                km.initial_iv_server_to_client);

        mac = new MAC(kxs.np.mac_algo_server_to_client, km.integrity_key_server_to_client);

        comp = CompressionFactory.createCompressor(kxs.np.comp_algo_server_to_client);
      } catch (IllegalArgumentException e1) {
        throw new IOException("Fatal error during MAC startup!");
      }

      tm.changeRecvCipher(cbc, mac);
      tm.changeRecvCompression(comp);

      ConnectionInfo sci = new ConnectionInfo();

      kexCount++;

      sci.keyExchangeAlgorithm = kxs.np.kex_algo;
      sci.keyExchangeCounter = kexCount;
      sci.clientToServerCryptoAlgorithm = kxs.np.enc_algo_client_to_server;
      sci.serverToClientCryptoAlgorithm = kxs.np.enc_algo_server_to_client;
      sci.clientToServerMACAlgorithm = kxs.np.mac_algo_client_to_server;
      sci.serverToClientMACAlgorithm = kxs.np.mac_algo_server_to_client;
      sci.serverHostKeyAlgorithm = kxs.np.server_host_key_algo;
      sci.serverHostKey = kxs.hostkey;

      synchronized (accessLock) {
        lastConnInfo = sci;
        accessLock.notifyAll();
      }

      kxs = null;
      return;
    }

    if ((kxs == null) || (kxs.state == 0)) throw new IOException("Unexpected Kex submessage!");

    if (kxs.np.kex_algo.equals("diffie-hellman-group-exchange-sha1")) {
      if (kxs.state == 1) {
        PacketKexDhGexGroup dhgexgrp = new PacketKexDhGexGroup(msg, 0, msglen);
        kxs.dhgx = new DhGroupExchange(dhgexgrp.getP(), dhgexgrp.getG());
        kxs.dhgx.init(rnd);
        PacketKexDhGexInit dhgexinit = new PacketKexDhGexInit(kxs.dhgx.getE());
        tm.sendKexMessage(dhgexinit.getPayload());
        kxs.state = 2;
        return;
      }

      if (kxs.state == 2) {
        PacketKexDhGexReply dhgexrpl = new PacketKexDhGexReply(msg, 0, msglen);

        kxs.hostkey = dhgexrpl.getHostKey();

        if (verifier != null) {
          boolean vres = false;

          try {
            vres =
                verifier.verifyServerHostKey(
                    hostname, port, kxs.np.server_host_key_algo, kxs.hostkey);
          } catch (Exception e) {
            throw (IOException)
                new IOException("The server hostkey was not accepted by the verifier callback.")
                    .initCause(e);
          }

          if (vres == false)
            throw new IOException("The server hostkey was not accepted by the verifier callback");
        }

        kxs.dhgx.setF(dhgexrpl.getF());

        try {
          kxs.H =
              kxs.dhgx.calculateH(
                  csh.getClientString(),
                  csh.getServerString(),
                  kxs.localKEX.getPayload(),
                  kxs.remoteKEX.getPayload(),
                  dhgexrpl.getHostKey(),
                  kxs.dhgexParameters);
        } catch (IllegalArgumentException e) {
          throw (IOException) new IOException("KEX error.").initCause(e);
        }

        boolean res = verifySignature(dhgexrpl.getSignature(), kxs.hostkey);

        if (res == false) throw new IOException("Hostkey signature sent by remote is wrong!");

        kxs.K = kxs.dhgx.getK();

        finishKex();
        kxs.state = -1;
        return;
      }

      throw new IllegalStateException("Illegal State in KEX Exchange!");
    }

    if (kxs.np.kex_algo.equals("diffie-hellman-group1-sha1")
        || kxs.np.kex_algo.equals("diffie-hellman-group14-sha1")) {
      if (kxs.state == 1) {

        PacketKexDHReply dhr = new PacketKexDHReply(msg, 0, msglen);

        kxs.hostkey = dhr.getHostKey();

        if (verifier != null) {
          boolean vres = false;

          try {
            vres =
                verifier.verifyServerHostKey(
                    hostname, port, kxs.np.server_host_key_algo, kxs.hostkey);
          } catch (Exception e) {
            throw (IOException)
                new IOException("The server hostkey was not accepted by the verifier callback.")
                    .initCause(e);
          }

          if (vres == false)
            throw new IOException("The server hostkey was not accepted by the verifier callback");
        }

        kxs.dhx.setF(dhr.getF());

        try {
          kxs.H =
              kxs.dhx.calculateH(
                  csh.getClientString(),
                  csh.getServerString(),
                  kxs.localKEX.getPayload(),
                  kxs.remoteKEX.getPayload(),
                  dhr.getHostKey());
        } catch (IllegalArgumentException e) {
          throw (IOException) new IOException("KEX error.").initCause(e);
        }

        boolean res = verifySignature(dhr.getSignature(), kxs.hostkey);

        if (res == false) throw new IOException("Hostkey signature sent by remote is wrong!");

        kxs.K = kxs.dhx.getK();

        finishKex();
        kxs.state = -1;
        return;
      }
    }

    throw new IllegalStateException("Unkown KEX method! (" + kxs.np.kex_algo + ")");
  }