OpenSshServerKeyDatabase.java

  1. /*
  2.  * Copyright (C) 2018, 2019 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.internal.transport.sshd;

  12. import static java.nio.charset.StandardCharsets.UTF_8;
  13. import static java.text.MessageFormat.format;

  15. import java.io.BufferedReader;
  16. import java.io.BufferedWriter;
  17. import java.io.FileNotFoundException;
  18. import java.io.IOException;
  19. import java.io.OutputStreamWriter;
  20. import java.net.InetSocketAddress;
  21. import java.net.SocketAddress;
  22. import java.nio.file.Files;
  23. import java.nio.file.InvalidPathException;
  24. import java.nio.file.Path;
  25. import java.nio.file.Paths;
  26. import java.security.GeneralSecurityException;
  27. import java.security.PublicKey;
  28. import java.security.SecureRandom;
  29. import java.util.ArrayList;
  30. import java.util.Arrays;
  31. import java.util.Collection;
  32. import java.util.Collections;
  33. import java.util.LinkedList;
  34. import java.util.List;
  35. import java.util.Map;
  36. import java.util.TreeSet;
  37. import java.util.concurrent.ConcurrentHashMap;
  38. import java.util.function.Supplier;

  40. import org.apache.sshd.client.config.hosts.HostPatternsHolder;
  41. import org.apache.sshd.client.config.hosts.KnownHostDigest;
  42. import org.apache.sshd.client.config.hosts.KnownHostEntry;
  43. import org.apache.sshd.client.config.hosts.KnownHostHashValue;
  44. import org.apache.sshd.client.keyverifier.KnownHostsServerKeyVerifier.HostEntryPair;
  45. import org.apache.sshd.client.session.ClientSession;
  46. import org.apache.sshd.common.NamedFactory;
  47. import org.apache.sshd.common.config.keys.AuthorizedKeyEntry;
  48. import org.apache.sshd.common.config.keys.KeyUtils;
  49. import org.apache.sshd.common.config.keys.PublicKeyEntry;
  50. import org.apache.sshd.common.config.keys.PublicKeyEntryResolver;
  51. import org.apache.sshd.common.digest.BuiltinDigests;
  52. import org.apache.sshd.common.mac.Mac;
  53. import org.apache.sshd.common.util.io.ModifiableFileWatcher;
  54. import org.apache.sshd.common.util.net.SshdSocketAddress;
  55. import org.eclipse.jgit.annotations.NonNull;
  56. import org.eclipse.jgit.internal.storage.file.LockFile;
  57. import org.eclipse.jgit.transport.CredentialItem;
  58. import org.eclipse.jgit.transport.CredentialsProvider;
  59. import org.eclipse.jgit.transport.URIish;
  60. import org.eclipse.jgit.transport.sshd.ServerKeyDatabase;
  61. import org.slf4j.Logger;
  62. import org.slf4j.LoggerFactory;

  64. /**
  65.  * A sever host key verifier that honors the {@code StrictHostKeyChecking} and
  66.  * {@code UserKnownHostsFile} values from the ssh configuration.
  67.  * <p>
  68.  * The verifier can be given default known_hosts files in the constructor, which
  69.  * will be used if the ssh config does not specify a {@code UserKnownHostsFile}.
  70.  * If the ssh config <em>does</em> set {@code UserKnownHostsFile}, the verifier
  71.  * uses the given files in the order given. Non-existing or unreadable files are
  72.  * ignored.
  73.  * <p>
  74.  * {@code StrictHostKeyChecking} accepts the following values:
  75.  * </p>
  76.  * <dl>
  77.  * <dt>ask</dt>
  78.  * <dd>Ask the user whether new or changed keys shall be accepted and be added
  79.  * to the known_hosts file.</dd>
  80.  * <dt>yes/true</dt>
  81.  * <dd>Accept only keys listed in the known_hosts file.</dd>
  82.  * <dt>no/false</dt>
  83.  * <dd>Silently accept all new or changed keys, add new keys to the known_hosts
  84.  * file.</dd>
  85.  * <dt>accept-new</dt>
  86.  * <dd>Silently accept keys for new hosts and add them to the known_hosts
  87.  * file.</dd>
  88.  * </dl>
  89.  * <p>
  90.  * If {@code StrictHostKeyChecking} is not set, or set to any other value, the
  91.  * default value <b>ask</b> is active.
  92.  * </p>
  93.  * <p>
  94.  * This implementation relies on the {@link ClientSession} being a
  95.  * {@link JGitClientSession}. By default Apache MINA sshd does not forward the
  96.  * config file host entry to the session, so it would be unknown here which
  97.  * entry it was and what setting of {@code StrictHostKeyChecking} should be
  98.  * used. If used with some other session type, the implementation assumes
  99.  * "<b>ask</b>".
  100.  * <p>
  101.  * <p>
  102.  * Asking the user is done via a {@link CredentialsProvider} obtained from the
  103.  * session. If none is set, the implementation falls back to strict host key
  104.  * checking ("<b>yes</b>").
  105.  * </p>
  106.  * <p>
  107.  * Note that adding a key to the known hosts file may create the file. You can
  108.  * specify in the constructor whether the user shall be asked about that, too.
  109.  * If the user declines updating the file, but the key was otherwise
  110.  * accepted (user confirmed for "<b>ask</b>", or "no" or "accept-new" are
  111.  * active), the key is accepted for this session only.
  112.  * </p>
  113.  * <p>
  114.  * If several known hosts files are specified, a new key is always added to the
  115.  * first file (even if it doesn't exist yet; see the note about file creation
  116.  * above).
  117.  * </p>
  118.  *
  119.  * @see <a href="http://man.openbsd.org/OpenBSD-current/man5/ssh_config.5">man
  120.  *      ssh-config</a>
  121.  */
  122. public class OpenSshServerKeyDatabase
  123.         implements ServerKeyDatabase {

  125.     // TODO: GlobalKnownHostsFile? May need some kind of LRU caching; these
  126.     // files may be large!

  128.     private static final Logger LOG = LoggerFactory
  129.             .getLogger(OpenSshServerKeyDatabase.class);

  131.     /** Can be used to mark revoked known host lines. */
  132.     private static final String MARKER_REVOKED = "revoked"; //$NON-NLS-1$

  134.     private final boolean askAboutNewFile;

  136.     private final Map<Path, HostKeyFile> knownHostsFiles = new ConcurrentHashMap<>();

  138.     private final List<HostKeyFile> defaultFiles = new ArrayList<>();

  140.     /**
  141.      * Creates a new {@link OpenSshServerKeyDatabase}.
  142.      *
  143.      * @param askAboutNewFile
  144.      *            whether to ask the user, if possible, about creating a new
  145.      *            non-existing known_hosts file
  146.      * @param defaultFiles
  147.      *            typically ~/.ssh/known_hosts and ~/.ssh/known_hosts2. May be
  148.      *            empty or {@code null}, in which case no default files are
  149.      *            installed. The files need not exist.
  150.      */
  151.     public OpenSshServerKeyDatabase(boolean askAboutNewFile,
  152.             List<Path> defaultFiles) {
  153.         if (defaultFiles != null) {
  154.             for (Path file : defaultFiles) {
  155.                 HostKeyFile newFile = new HostKeyFile(file);
  156.                 knownHostsFiles.put(file, newFile);
  157.                 this.defaultFiles.add(newFile);
  158.             }
  159.         }
  160.         this.askAboutNewFile = askAboutNewFile;
  161.     }

  163.     private List<HostKeyFile> getFilesToUse(@NonNull Configuration config) {
  164.         List<HostKeyFile> filesToUse = defaultFiles;
  165.         List<HostKeyFile> userFiles = addUserHostKeyFiles(
  166.                 config.getUserKnownHostsFiles());
  167.         if (!userFiles.isEmpty()) {
  168.             filesToUse = userFiles;
  169.         }
  170.         return filesToUse;
  171.     }

  173.     @Override
  174.     public List<PublicKey> lookup(@NonNull String connectAddress,
  175.             @NonNull InetSocketAddress remoteAddress,
  176.             @NonNull Configuration config) {
  177.         List<HostKeyFile> filesToUse = getFilesToUse(config);
  178.         List<PublicKey> result = new ArrayList<>();
  179.         Collection<SshdSocketAddress> candidates = getCandidates(
  180.                 connectAddress, remoteAddress);
  181.         for (HostKeyFile file : filesToUse) {
  182.             for (HostEntryPair current : file.get()) {
  183.                 KnownHostEntry entry = current.getHostEntry();
  184.                 for (SshdSocketAddress host : candidates) {
  185.                     if (entry.isHostMatch(host.getHostName(), host.getPort())) {
  186.                         result.add(current.getServerKey());
  187.                         break;
  188.                     }
  189.                 }
  190.             }
  191.         }
  192.         return result;
  193.     }

  195.     @Override
  196.     public boolean accept(@NonNull String connectAddress,
  197.             @NonNull InetSocketAddress remoteAddress,
  198.             @NonNull PublicKey serverKey,
  199.             @NonNull Configuration config, CredentialsProvider provider) {
  200.         List<HostKeyFile> filesToUse = getFilesToUse(config);
  201.         AskUser ask = new AskUser(config, provider);
  202.         HostEntryPair[] modified = { null };
  203.         Path path = null;
  204.         Collection<SshdSocketAddress> candidates = getCandidates(connectAddress,
  205.                 remoteAddress);
  206.         for (HostKeyFile file : filesToUse) {
  207.             try {
  208.                 if (find(candidates, serverKey, file.get(), modified)) {
  209.                     return true;
  210.                 }
  211.             } catch (RevokedKeyException e) {
  212.                 ask.revokedKey(remoteAddress, serverKey, file.getPath());
  213.                 return false;
  214.             }
  215.             if (path == null && modified[0] != null) {
  216.                 // Remember the file in which we might need to update the
  217.                 // entry
  218.                 path = file.getPath();
  219.             }
  220.         }
  221.         if (modified[0] != null) {
  222.             // We found an entry, but with a different key
  223.             AskUser.ModifiedKeyHandling toDo = ask.acceptModifiedServerKey(
  224.                     remoteAddress, modified[0].getServerKey(),
  225.                     serverKey, path);
  226.             if (toDo == AskUser.ModifiedKeyHandling.ALLOW_AND_STORE) {
  227.                 try {
  228.                     updateModifiedServerKey(serverKey, modified[0], path);
  229.                     knownHostsFiles.get(path).resetReloadAttributes();
  230.                 } catch (IOException e) {
  231.                     LOG.warn(format(SshdText.get().knownHostsCouldNotUpdate,
  232.                             path));
  233.                 }
  234.             }
  235.             if (toDo == AskUser.ModifiedKeyHandling.DENY) {
  236.                 return false;
  237.             }
  238.             // TODO: OpenSsh disables password and keyboard-interactive
  239.             // authentication in this case. Also agent and local port forwarding
  240.             // are switched off. (Plus a few other things such as X11 forwarding
  241.             // that are of no interest to a git client.)
  242.             return true;
  243.         } else if (ask.acceptUnknownKey(remoteAddress, serverKey)) {
  244.             if (!filesToUse.isEmpty()) {
  245.                 HostKeyFile toUpdate = filesToUse.get(0);
  246.                 path = toUpdate.getPath();
  247.                 try {
  248.                     if (Files.exists(path) || !askAboutNewFile
  249.                             || ask.createNewFile(path)) {
  250.                         updateKnownHostsFile(candidates, serverKey, path,
  251.                                 config);
  252.                         toUpdate.resetReloadAttributes();
  253.                     }
  254.                 } catch (Exception e) {
  255.                     LOG.warn(format(SshdText.get().knownHostsCouldNotUpdate,
  256.                             path), e);
  257.                 }
  258.             }
  259.             return true;
  260.         }
  261.         return false;
  262.     }

  264.     private static class RevokedKeyException extends Exception {
  265.         private static final long serialVersionUID = 1L;
  266.     }

  268.     private boolean find(Collection<SshdSocketAddress> candidates,
  269.             PublicKey serverKey, List<HostEntryPair> entries,
  270.             HostEntryPair[] modified) throws RevokedKeyException {
  271.         for (HostEntryPair current : entries) {
  272.             KnownHostEntry entry = current.getHostEntry();
  273.             for (SshdSocketAddress host : candidates) {
  274.                 if (entry.isHostMatch(host.getHostName(), host.getPort())) {
  275.                     boolean isRevoked = MARKER_REVOKED
  276.                             .equals(entry.getMarker());
  277.                     if (KeyUtils.compareKeys(serverKey,
  278.                             current.getServerKey())) {
  279.                         // Exact match
  280.                         if (isRevoked) {
  281.                             throw new RevokedKeyException();
  282.                         }
  283.                         modified[0] = null;
  284.                         return true;
  285.                     } else if (!isRevoked) {
  286.                         // Server sent a different key
  287.                         modified[0] = current;
  288.                         // Keep going -- maybe there's another entry for this
  289.                         // host
  290.                     }
  291.                 }
  292.             }
  293.         }
  294.         return false;
  295.     }

  297.     private List<HostKeyFile> addUserHostKeyFiles(List<String> fileNames) {
  298.         if (fileNames == null || fileNames.isEmpty()) {
  299.             return Collections.emptyList();
  300.         }
  301.         List<HostKeyFile> userFiles = new ArrayList<>();
  302.         for (String name : fileNames) {
  303.             try {
  304.                 Path path = Paths.get(name);
  305.                 HostKeyFile file = knownHostsFiles.computeIfAbsent(path,
  306.                         p -> new HostKeyFile(path));
  307.                 userFiles.add(file);
  308.             } catch (InvalidPathException e) {
  309.                 LOG.warn(format(SshdText.get().knownHostsInvalidPath,
  310.                         name));
  311.             }
  312.         }
  313.         return userFiles;
  314.     }

  316.     private void updateKnownHostsFile(Collection<SshdSocketAddress> candidates,
  317.             PublicKey serverKey, Path path, Configuration config)
  318.             throws Exception {
  319.         String newEntry = createHostKeyLine(candidates, serverKey, config);
  320.         if (newEntry == null) {
  321.             return;
  322.         }
  323.         LockFile lock = new LockFile(path.toFile());
  324.         if (lock.lockForAppend()) {
  325.             try {
  326.                 try (BufferedWriter writer = new BufferedWriter(
  327.                         new OutputStreamWriter(lock.getOutputStream(),
  328.                                 UTF_8))) {
  329.                     writer.newLine();
  330.                     writer.write(newEntry);
  331.                     writer.newLine();
  332.                 }
  333.                 lock.commit();
  334.             } catch (IOException e) {
  335.                 lock.unlock();
  336.                 throw e;
  337.             }
  338.         } else {
  339.             LOG.warn(format(SshdText.get().knownHostsFileLockedUpdate,
  340.                     path));
  341.         }
  342.     }

  344.     private void updateModifiedServerKey(PublicKey serverKey,
  345.             HostEntryPair entry, Path path)
  346.             throws IOException {
  347.         KnownHostEntry hostEntry = entry.getHostEntry();
  348.         String oldLine = hostEntry.getConfigLine();
  349.         if (oldLine == null) {
  350.             return;
  351.         }
  352.         String newLine = updateHostKeyLine(oldLine, serverKey);
  353.         if (newLine == null || newLine.isEmpty()) {
  354.             return;
  355.         }
  356.         if (oldLine.isEmpty() || newLine.equals(oldLine)) {
  357.             // Shouldn't happen.
  358.             return;
  359.         }
  360.         LockFile lock = new LockFile(path.toFile());
  361.         if (lock.lock()) {
  362.             try {
  363.                 try (BufferedWriter writer = new BufferedWriter(
  364.                         new OutputStreamWriter(lock.getOutputStream(), UTF_8));
  365.                         BufferedReader reader = Files.newBufferedReader(path,
  366.                                 UTF_8)) {
  367.                     boolean done = false;
  368.                     String line;
  369.                     while ((line = reader.readLine()) != null) {
  370.                         String toWrite = line;
  371.                         if (!done) {
  372.                             int pos = line.indexOf('#');
  373.                             String toTest = pos < 0 ? line
  374.                                     : line.substring(0, pos);
  375.                             if (toTest.trim().equals(oldLine)) {
  376.                                 toWrite = newLine;
  377.                                 done = true;
  378.                             }
  379.                         }
  380.                         writer.write(toWrite);
  381.                         writer.newLine();
  382.                     }
  383.                 }
  384.                 lock.commit();
  385.             } catch (IOException e) {
  386.                 lock.unlock();
  387.                 throw e;
  388.             }
  389.         } else {
  390.             LOG.warn(format(SshdText.get().knownHostsFileLockedUpdate,
  391.                     path));
  392.         }
  393.     }

  395.     private static class AskUser {

  397.         public enum ModifiedKeyHandling {
  398.             DENY, ALLOW, ALLOW_AND_STORE
  399.         }

  401.         private enum Check {
  402.             ASK, DENY, ALLOW;
  403.         }

  405.         private final @NonNull Configuration config;

  407.         private final CredentialsProvider provider;

  409.         public AskUser(@NonNull Configuration config,
  410.                 CredentialsProvider provider) {
  411.             this.config = config;
  412.             this.provider = provider;
  413.         }

  415.         private static boolean askUser(CredentialsProvider provider, URIish uri,
  416.                 String prompt, String... messages) {
  417.             List<CredentialItem> items = new ArrayList<>(messages.length + 1);
  418.             for (String message : messages) {
  419.                 items.add(new CredentialItem.InformationalMessage(message));
  420.             }
  421.             if (prompt != null) {
  422.                 CredentialItem.YesNoType answer = new CredentialItem.YesNoType(
  423.                         prompt);
  424.                 items.add(answer);
  425.                 return provider.get(uri, items) && answer.getValue();
  426.             }
  427.             return provider.get(uri, items);
  428.         }

  430.         private Check checkMode(SocketAddress remoteAddress, boolean changed) {
  431.             if (!(remoteAddress instanceof InetSocketAddress)) {
  432.                 return Check.DENY;
  433.             }
  434.             switch (config.getStrictHostKeyChecking()) {
  435.             case REQUIRE_MATCH:
  436.                 return Check.DENY;
  437.             case ACCEPT_ANY:
  438.                 return Check.ALLOW;
  439.             case ACCEPT_NEW:
  440.                 return changed ? Check.DENY : Check.ALLOW;
  441.             default:
  442.                 return provider == null ? Check.DENY : Check.ASK;
  443.             }
  444.         }

  446.         public void revokedKey(SocketAddress remoteAddress, PublicKey serverKey,
  447.                 Path path) {
  448.             if (provider == null) {
  449.                 return;
  450.             }
  451.             InetSocketAddress remote = (InetSocketAddress) remoteAddress;
  452.             URIish uri = JGitUserInteraction.toURI(config.getUsername(),
  453.                     remote);
  454.             String sha256 = KeyUtils.getFingerPrint(BuiltinDigests.sha256,
  455.                     serverKey);
  456.             String md5 = KeyUtils.getFingerPrint(BuiltinDigests.md5, serverKey);
  457.             String keyAlgorithm = serverKey.getAlgorithm();
  458.             askUser(provider, uri, null, //
  459.                     format(SshdText.get().knownHostsRevokedKeyMsg,
  460.                             remote.getHostString(), path),
  461.                     format(SshdText.get().knownHostsKeyFingerprints,
  462.                             keyAlgorithm),
  463.                     md5, sha256);
  464.         }

  466.         public boolean acceptUnknownKey(SocketAddress remoteAddress,
  467.                 PublicKey serverKey) {
  468.             Check check = checkMode(remoteAddress, false);
  469.             if (check != Check.ASK) {
  470.                 return check == Check.ALLOW;
  471.             }
  472.             InetSocketAddress remote = (InetSocketAddress) remoteAddress;
  473.             // Ask the user
  474.             String sha256 = KeyUtils.getFingerPrint(BuiltinDigests.sha256,
  475.                     serverKey);
  476.             String md5 = KeyUtils.getFingerPrint(BuiltinDigests.md5, serverKey);
  477.             String keyAlgorithm = serverKey.getAlgorithm();
  478.             String remoteHost = remote.getHostString();
  479.             URIish uri = JGitUserInteraction.toURI(config.getUsername(),
  480.                     remote);
  481.             String prompt = SshdText.get().knownHostsUnknownKeyPrompt;
  482.             return askUser(provider, uri, prompt, //
  483.                     format(SshdText.get().knownHostsUnknownKeyMsg,
  484.                             remoteHost),
  485.                     format(SshdText.get().knownHostsKeyFingerprints,
  486.                             keyAlgorithm),
  487.                     md5, sha256);
  488.         }

  490.         public ModifiedKeyHandling acceptModifiedServerKey(
  491.                 InetSocketAddress remoteAddress, PublicKey expected,
  492.                 PublicKey actual, Path path) {
  493.             Check check = checkMode(remoteAddress, true);
  494.             if (check == Check.ALLOW) {
  495.                 // Never auto-store on CHECK.ALLOW
  496.                 return ModifiedKeyHandling.ALLOW;
  497.             }
  498.             String keyAlgorithm = actual.getAlgorithm();
  499.             String remoteHost = remoteAddress.getHostString();
  500.             URIish uri = JGitUserInteraction.toURI(config.getUsername(),
  501.                     remoteAddress);
  502.             List<String> messages = new ArrayList<>();
  503.             String warning = format(
  504.                     SshdText.get().knownHostsModifiedKeyWarning,
  505.                     keyAlgorithm, expected.getAlgorithm(), remoteHost,
  506.                     KeyUtils.getFingerPrint(BuiltinDigests.md5, expected),
  507.                     KeyUtils.getFingerPrint(BuiltinDigests.sha256, expected),
  508.                     KeyUtils.getFingerPrint(BuiltinDigests.md5, actual),
  509.                     KeyUtils.getFingerPrint(BuiltinDigests.sha256, actual));
  510.             messages.addAll(Arrays.asList(warning.split("\n"))); //$NON-NLS-1$

  512.             if (check == Check.DENY) {
  513.                 if (provider != null) {
  514.                     messages.add(format(
  515.                             SshdText.get().knownHostsModifiedKeyDenyMsg, path));
  516.                     askUser(provider, uri, null,
  517.                             messages.toArray(new String[0]));
  518.                 }
  519.                 return ModifiedKeyHandling.DENY;
  520.             }
  521.             // ASK -- two questions: procceed? and store?
  522.             List<CredentialItem> items = new ArrayList<>(messages.size() + 2);
  523.             for (String message : messages) {
  524.                 items.add(new CredentialItem.InformationalMessage(message));
  525.             }
  526.             CredentialItem.YesNoType proceed = new CredentialItem.YesNoType(
  527.                     SshdText.get().knownHostsModifiedKeyAcceptPrompt);
  528.             CredentialItem.YesNoType store = new CredentialItem.YesNoType(
  529.                     SshdText.get().knownHostsModifiedKeyStorePrompt);
  530.             items.add(proceed);
  531.             items.add(store);
  532.             if (provider.get(uri, items) && proceed.getValue()) {
  533.                 return store.getValue() ? ModifiedKeyHandling.ALLOW_AND_STORE
  534.                         : ModifiedKeyHandling.ALLOW;
  535.             }
  536.             return ModifiedKeyHandling.DENY;
  537.         }

  539.         public boolean createNewFile(Path path) {
  540.             if (provider == null) {
  541.                 // We can't ask, so don't create the file
  542.                 return false;
  543.             }
  544.             URIish uri = new URIish().setPath(path.toString());
  545.             return askUser(provider, uri, //
  546.                     format(SshdText.get().knownHostsUserAskCreationPrompt,
  547.                             path), //
  548.                     format(SshdText.get().knownHostsUserAskCreationMsg, path));
  549.         }
  550.     }

  552.     private static class HostKeyFile extends ModifiableFileWatcher
  553.             implements Supplier<List<HostEntryPair>> {

  555.         private List<HostEntryPair> entries = Collections.emptyList();

  557.         public HostKeyFile(Path path) {
  558.             super(path);
  559.         }

  561.         @Override
  562.         public List<HostEntryPair> get() {
  563.             Path path = getPath();
  564.             try {
  565.                 if (checkReloadRequired()) {
  566.                     if (!Files.exists(path)) {
  567.                         // Has disappeared.
  568.                         resetReloadAttributes();
  569.                         return Collections.emptyList();
  570.                     }
  571.                     LockFile lock = new LockFile(path.toFile());
  572.                     if (lock.lock()) {
  573.                         try {
  574.                             entries = reload(getPath());
  575.                         } finally {
  576.                             lock.unlock();
  577.                         }
  578.                     } else {
  579.                         LOG.warn(format(SshdText.get().knownHostsFileLockedRead,
  580.                                 path));
  581.                     }
  582.                 }
  583.             } catch (IOException e) {
  584.                 LOG.warn(format(SshdText.get().knownHostsFileReadFailed, path));
  585.             }
  586.             return Collections.unmodifiableList(entries);
  587.         }

  589.         private List<HostEntryPair> reload(Path path) throws IOException {
  590.             try {
  591.                 List<KnownHostEntry> rawEntries = KnownHostEntryReader
  592.                         .readFromFile(path);
  593.                 updateReloadAttributes();
  594.                 if (rawEntries == null || rawEntries.isEmpty()) {
  595.                     return Collections.emptyList();
  596.                 }
  597.                 List<HostEntryPair> newEntries = new LinkedList<>();
  598.                 for (KnownHostEntry entry : rawEntries) {
  599.                     AuthorizedKeyEntry keyPart = entry.getKeyEntry();
  600.                     if (keyPart == null) {
  601.                         continue;
  602.                     }
  603.                     try {
  604.                         PublicKey serverKey = keyPart.resolvePublicKey(null,
  605.                                 PublicKeyEntryResolver.IGNORING);
  606.                         if (serverKey == null) {
  607.                             LOG.warn(format(
  608.                                     SshdText.get().knownHostsUnknownKeyType,
  609.                                     path, entry.getConfigLine()));
  610.                         } else {
  611.                             newEntries.add(new HostEntryPair(entry, serverKey));
  612.                         }
  613.                     } catch (GeneralSecurityException e) {
  614.                         LOG.warn(format(SshdText.get().knownHostsInvalidLine,
  615.                                 path, entry.getConfigLine()));
  616.                     }
  617.                 }
  618.                 return newEntries;
  619.             } catch (FileNotFoundException e) {
  620.                 resetReloadAttributes();
  621.                 return Collections.emptyList();
  622.             }
  623.         }
  624.     }

  626.     private int parsePort(String s) {
  627.         try {
  628.             return Integer.parseInt(s);
  629.         } catch (NumberFormatException e) {
  630.             return -1;
  631.         }
  632.     }

  634.     private SshdSocketAddress toSshdSocketAddress(@NonNull String address) {
  635.         String host = null;
  636.         int port = 0;
  637.         if (HostPatternsHolder.NON_STANDARD_PORT_PATTERN_ENCLOSURE_START_DELIM == address
  638.                 .charAt(0)) {
  639.             int end = address.indexOf(
  640.                     HostPatternsHolder.NON_STANDARD_PORT_PATTERN_ENCLOSURE_END_DELIM);
  641.             if (end <= 1) {
  642.                 return null; // Invalid
  643.             }
  644.             host = address.substring(1, end);
  645.             if (end < address.length() - 1
  646.                     && HostPatternsHolder.PORT_VALUE_DELIMITER == address
  647.                             .charAt(end + 1)) {
  648.                 port = parsePort(address.substring(end + 2));
  649.             }
  650.         } else {
  651.             int i = address
  652.                     .lastIndexOf(HostPatternsHolder.PORT_VALUE_DELIMITER);
  653.             if (i > 0) {
  654.                 port = parsePort(address.substring(i + 1));
  655.                 host = address.substring(0, i);
  656.             } else {
  657.                 host = address;
  658.             }
  659.         }
  660.         if (port < 0 || port > 65535) {
  661.             return null;
  662.         }
  663.         return new SshdSocketAddress(host, port);
  664.     }

  666.     private Collection<SshdSocketAddress> getCandidates(
  667.             @NonNull String connectAddress,
  668.             @NonNull InetSocketAddress remoteAddress) {
  669.         Collection<SshdSocketAddress> candidates = new TreeSet<>(
  670.                 SshdSocketAddress.BY_HOST_AND_PORT);
  671.         candidates.add(SshdSocketAddress.toSshdSocketAddress(remoteAddress));
  672.         SshdSocketAddress address = toSshdSocketAddress(connectAddress);
  673.         if (address != null) {
  674.             candidates.add(address);
  675.         }
  676.         return candidates;
  677.     }

  679.     private String createHostKeyLine(Collection<SshdSocketAddress> patterns,
  680.             PublicKey key, Configuration config) throws Exception {
  681.         StringBuilder result = new StringBuilder();
  682.         if (config.getHashKnownHosts()) {
  683.             // SHA1 is the only algorithm for host name hashing known to OpenSSH
  684.             // or to Apache MINA sshd.
  685.             NamedFactory<Mac> digester = KnownHostDigest.SHA1;
  686.             Mac mac = digester.create();
  687.             SecureRandom prng = new SecureRandom();
  688.             byte[] salt = new byte[mac.getDefaultBlockSize()];
  689.             for (SshdSocketAddress address : patterns) {
  690.                 if (result.length() > 0) {
  691.                     result.append(',');
  692.                 }
  693.                 prng.nextBytes(salt);
  694.                 KnownHostHashValue.append(result, digester, salt,
  695.                         KnownHostHashValue.calculateHashValue(
  696.                                 address.getHostName(), address.getPort(), mac,
  697.                                 salt));
  698.             }
  699.         } else {
  700.             for (SshdSocketAddress address : patterns) {
  701.                 if (result.length() > 0) {
  702.                     result.append(',');
  703.                 }
  704.                 KnownHostHashValue.appendHostPattern(result,
  705.                         address.getHostName(), address.getPort());
  706.             }
  707.         }
  708.         result.append(' ');
  709.         PublicKeyEntry.appendPublicKeyEntry(result, key);
  710.         return result.toString();
  711.     }

  713.     private String updateHostKeyLine(String line, PublicKey newKey)
  714.             throws IOException {
  715.         // Replaces an existing public key by the new key
  716.         int pos = line.indexOf(' ');
  717.         if (pos > 0 && line.charAt(0) == KnownHostEntry.MARKER_INDICATOR) {
  718.             // We're at the end of the marker. Skip ahead to the next blank.
  719.             pos = line.indexOf(' ', pos + 1);
  720.         }
  721.         if (pos < 0) {
  722.             // Don't update if bogus format
  723.             return null;
  724.         }
  725.         StringBuilder result = new StringBuilder(line.substring(0, pos + 1));
  726.         PublicKeyEntry.appendPublicKeyEntry(result, newKey);
  727.         return result.toString();
  728.     }

  730. }
Created with JaCoCo 0.8.6.202009150832