SshdSessionFactoryBuilder.java

  1. /*
  2.  * Copyright (C) 2020 Thomas Wolf <thomas.wolf@paranor.ch> and others
  3.  *
  4.  * This program and the accompanying materials are made available under the
  5.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  6.  * https://www.eclipse.org/org/documents/edl-v10.php.
  7.  *
  8.  * SPDX-License-Identifier: BSD-3-Clause
  9.  */
  10. package org.eclipse.jgit.transport.sshd;

  12. import java.io.File;
  13. import java.nio.file.Path;
  14. import java.security.KeyPair;
  15. import java.util.Collections;
  16. import java.util.List;
  17. import java.util.function.BiFunction;
  18. import java.util.function.Function;

  20. import org.eclipse.jgit.annotations.NonNull;
  21. import org.eclipse.jgit.transport.CredentialsProvider;
  22. import org.eclipse.jgit.transport.SshConfigStore;
  23. import org.eclipse.jgit.util.StringUtils;

  25. /**
  26.  * A builder API to configure {@link SshdSessionFactory SshdSessionFactories}.
  27.  *
  28.  * @since 5.8
  29.  */
  30. public final class SshdSessionFactoryBuilder {

  32.     private final State state = new State();

  34.     /**
  35.      * Sets the {@link ProxyDataFactory} to use for {@link SshdSessionFactory
  36.      * SshdSessionFactories} created by {@link #build(KeyCache)}.
  37.      *
  38.      * @param proxyDataFactory
  39.      *            to use
  40.      * @return this {@link SshdSessionFactoryBuilder}
  41.      */
  42.     public SshdSessionFactoryBuilder setProxyDataFactory(
  43.             ProxyDataFactory proxyDataFactory) {
  44.         this.state.proxyDataFactory = proxyDataFactory;
  45.         return this;
  46.     }

  48.     /**
  49.      * Sets the home directory to use for {@link SshdSessionFactory
  50.      * SshdSessionFactories} created by {@link #build(KeyCache)}.
  51.      *
  52.      * @param homeDirectory
  53.      *            to use; may be {@code null}, in which case the home directory
  54.      *            as defined by {@link org.eclipse.jgit.util.FS#userHome()
  55.      *            FS.userHome()} is assumed
  56.      * @return this {@link SshdSessionFactoryBuilder}
  57.      */
  58.     public SshdSessionFactoryBuilder setHomeDirectory(File homeDirectory) {
  59.         this.state.homeDirectory = homeDirectory;
  60.         return this;
  61.     }

  63.     /**
  64.      * Sets the SSH directory to use for {@link SshdSessionFactory
  65.      * SshdSessionFactories} created by {@link #build(KeyCache)}.
  66.      *
  67.      * @param sshDirectory
  68.      *            to use; may be {@code null}, in which case ".ssh" under the
  69.      *            {@link #setHomeDirectory(File) home directory} is assumed
  70.      * @return this {@link SshdSessionFactoryBuilder}
  71.      */
  72.     public SshdSessionFactoryBuilder setSshDirectory(File sshDirectory) {
  73.         this.state.sshDirectory = sshDirectory;
  74.         return this;
  75.     }

  77.     /**
  78.      * Sets the default preferred authentication mechanisms to use for
  79.      * {@link SshdSessionFactory SshdSessionFactories} created by
  80.      * {@link #build(KeyCache)}.
  81.      *
  82.      * @param authentications
  83.      *            comma-separated list of authentication mechanism names; if
  84.      *            {@code null} or empty, the default as specified by
  85.      *            {@link SshdSessionFactory#getDefaultPreferredAuthentications()}
  86.      *            will be used
  87.      * @return this {@link SshdSessionFactoryBuilder}
  88.      */
  89.     public SshdSessionFactoryBuilder setPreferredAuthentications(
  90.             String authentications) {
  91.         this.state.preferredAuthentications = authentications;
  92.         return this;
  93.     }

  95.     /**
  96.      * Sets a function that returns the SSH config file, given the SSH
  97.      * directory. The function may return {@code null}, in which case no SSH
  98.      * config file will be used. If a non-null file is returned, it will be used
  99.      * when it exists. If no supplier has been set, or the supplier has been set
  100.      * explicitly to {@code null}, by default a file named
  101.      * {@link org.eclipse.jgit.transport.SshConstants#CONFIG
  102.      * SshConstants.CONFIG} in the {@link #setSshDirectory(File) SSH directory}
  103.      * is used.
  104.      *
  105.      * @param supplier
  106.      *            returning a {@link File} for the SSH config file to use, or
  107.      *            returning {@code null} if no config file is to be used
  108.      * @return this {@link SshdSessionFactoryBuilder}
  109.      */
  110.     public SshdSessionFactoryBuilder setConfigFile(
  111.             Function<File, File> supplier) {
  112.         this.state.configFileFinder = supplier;
  113.         return this;
  114.     }

  116.     /**
  117.      * A factory interface for creating a @link SshConfigStore}.
  118.      */
  119.     @FunctionalInterface
  120.     public interface ConfigStoreFactory {

  122.         /**
  123.          * Creates a {@link SshConfigStore}. May return {@code null} if none is
  124.          * to be used.
  125.          *
  126.          * @param homeDir
  127.          *            to use for ~-replacements
  128.          * @param configFile
  129.          *            to use, may be {@code null} if none
  130.          * @param localUserName
  131.          *            name of the current user in the local OS
  132.          * @return the {@link SshConfigStore}, or {@code null} if none is to be
  133.          *         used
  134.          */
  135.         SshConfigStore create(@NonNull File homeDir, File configFile,
  136.                 String localUserName);
  137.     }

  139.     /**
  140.      * Sets a factory for the {@link SshConfigStore} to use. If not set or
  141.      * explicitly set to {@code null}, the default as specified by
  142.      * {@link SshdSessionFactory#createSshConfigStore(File, File, String)} is
  143.      * used.
  144.      *
  145.      * @param factory
  146.      *            to set
  147.      * @return this {@link SshdSessionFactoryBuilder}
  148.      */
  149.     public SshdSessionFactoryBuilder setConfigStoreFactory(
  150.             ConfigStoreFactory factory) {
  151.         this.state.configFactory = factory;
  152.         return this;
  153.     }

  155.     /**
  156.      * Sets a function that returns the default known hosts files, given the SSH
  157.      * directory. If not set or explicitly set to {@code null}, the defaults as
  158.      * specified by {@link SshdSessionFactory#getDefaultKnownHostsFiles(File)}
  159.      * are used.
  160.      *
  161.      * @param supplier
  162.      *            to get the default known hosts files
  163.      * @return this {@link SshdSessionFactoryBuilder}
  164.      */
  165.     public SshdSessionFactoryBuilder setDefaultKnownHostsFiles(
  166.             Function<File, List<Path>> supplier) {
  167.         this.state.knownHostsFileFinder = supplier;
  168.         return this;
  169.     }

  171.     /**
  172.      * Sets a function that returns the default private key files, given the SSH
  173.      * directory. If not set or explicitly set to {@code null}, the defaults as
  174.      * specified by {@link SshdSessionFactory#getDefaultIdentities(File)} are
  175.      * used.
  176.      *
  177.      * @param supplier
  178.      *            to get the default private key files
  179.      * @return this {@link SshdSessionFactoryBuilder}
  180.      */
  181.     public SshdSessionFactoryBuilder setDefaultIdentities(
  182.             Function<File, List<Path>> supplier) {
  183.         this.state.defaultKeyFileFinder = supplier;
  184.         return this;
  185.     }

  187.     /**
  188.      * Sets a function that returns the default private keys, given the SSH
  189.      * directory. If not set or explicitly set to {@code null}, the defaults as
  190.      * specified by {@link SshdSessionFactory#getDefaultKeys(File)} are used.
  191.      *
  192.      * @param provider
  193.      *            to get the default private key files
  194.      * @return this {@link SshdSessionFactoryBuilder}
  195.      */
  196.     public SshdSessionFactoryBuilder setDefaultKeysProvider(
  197.             Function<File, Iterable<KeyPair>> provider) {
  198.         this.state.defaultKeysProvider = provider;
  199.         return this;
  200.     }

  202.     /**
  203.      * Sets a factory function to create a {@link KeyPasswordProvider}. If not
  204.      * set or explicitly set to {@code null}, or if the factory returns
  205.      * {@code null}, the default as specified by
  206.      * {@link SshdSessionFactory#createKeyPasswordProvider(CredentialsProvider)}
  207.      * is used.
  208.      *
  209.      * @param factory
  210.      *            to create a {@link KeyPasswordProvider}
  211.      * @return this {@link SshdSessionFactoryBuilder}
  212.      */
  213.     public SshdSessionFactoryBuilder setKeyPasswordProvider(
  214.             Function<CredentialsProvider, KeyPasswordProvider> factory) {
  215.         this.state.passphraseProviderFactory = factory;
  216.         return this;
  217.     }

  219.     /**
  220.      * Sets a function that creates a new {@link ServerKeyDatabase}, given the
  221.      * SSH and home directory. If not set or explicitly set to {@code null}, or
  222.      * if the {@code factory} returns {@code null}, the default as specified by
  223.      * {@link SshdSessionFactory#createServerKeyDatabase(File, File)} is used.
  224.      *
  225.      * @param factory
  226.      *            to create a {@link ServerKeyDatabase}
  227.      * @return this {@link SshdSessionFactoryBuilder}
  228.      */
  229.     public SshdSessionFactoryBuilder setServerKeyDatabase(
  230.             BiFunction<File, File, ServerKeyDatabase> factory) {
  231.         this.state.serverKeyDatabaseCreator = factory;
  232.         return this;
  233.     }

  235.     /**
  236.      * Builds a {@link SshdSessionFactory} as configured, using the given
  237.      * {@link KeyCache} for caching keys.
  238.      * <p>
  239.      * Different {@link SshdSessionFactory SshdSessionFactories} should
  240.      * <em>not</em> share the same {@link KeyCache} since the cache is
  241.      * invalidated when the factory itself or when the last {@link SshdSession}
  242.      * created from the factory is closed.
  243.      * </p>
  244.      *
  245.      * @param cache
  246.      *            to use for caching ssh keys; may be {@code null} if no caching
  247.      *            is desired.
  248.      * @return the {@link SshdSessionFactory}
  249.      */
  250.     public SshdSessionFactory build(KeyCache cache) {
  251.         // Use a copy to avoid that subsequent calls to setters affect an
  252.         // already created SshdSessionFactory.
  253.         return state.copy().build(cache);
  254.     }

  256.     private static class State {

  258.         ProxyDataFactory proxyDataFactory;

  260.         File homeDirectory;

  262.         File sshDirectory;

  264.         String preferredAuthentications;

  266.         Function<File, File> configFileFinder;

  268.         ConfigStoreFactory configFactory;

  270.         Function<CredentialsProvider, KeyPasswordProvider> passphraseProviderFactory;

  272.         Function<File, List<Path>> knownHostsFileFinder;

  274.         Function<File, List<Path>> defaultKeyFileFinder;

  276.         Function<File, Iterable<KeyPair>> defaultKeysProvider;

  278.         BiFunction<File, File, ServerKeyDatabase> serverKeyDatabaseCreator;

  280.         State copy() {
  281.             State c = new State();
  282.             c.proxyDataFactory = proxyDataFactory;
  283.             c.homeDirectory = homeDirectory;
  284.             c.sshDirectory = sshDirectory;
  285.             c.preferredAuthentications = preferredAuthentications;
  286.             c.configFileFinder = configFileFinder;
  287.             c.configFactory = configFactory;
  288.             c.passphraseProviderFactory = passphraseProviderFactory;
  289.             c.knownHostsFileFinder = knownHostsFileFinder;
  290.             c.defaultKeyFileFinder = defaultKeyFileFinder;
  291.             c.defaultKeysProvider = defaultKeysProvider;
  292.             c.serverKeyDatabaseCreator = serverKeyDatabaseCreator;
  293.             return c;
  294.         }

  296.         SshdSessionFactory build(KeyCache cache) {
  297.             SshdSessionFactory factory = new SessionFactory(cache,
  298.                     proxyDataFactory);
  299.             factory.setHomeDirectory(homeDirectory);
  300.             factory.setSshDirectory(sshDirectory);
  301.             return factory;
  302.         }

  304.         private class SessionFactory extends SshdSessionFactory {

  306.             public SessionFactory(KeyCache cache,
  307.                     ProxyDataFactory proxyDataFactory) {
  308.                 super(cache, proxyDataFactory);
  309.             }

  311.             @Override
  312.             protected File getSshConfig(File sshDir) {
  313.                 if (configFileFinder != null) {
  314.                     return configFileFinder.apply(sshDir);
  315.                 }
  316.                 return super.getSshConfig(sshDir);
  317.             }

  319.             @Override
  320.             protected List<Path> getDefaultKnownHostsFiles(File sshDir) {
  321.                 if (knownHostsFileFinder != null) {
  322.                     List<Path> result = knownHostsFileFinder.apply(sshDir);
  323.                     return result == null ? Collections.emptyList() : result;
  324.                 }
  325.                 return super.getDefaultKnownHostsFiles(sshDir);
  326.             }

  328.             @Override
  329.             protected List<Path> getDefaultIdentities(File sshDir) {
  330.                 if (defaultKeyFileFinder != null) {
  331.                     List<Path> result = defaultKeyFileFinder.apply(sshDir);
  332.                     return result == null ? Collections.emptyList() : result;
  333.                 }
  334.                 return super.getDefaultIdentities(sshDir);
  335.             }

  337.             @Override
  338.             protected String getDefaultPreferredAuthentications() {
  339.                 if (!StringUtils.isEmptyOrNull(preferredAuthentications)) {
  340.                     return preferredAuthentications;
  341.                 }
  342.                 return super.getDefaultPreferredAuthentications();
  343.             }

  345.             @Override
  346.             protected Iterable<KeyPair> getDefaultKeys(File sshDir) {
  347.                 if (defaultKeysProvider != null) {
  348.                     Iterable<KeyPair> result = defaultKeysProvider
  349.                             .apply(sshDir);
  350.                     return result == null ? Collections.emptyList() : result;
  351.                 }
  352.                 return super.getDefaultKeys(sshDir);
  353.             }

  355.             @Override
  356.             protected KeyPasswordProvider createKeyPasswordProvider(
  357.                     CredentialsProvider provider) {
  358.                 if (passphraseProviderFactory != null) {
  359.                     KeyPasswordProvider result = passphraseProviderFactory
  360.                             .apply(provider);
  361.                     if (result != null) {
  362.                         return result;
  363.                     }
  364.                 }
  365.                 return super.createKeyPasswordProvider(provider);
  366.             }

  368.             @Override
  369.             protected ServerKeyDatabase createServerKeyDatabase(File homeDir,
  370.                     File sshDir) {
  371.                 if (serverKeyDatabaseCreator != null) {
  372.                     ServerKeyDatabase result = serverKeyDatabaseCreator
  373.                             .apply(homeDir, sshDir);
  374.                     if (result != null) {
  375.                         return result;
  376.                     }
  377.                 }
  378.                 return super.createServerKeyDatabase(homeDir, sshDir);
  379.             }

  381.             @Override
  382.             protected SshConfigStore createSshConfigStore(File homeDir,
  383.                     File configFile, String localUserName) {
  384.                 if (configFactory != null) {
  385.                     return configFactory.create(homeDir, configFile,
  386.                             localUserName);
  387.                 }
  388.                 return super.createSshConfigStore(homeDir, configFile,
  389.                         localUserName);
  390.             }
  391.         }
  392.     }
  393. }
Created with JaCoCo 0.8.5.201910111838