Java SshServer.setUpDefaultServer方法代码示例

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void startServer() throws IOException {
    SshServer sshd = SshServer.setUpDefaultServer();
    port = getPort();
    sshd.setPort(port);
    sshd.setPublickeyAuthenticator(AcceptAllPublickeyAuthenticator.INSTANCE);
    SimpleGeneratorHostKeyProvider provider = new SimpleGeneratorHostKeyProvider();
    sshd.setKeyPairProvider(provider);
    SftpSubsystemFactory.Builder builder = new SftpSubsystemFactory.Builder();

    SftpSubsystemFactory sftpFactory = builder.build();
    sshd.setSubsystemFactories(new ArrayList<NamedFactory<Command>>() {
        {
            add(sftpFactory);
        }
    });
    sshd.setHost(LOCALHOST);
    String msg = String.format("Local SSH Server started on [%s] and listening on port [%d]", sshd.getHost(), sshd
        .getPort());
    LOGGER.info(msg);
    ScpCommandFactory factory = new ScpCommandFactory();
    factory.setDelegateCommandFactory(new FakeCommandFactory());
    sshd.setCommandFactory(factory);
    Runtime.getRuntime().addShutdownHook(new Thread(new Close(sshd)));
    sshd.start();
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
@Bean
SshServer sshServer() {
    SshdShellProperties.Shell props = properties.getShell();
    if (Objects.isNull(props.getPassword())) {
        props.setPassword(UUID.randomUUID().toString());
        log.info("********** User password not set. Use following password to login: {} **********",
                props.getPassword());
    }
    SshServer server = SshServer.setUpDefaultServer();
    server.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(new File(props.getHostKeyFile())));
    server.setPublickeyAuthenticator(Objects.isNull(props.getPublicKeyFile())
            ? RejectAllPublickeyAuthenticator.INSTANCE
            : new SshdAuthorizedKeysAuthenticator(new File(props.getPublicKeyFile())));
    server.setHost(props.getHost());
    server.setPasswordAuthenticator(passwordAuthenticator());
    server.setPort(props.getPort());
    server.setShellFactory(() -> sshSessionInstance());
    server.setCommandFactory(command -> sshSessionInstance());
    return server;
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
private SshServer startServer(
    FileSystem fileSystem
) throws IOException {
    SshServer server = SshServer.setUpDefaultServer();
    server.setPort(port);
    server.setKeyPairProvider(new SimpleGeneratorHostKeyProvider());
    server.setPasswordAuthenticator(new StaticPasswordAuthenticator(true));
    server.setSubsystemFactories(singletonList(new SftpSubsystemFactory()));
    /* When a channel is closed SshServer calls close() on the file system.
     * In order to use the file system for multiple channels/sessions we
     * have to use a file system wrapper whose close() does nothing.
     */
    server.setFileSystemFactory(session -> new DoNotClose(fileSystem));
    server.start();
    this.server = server;
    return server;
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
private SshServer setUpSshServer(String algorithm) throws IOException {
	SshServer sshServer = SshServer.setUpDefaultServer();
	sshServer.setPort(0);
	AbstractGeneratorHostKeyProvider hostKeyProvider = SecurityUtils.createGeneratorHostKeyProvider(getServerKeyFile(algorithm));
	hostKeyProvider.setAlgorithm(algorithm);
	if (algorithm.equals(KeyUtils.EC_ALGORITHM)) {
		hostKeyProvider.setKeySize(256);
	}
	sshServer.setKeyPairProvider(hostKeyProvider);

	sshServer.setPublickeyAuthenticator(AcceptAllPublickeyAuthenticator.INSTANCE);
	sshServer.setTcpipForwardingFilter(AcceptAllForwardingFilter.INSTANCE);

	writeFingerprintToKnownHosts(algorithm);

	sshServer.start();

	int sshServerPort = sshServer.getPort();
	assertTrue(sshServerPort > 0);

	return sshServer;
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void start(Consumer<Connection> factory, Consumer<Throwable> doneHandler) {
    server = SshServer.setUpDefaultServer();
    server.setIoServiceFactoryFactory(new NettyIoServiceFactoryFactory(childGroup));
    server.setPort(port);
    server.setHost(host);
    server.setKeyPairProvider(keyPairProvider);
    server.setPasswordAuthenticator(passwordAuthenticator);
    if (publicKeyAuthenticator != null) {
        server.setPublickeyAuthenticator(publicKeyAuthenticator);
    }
    server.setShellFactory(() -> new TtyCommand(charset, factory));
    try {
        server.start();
    } catch (Exception e) {
        doneHandler.accept(e);
        return;
    }
    doneHandler.accept(null);
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
@Override
protected void before() throws Throwable {
  sshd = SshServer.setUpDefaultServer();
  sshd.setPort(findRandomOpenPortOnAllLocalInterfaces());
  sshd.setKeyPairProvider(
      new ClassLoadableResourceKeyPairProvider(getClass().getClassLoader(), "server_key"));
  sshd.setCommandFactory(new ScpCommandFactory());
  sshd.setSubsystemFactories(Collections.singletonList(new SftpSubsystemFactory()));
  sshd.setUserAuthFactories(Collections.singletonList(new UserAuthPublicKeyFactory()));
  sshd.setHost("localhost");
  sshd.setPublickeyAuthenticator(AcceptAllPublickeyAuthenticator.INSTANCE);
  sshd.setHostBasedAuthenticator(new StaticHostBasedAuthenticator(true));

  VirtualFileSystemFactory fileSystemFactory = new VirtualFileSystemFactory();
  fileSystemFactory.setDefaultHomeDir(currentFolder.get().toPath());

  sshd.setFileSystemFactory(fileSystemFactory);
  sshd.start();
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void start(Consumer<TtyConnection> factory, Consumer<Throwable> doneHandler) {
  server = SshServer.setUpDefaultServer();
  server.setIoServiceFactoryFactory(new NettyIoServiceFactoryFactory(childGroup));
  server.setPort(port);
  server.setHost(host);
  server.setKeyPairProvider(keyPairProvider);
  server.setPasswordAuthenticator(passwordAuthenticator);
  server.setShellFactory(() -> new TtyCommand(charset, factory));
  try {
    server.start();
  } catch (Exception e) {
    doneHandler.accept(e);
    return;
  }
  doneHandler.accept(null);
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void start(int port) throws IOException {
    if (sshServerMap.get(port) == null) {
        SshServer sshServer = SshServer.setUpDefaultServer();
        AbstractFileKeyPairProvider fileKeyPairProvider = SecurityUtils.createFileKeyPairProvider();
        fileKeyPairProvider.setFiles(Collections.singleton(getHostkey()));
        fileKeyPairProvider.setPasswordFinder(resourceKey -> "cloudbreak");
        sshServer.setKeyPairProvider(fileKeyPairProvider);
        sshServer.setPublickeyAuthenticator((username, key, session) -> true);
        setCommandFactory(sshServer);
        sshServer.setFileSystemFactory(new MockFileSystemFactory());
        sshServer.setPort(port);
        sshServer.start();
        LOGGER.debug(sshServer.getHost());
        sshServerMap.put(port, sshServer);
    }
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
@Override
public void onEnable() {
    instance = this;

    sshd = SshServer.setUpDefaultServer();
    sshd.setPort(getConfig().getInt("port", 22));
    String host = getConfig().getString("listenAddress", "all");
    sshd.setHost(host.equals("all") ? null : host);

    File hostKey = new File(getDataFolder(), "hostkey");
    File authorizedKeys = new File(getDataFolder(), "authorized_keys");

    sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(hostKey));
    sshd.setShellFactory(new ConsoleShellFactory());
    sshd.setPasswordAuthenticator(new ConfigPasswordAuthenticator());
    sshd.setPublickeyAuthenticator(new PublicKeyAuthenticator(authorizedKeys));
    sshd.setCommandFactory(new ConsoleCommandFactory());
    try {
        sshd.start();
    } catch (IOException e) {
        getLogger().severe("Failed to start SSH server! " + e.getMessage());
    }
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public static SshServer create() {

        SshServer sshd = SshServer.setUpDefaultServer();
        sshd.setPort(SpashConfig.getInstance().spashListenPort());

        AbstractGeneratorHostKeyProvider keyProvider = new SimpleGeneratorHostKeyProvider(new File(SpashConfig.getInstance().spashKeyFileName()));
        keyProvider.setAlgorithm(SpashConfig.getInstance().spashKeyAlgorithm());
        keyProvider.setKeySize(SpashConfig.getInstance().spashKeyLength());

        sshd.setKeyPairProvider(keyProvider);

        List<NamedFactory<UserAuth>> userAuthFactories = new ArrayList<NamedFactory<UserAuth>>();
        userAuthFactories.add(new UserAuthPasswordFactory());
        sshd.setUserAuthFactories(userAuthFactories);

        sshd.setPasswordAuthenticator(new PasswordAuthenticator() {
            @Override
            public boolean authenticate(String username, String password, ServerSession serverSession) throws PasswordChangeRequiredException {
                return username!=null && username.length()>0 && username.equals(password);
            }
        });

        sshd.setShellFactory(new SpashShellFactory());

        List<NamedFactory<Command>> namedFactoryList = new ArrayList<>();
        namedFactoryList.add(new SftpSubsystemFactory());
        sshd.setSubsystemFactories(namedFactoryList);

        sshd.setCommandFactory(new ScpCommandFactory());

        sshd.setFileSystemFactory(new FileSystemFactory() {
            @Override
            public FileSystem createFileSystem(Session session) throws IOException {
                return SpashFileSystem.get().getFileSystem();
            }
        });

        return sshd;
    }
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void startServer(Integer timeout) throws Exception {
  if (server != null) {
    throw failure("Server already started");
  }
  server = SshServer.setUpDefaultServer();
  if (timeout != null) {
    server.setProperties(Collections.singletonMap(FactoryManager.AUTH_TIMEOUT, timeout.toString()));
  }
  server.setPort(5000);
  server.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(new File("hostkey.ser").toPath()));
  server.setPasswordAuthenticator((username, password, sess) -> authenticator.authenticate(username, password, sess));
  server.setShellFactory(new EchoShellFactory());
  server.setServiceFactories(Arrays.asList(ServerConnectionServiceFactory.INSTANCE, AsyncUserAuthServiceFactory.INSTANCE));
  server.start();
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
/**
 * Builds a new instance of SSH server.
 * @return SSH server.
 */
public SshServer build() {
    final SshServer sshd = SshServer.setUpDefaultServer();
    sshd.setPort(this.port);
    sshd.setKeyPairProvider(
        new SimpleGeneratorHostKeyProvider(
            new File(Files.createTempDir(), "hostkey.ser")
        )
    );
    sshd.setUserAuthFactories(this.factories);
    sshd.setPasswordAuthenticator(this.pwd.orNull());
    sshd.setPublickeyAuthenticator(this.pkey.orNull());
    return sshd;
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public static SshServer setupTestServer(Class<?> anchor) {
    SshServer sshd = SshServer.setUpDefaultServer();
    sshd.setKeyPairProvider(createTestHostKeyProvider(anchor));
    sshd.setPasswordAuthenticator(BogusPasswordAuthenticator.INSTANCE);
    sshd.setPublickeyAuthenticator(AcceptAllPublickeyAuthenticator.INSTANCE);
    sshd.setShellFactory(EchoShellFactory.INSTANCE);
    sshd.setCommandFactory(UnknownCommandFactory.INSTANCE);
    return sshd;
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public void startServer(Integer timeout) throws Exception {
  if (server != null) {
    throw failure("Server already started");
  }
  server = SshServer.setUpDefaultServer();
  if (timeout != null) {
    server.getProperties().put(FactoryManager.AUTH_TIMEOUT, timeout.toString());
  }
  server.setPort(5000);
  server.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(new File("hostkey.ser").toPath()));
  server.setPasswordAuthenticator((username, password, sess) -> authenticator.authenticate(username, password, sess));
  server.setShellFactory(new EchoShellFactory());
  server.setServiceFactories(Arrays.asList(ServerConnectionServiceFactory.INSTANCE, AsyncUserAuthServiceFactory.INSTANCE));
  server.start();
}
 

import org.apache.sshd.server.SshServer; //导入方法依赖的package包/类
public EmbeddedSSHServer(Path homeDir, int port) {
    this.sshServer = SshServer.setUpDefaultServer();
    this.sshServer.setPort(port);
    this.sshServer.setCommandFactory(new EchoCommandFactory());
    this.sshServer.setKeyPairProvider(new SimpleGeneratorHostKeyProvider());
    this.sshServer.setPasswordAuthenticator((username, password, serverSession) -> username.equals("admin") && password.equals("admin"));
    this.sshServer.setPublickeyAuthenticator((s, publicKey, serverSession) -> true);
    this.homeDir = homeDir;

    if (EnvironmentUtils.isWindows()) {
        sshServer.setShellFactory(new ProcessShellFactory(new String[] { "cmd.exe " }));
    } else {
        sshServer.setShellFactory(new ProcessShellFactory(new String[] { "/bin/sh", "-i", "-s" }));
    }
}