Java Examples for org.apache.sshd.common.Channel

@Override
protected void checkConfig() {
    super.checkConfig();
    Objects.requireNonNull(getTcpipForwarderFactory(), "TcpipForwarderFactory not set");
    Objects.requireNonNull(getServerKeyVerifier(), "ServerKeyVerifier not set");
    Objects.requireNonNull(getHostConfigEntryResolver(), "HostConfigEntryResolver not set");
    Objects.requireNonNull(getClientIdentityLoader(), "ClientIdentityLoader not set");
    Objects.requireNonNull(getFilePasswordProvider(), "FilePasswordProvider not set");
    // if no client identities override use the default
    KeyPairProvider defaultIdentities = getKeyPairProvider();
    if (defaultIdentities == null) {
        setKeyPairProvider(new DefaultClientIdentitiesWatcher(this::getClientIdentityLoader, this::getFilePasswordProvider));
    }
    // Register the additional agent forwarding channel if needed
    SshAgentFactory agentFactory = getAgentFactory();
    if (agentFactory != null) {
        List<NamedFactory<Channel>> forwarders = ValidateUtils.checkNotNullAndNotEmpty(agentFactory.getChannelForwardingFactories(this), "No agent channel forwarding factories for %s", agentFactory);
        List<NamedFactory<Channel>> factories = getChannelFactories();
        if (GenericUtils.isEmpty(factories)) {
            factories = forwarders;
        } else {
            // create a copy in case un-modifiable original
            List<NamedFactory<Channel>> factories2 = new ArrayList<>(factories.size() + forwarders.size());
            factories2.addAll(factories);
            factories2.addAll(forwarders);
            factories = factories2;
        }
        setChannelFactories(factories);
    }
    if (GenericUtils.isEmpty(getServiceFactories())) {
        setServiceFactories(DEFAULT_SERVICE_FACTORIES);
    }
    if (GenericUtils.isEmpty(getUserAuthFactories())) {
        setUserAuthFactories(DEFAULT_USER_AUTH_FACTORIES);
    }
}

@Test
public void testIdleClient() throws Exception {
    SshClient client = setupTestClient();
    client.start();
    try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
        session.addPasswordIdentity(getCurrentTestName());
        session.auth().verify(5L, TimeUnit.SECONDS);
        try (ClientChannel channel = session.createChannel(Channel.CHANNEL_SHELL)) {
            Collection<ClientChannelEvent> result = channel.waitFor(EnumSet.of(ClientChannelEvent.CLOSED), WAIT);
            assertTrue("Wrong channel state: " + result, result.containsAll(EnumSet.of(ClientChannelEvent.CLOSED)));
        }
    } finally {
        client.stop();
    }
}

public boolean start() throws IOException {
    if (sshd != null) {
        throw new IllegalStateException();
    }
    final boolean authUseKeys = true;
    // TODO: Use AuthorizedSshKeys helper
    final File authorizedKeys = configuration.lookupFile("sshd.authorized_keys", "~/.ssh/authorized_fathomcloud");
    if (!authUseKeys) {
        throw new IllegalArgumentException("Neither password nor publickey SSH-auth are enabled, so won't start SSH server");
    }
    sshd = SshServer.setUpDefaultServer();
    if (authUseKeys) {
        sshd.setPublickeyAuthenticator(new PublickeyAuthenticator() {

            @Override
            public boolean authenticate(String username, PublicKey key, ServerSession session) {
                try {
                    String opensshEncoded = OpenSshUtils.serialize(key);
                    log.info("SSH presented public key: " + opensshEncoded);
                    List<String> match = Lists.newArrayList(Splitter.on(CharMatcher.WHITESPACE).split(opensshEncoded));
                    if (!authorizedKeys.exists()) {
                        log.warn("SSH authorized key file does not exist: {}", authorizedKeys);
                    } else {
                        for (String line : Files.readLines(authorizedKeys, Charsets.UTF_8)) {
                            line = line.trim();
                            List<String> tokens = Lists.newArrayList(Splitter.on(CharMatcher.WHITESPACE).split(line));
                            if (tokens.size() < 2) {
                                continue;
                            }
                            if (!match.get(0).equals(tokens.get(0))) {
                                continue;
                            }
                            if (!match.get(1).equals(tokens.get(1))) {
                                continue;
                            }
                            return true;
                        }
                    }
                    return false;
                } catch (Exception e) {
                    log.error("Exception while verifying public key", e);
                    return false;
                }
            }
        });
    }
    // Log if anyone even suggests touching the filesystem
    sshd.setFileSystemFactory(new FileSystemFactory() {

        @Override
        public FileSystemView createFileSystemView(Session session) throws IOException {
            log.warn("Blocking SSHD filesystem access");
            throw new IllegalStateException("Blocking SSHD filesystem access");
        }
    });
    // Log if anyone even suggested forwarding a port
    sshd.setForwardingFilter(new ForwardingFilter() {

        @Override
        public boolean canListen(InetSocketAddress address, ServerSession session) {
            log.warn("Blocking SSHD port forwarding");
            return false;
        }

        @Override
        public boolean canForwardX11(ServerSession session) {
            log.warn("Blocking SSHD port forwarding");
            return false;
        }

        @Override
        public boolean canForwardAgent(ServerSession session) {
            log.warn("Blocking SSHD port forwarding");
            return false;
        }

        @Override
        public boolean canConnect(InetSocketAddress address, ServerSession session) {
            log.warn("Blocking SSHD port forwarding");
            return false;
        }
    });
    sshd.setAgentFactory(new SshAgentFactory() {

        @Override
        public NamedFactory<Channel> getChannelForwardingFactory() {
            log.warn("Blocking SSHD agent functionality");
            throw new IllegalStateException("Blocking SSHD agent functionality");
        }

        @Override
        public SshAgentServer createServer(Session session) throws IOException {
            log.warn("Blocking SSHD agent functionality");
            throw new IllegalStateException("Blocking SSHD agent functionality");
        }

        @Override
        public SshAgent createClient(Session session) throws IOException {
            log.warn("Blocking SSHD agent functionality");
            throw new IllegalStateException("Blocking SSHD agent functionality");
        }
    });
    sshd.setTcpipForwardNioSocketAcceptorFactory(new ForwardingAcceptorFactory() {

        @Override
        public NioSocketAcceptor createNioSocketAcceptor(Session session) {
            log.warn("Blocking SSHD Tcpip Forward functionality");
            throw new IllegalStateException("Blocking SSHD Tcpip Forward access");
        }
    });
    sshd.setX11ForwardNioSocketAcceptorFactory(new ForwardingAcceptorFactory() {

        @Override
        public NioSocketAcceptor createNioSocketAcceptor(Session session) {
            log.warn("Blocking SSHD X11 Forward functionality");
            throw new IllegalStateException("Blocking SSHD X11 Forward access");
        }
    });
    sshd.setShellFactory(new Factory<Command>() {

        @Override
        public Command create() {
            log.warn("Blocking SSHD shell functionality");
            throw new IllegalStateException("Blocking SSHD shell access");
        }
    });
    sshd.setPort(configuration.lookup("sshd.port", 2222));
    File hostkeyPath = configuration.lookupFile("sshd.hostkey", "hostkey.ser");
    sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(hostkeyPath.getAbsolutePath()));
    sshd.setCommandFactory(sshCommandFactory);
    List<NamedFactory<Command>> subsystemFactories = sshd.getSubsystemFactories();
    if (subsystemFactories != null) {
        throw new UnsupportedOperationException();
    }
    List<NamedFactory<Channel>> channelFactories = sshd.getChannelFactories();
    sshd.setChannelFactories(Lists.newArrayList(Iterables.filter(channelFactories, new Predicate<NamedFactory<Channel>>() {

        @Override
        public boolean apply(NamedFactory<Channel> command) {
            if (command instanceof ChannelSession.Factory) {
                log.info("Accepting Channel factory: " + command);
                return true;
            } else {
                return false;
            }
        }
    })));
    log.info("Starting SSH server");
    sshd.start();
    for (NamedFactory<UserAuth> authFactory : sshd.getUserAuthFactories()) {
        if (authFactory instanceof UserAuthPublicKey.Factory) {
            if (!authUseKeys) {
                throw new IllegalStateException();
            }
        } else {
            throw new IllegalStateException();
        }
    }
    return true;
}