JGitPublicKeyAuthentication.java

  1. /*
  2.  * Copyright (C) 2018, 2022 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.text.MessageFormat.format;
  13. import static org.eclipse.jgit.transport.SshConstants.PUBKEY_ACCEPTED_ALGORITHMS;

  15. import java.io.IOException;
  16. import java.net.URISyntaxException;
  17. import java.nio.file.Files;
  18. import java.nio.file.InvalidPathException;
  19. import java.nio.file.LinkOption;
  20. import java.nio.file.Path;
  21. import java.nio.file.Paths;
  22. import java.security.GeneralSecurityException;
  23. import java.security.KeyPair;
  24. import java.security.PublicKey;
  25. import java.util.ArrayList;
  26. import java.util.Arrays;
  27. import java.util.Collection;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;
  31. import java.util.NoSuchElementException;
  32. import java.util.Objects;
  33. import java.util.stream.Collectors;

  35. import org.apache.sshd.agent.SshAgent;
  36. import org.apache.sshd.agent.SshAgentFactory;
  37. import org.apache.sshd.agent.SshAgentKeyConstraint;
  38. import org.apache.sshd.client.auth.pubkey.KeyAgentIdentity;
  39. import org.apache.sshd.client.auth.pubkey.PublicKeyIdentity;
  40. import org.apache.sshd.client.auth.pubkey.UserAuthPublicKey;
  41. import org.apache.sshd.client.auth.pubkey.UserAuthPublicKeyIterator;
  42. import org.apache.sshd.client.config.hosts.HostConfigEntry;
  43. import org.apache.sshd.client.session.ClientSession;
  44. import org.apache.sshd.common.FactoryManager;
  45. import org.apache.sshd.common.NamedFactory;
  46. import org.apache.sshd.common.config.keys.AuthorizedKeyEntry;
  47. import org.apache.sshd.common.config.keys.KeyUtils;
  48. import org.apache.sshd.common.config.keys.PublicKeyEntryResolver;
  49. import org.apache.sshd.common.config.keys.u2f.SecurityKeyPublicKey;
  50. import org.apache.sshd.common.signature.Signature;
  51. import org.apache.sshd.common.signature.SignatureFactoriesManager;
  52. import org.eclipse.jgit.internal.transport.ssh.OpenSshConfigFile;
  53. import org.eclipse.jgit.transport.CredentialItem;
  54. import org.eclipse.jgit.transport.CredentialsProvider;
  55. import org.eclipse.jgit.transport.SshConstants;
  56. import org.eclipse.jgit.transport.URIish;
  57. import org.eclipse.jgit.util.StringUtils;

  59. /**
  60.  * Custom {@link UserAuthPublicKey} implementation for handling SSH config
  61.  * PubkeyAcceptedAlgorithms and interaction with the SSH agent.
  62.  */
  63. public class JGitPublicKeyAuthentication extends UserAuthPublicKey {

  65.     private SshAgent agent;

  67.     private HostConfigEntry hostConfig;

  69.     private boolean addKeysToAgent;

  71.     private boolean askBeforeAdding;

  73.     private String skProvider;

  75.     private SshAgentKeyConstraint[] constraints;

  77.     JGitPublicKeyAuthentication(List<NamedFactory<Signature>> factories) {
  78.         super(factories);
  79.     }

  81.     @Override
  82.     public void init(ClientSession rawSession, String service)
  83.             throws Exception {
  84.         if (!(rawSession instanceof JGitClientSession)) {
  85.             throw new IllegalStateException("Wrong session type: " //$NON-NLS-1$
  86.                     + rawSession.getClass().getCanonicalName());
  87.         }
  88.         JGitClientSession session = (JGitClientSession) rawSession;
  89.         hostConfig = session.getHostConfigEntry();
  90.         // Set signature algorithms for public key authentication
  91.         String pubkeyAlgos = hostConfig.getProperty(PUBKEY_ACCEPTED_ALGORITHMS);
  92.         if (!StringUtils.isEmptyOrNull(pubkeyAlgos)) {
  93.             List<String> signatures = session.getSignatureFactoriesNames();
  94.             signatures = session.modifyAlgorithmList(signatures,
  95.                     session.getAllAvailableSignatureAlgorithms(), pubkeyAlgos,
  96.                     PUBKEY_ACCEPTED_ALGORITHMS);
  97.             if (!signatures.isEmpty()) {
  98.                 if (log.isDebugEnabled()) {
  99.                     log.debug(PUBKEY_ACCEPTED_ALGORITHMS + ' ' + signatures);
  100.                 }
  101.                 setSignatureFactoriesNames(signatures);
  102.                 super.init(session, service);
  103.                 return;
  104.             }
  105.             log.warn(format(SshdText.get().configNoKnownAlgorithms,
  106.                     PUBKEY_ACCEPTED_ALGORITHMS, pubkeyAlgos));
  107.         }
  108.         // TODO: remove this once we're on an sshd version that has SSHD-1272
  109.         // fixed
  110.         List<NamedFactory<Signature>> localFactories = getSignatureFactories();
  111.         if (localFactories == null || localFactories.isEmpty()) {
  112.             setSignatureFactoriesNames(session.getSignatureFactoriesNames());
  113.         }
  114.         super.init(session, service);
  115.     }

  117.     @Override
  118.     protected Iterator<PublicKeyIdentity> createPublicKeyIterator(
  119.             ClientSession session, SignatureFactoriesManager manager)
  120.             throws Exception {
  121.         agent = getAgent(session);
  122.         if (agent != null) {
  123.             parseAddKeys(hostConfig);
  124.             if (addKeysToAgent) {
  125.                 skProvider = hostConfig.getProperty(SshConstants.SECURITY_KEY_PROVIDER);
  126.             }
  127.         }
  128.         return new KeyIterator(session, manager);
  129.     }

  131.     @Override
  132.     protected PublicKeyIdentity resolveAttemptedPublicKeyIdentity(
  133.             ClientSession session, String service) throws Exception {
  134.         PublicKeyIdentity id = super.resolveAttemptedPublicKeyIdentity(session,
  135.                 service);
  136.         if (addKeysToAgent && id != null && !(id instanceof KeyAgentIdentity)) {
  137.             KeyPair key = id.getKeyIdentity();
  138.             if (key != null && key.getPublic() != null
  139.                     && key.getPrivate() != null) {
  140.                 // We've just successfully loaded a key that wasn't in the
  141.                 // agent. Add it to the agent.
  142.                 //
  143.                 // Keys are added after loading, as in OpenSSH. The alternative
  144.                 // might be to add a key only after (partially) successful
  145.                 // authentication?
  146.                 PublicKey pk = key.getPublic();
  147.                 String fingerprint = KeyUtils.getFingerPrint(pk);
  148.                 String keyType = KeyUtils.getKeyType(key);
  149.                 try {
  150.                     // Check that the key is not in the agent already.
  151.                     if (agentHasKey(pk)) {
  152.                         return id;
  153.                     }
  154.                     if (askBeforeAdding
  155.                             && (session instanceof JGitClientSession)) {
  156.                         CredentialsProvider provider = ((JGitClientSession) session)
  157.                                 .getCredentialsProvider();
  158.                         CredentialItem.YesNoType question = new CredentialItem.YesNoType(
  159.                                 format(SshdText
  160.                                         .get().pubkeyAuthAddKeyToAgentQuestion,
  161.                                         keyType, fingerprint));
  162.                         boolean result = provider != null
  163.                                 && provider.supports(question)
  164.                                 && provider.get(getUri(), question);
  165.                         if (!result || !question.getValue()) {
  166.                             // Don't add the key.
  167.                             return id;
  168.                         }
  169.                     }
  170.                     SshAgentKeyConstraint[] rules = constraints;
  171.                     if (pk instanceof SecurityKeyPublicKey && !StringUtils.isEmptyOrNull(skProvider)) {
  172.                         rules = Arrays.copyOf(rules, rules.length + 1);
  173.                         rules[rules.length - 1] =
  174.                                 new SshAgentKeyConstraint.FidoProviderExtension(skProvider);
  175.                     }
  176.                     // Unfortunately a comment associated with the key is lost
  177.                     // by Apache MINA sshd, and there is also no way to get the
  178.                     // original file name for keys loaded from a file. So add it
  179.                     // without comment.
  180.                     agent.addIdentity(key, null, rules);
  181.                 } catch (IOException e) {
  182.                     // Do not re-throw: we don't want authentication to fail if
  183.                     // we cannot add the key to the agent.
  184.                     log.error(
  185.                             format(SshdText.get().pubkeyAuthAddKeyToAgentError,
  186.                                     keyType, fingerprint),
  187.                             e);
  188.                     // Note that as of Win32-OpenSSH 8.6 and Pageant 0.76,
  189.                     // neither can handle key constraints. Pageant fails
  190.                     // gracefully, not adding the key and returning
  191.                     // SSH_AGENT_FAILURE. Win32-OpenSSH closes the connection
  192.                     // without even returning a failure message, which violates
  193.                     // the SSH agent protocol and makes all subsequent requests
  194.                     // to the agent fail.
  195.                 }
  196.             }
  197.         }
  198.         return id;
  199.     }

  201.     private boolean agentHasKey(PublicKey pk) throws IOException {
  202.         Iterable<? extends Map.Entry<PublicKey, String>> ids = agent
  203.                 .getIdentities();
  204.         if (ids == null) {
  205.             return false;
  206.         }
  207.         Iterator<? extends Map.Entry<PublicKey, String>> iter = ids.iterator();
  208.         while (iter.hasNext()) {
  209.             if (KeyUtils.compareKeys(iter.next().getKey(), pk)) {
  210.                 return true;
  211.             }
  212.         }
  213.         return false;
  214.     }

  216.     private URIish getUri() {
  217.         String uri = SshConstants.SSH_SCHEME + "://"; //$NON-NLS-1$
  218.         String userName = hostConfig.getUsername();
  219.         if (!StringUtils.isEmptyOrNull(userName)) {
  220.             uri += userName + '@';
  221.         }
  222.         uri += hostConfig.getHost();
  223.         int port = hostConfig.getPort();
  224.         if (port > 0 && port != SshConstants.SSH_DEFAULT_PORT) {
  225.             uri += ":" + port; //$NON-NLS-1$
  226.         }
  227.         try {
  228.             return new URIish(uri);
  229.         } catch (URISyntaxException e) {
  230.             log.error(e.getLocalizedMessage(), e);
  231.         }
  232.         return new URIish();
  233.     }

  235.     private SshAgent getAgent(ClientSession session) throws Exception {
  236.         FactoryManager manager = Objects.requireNonNull(
  237.                 session.getFactoryManager(), "No session factory manager"); //$NON-NLS-1$
  238.         SshAgentFactory factory = manager.getAgentFactory();
  239.         if (factory == null) {
  240.             return null;
  241.         }
  242.         return factory.createClient(session, manager);
  243.     }

  245.     private void parseAddKeys(HostConfigEntry config) {
  246.         String value = config.getProperty(SshConstants.ADD_KEYS_TO_AGENT);
  247.         if (StringUtils.isEmptyOrNull(value)) {
  248.             addKeysToAgent = false;
  249.             return;
  250.         }
  251.         String[] values = value.split(","); //$NON-NLS-1$
  252.         List<SshAgentKeyConstraint> rules = new ArrayList<>(2);
  253.         switch (values[0]) {
  254.         case "yes": //$NON-NLS-1$
  255.             addKeysToAgent = true;
  256.             break;
  257.         case "no": //$NON-NLS-1$
  258.             addKeysToAgent = false;
  259.             break;
  260.         case "ask": //$NON-NLS-1$
  261.             addKeysToAgent = true;
  262.             askBeforeAdding = true;
  263.             break;
  264.         case "confirm": //$NON-NLS-1$
  265.             addKeysToAgent = true;
  266.             rules.add(SshAgentKeyConstraint.CONFIRM);
  267.             if (values.length > 1) {
  268.                 int seconds = OpenSshConfigFile.timeSpec(values[1]);
  269.                 if (seconds > 0) {
  270.                     rules.add(new SshAgentKeyConstraint.LifeTime(seconds));
  271.                 }
  272.             }
  273.             break;
  274.         default:
  275.             int seconds = OpenSshConfigFile.timeSpec(values[0]);
  276.             if (seconds > 0) {
  277.                 addKeysToAgent = true;
  278.                 rules.add(new SshAgentKeyConstraint.LifeTime(seconds));
  279.             }
  280.             break;
  281.         }
  282.         constraints = rules.toArray(new SshAgentKeyConstraint[0]);
  283.     }

  285.     @Override
  286.     protected void releaseKeys() throws IOException {
  287.         addKeysToAgent = false;
  288.         askBeforeAdding = false;
  289.         skProvider = null;
  290.         constraints = null;
  291.         try {
  292.             if (agent != null) {
  293.                 try {
  294.                     agent.close();
  295.                 } finally {
  296.                     agent = null;
  297.                 }
  298.             }
  299.         } finally {
  300.             super.releaseKeys();
  301.         }
  302.     }

  304.     private class KeyIterator extends UserAuthPublicKeyIterator {

  306.         private Iterable<? extends Map.Entry<PublicKey, String>> agentKeys;

  308.         // If non-null, all the public keys from explicitly given key files. Any
  309.         // agent key not matching one of these public keys will be ignored in
  310.         // getIdentities().
  311.         private Collection<PublicKey> identityFiles;

  313.         public KeyIterator(ClientSession session,
  314.                 SignatureFactoriesManager manager)
  315.                 throws Exception {
  316.             super(session, manager);
  317.         }

  319.         private List<PublicKey> getExplicitKeys(
  320.                 Collection<String> explicitFiles) {
  321.             if (explicitFiles == null) {
  322.                 return null;
  323.             }
  324.             return explicitFiles.stream().map(s -> {
  325.                 try {
  326.                     Path p = Paths.get(s + ".pub"); //$NON-NLS-1$
  327.                     if (Files.isRegularFile(p, LinkOption.NOFOLLOW_LINKS)) {
  328.                         return AuthorizedKeyEntry.readAuthorizedKeys(p).get(0)
  329.                                 .resolvePublicKey(null,
  330.                                         PublicKeyEntryResolver.IGNORING);
  331.                     }
  332.                 } catch (InvalidPathException | IOException
  333.                         | GeneralSecurityException e) {
  334.                     log.warn(format(SshdText.get().cannotReadPublicKey, s), e);
  335.                 }
  336.                 return null;
  337.             }).filter(Objects::nonNull).collect(Collectors.toList());
  338.         }

  340.         @Override
  341.         protected Iterable<KeyAgentIdentity> initializeAgentIdentities(
  342.                 ClientSession session) throws IOException {
  343.             if (agent == null) {
  344.                 return null;
  345.             }
  346.             agentKeys = agent.getIdentities();
  347.             if (hostConfig != null && hostConfig.isIdentitiesOnly()) {
  348.                 identityFiles = getExplicitKeys(hostConfig.getIdentities());
  349.             }
  350.             return () -> new Iterator<>() {

  352.                 private final Iterator<? extends Map.Entry<PublicKey, String>> iter = agentKeys
  353.                         .iterator();

  355.                 private Map.Entry<PublicKey, String> next;

  357.                 @Override
  358.                 public boolean hasNext() {
  359.                     while (next == null && iter.hasNext()) {
  360.                         Map.Entry<PublicKey, String> val = iter.next();
  361.                         PublicKey pk = val.getKey();
  362.                         // This checks against all explicit keys for any agent
  363.                         // key, but since identityFiles.size() is typically 1,
  364.                         // it should be fine.
  365.                         if (identityFiles == null || identityFiles.stream()
  366.                                 .anyMatch(k -> KeyUtils.compareKeys(k, pk))) {
  367.                             next = val;
  368.                             return true;
  369.                         }
  370.                         if (log.isTraceEnabled()) {
  371.                             log.trace(
  372.                                     "Ignoring SSH agent {} key not in explicit IdentityFile in SSH config: {}", //$NON-NLS-1$
  373.                                     KeyUtils.getKeyType(pk),
  374.                                     KeyUtils.getFingerPrint(pk));
  375.                         }
  376.                     }
  377.                     return next != null;
  378.                 }

  380.                 @Override
  381.                 public KeyAgentIdentity next() {
  382.                     if (!hasNext()) {
  383.                         throw new NoSuchElementException();
  384.                     }
  385.                     KeyAgentIdentity result = new KeyAgentIdentity(agent,
  386.                             next.getKey(), next.getValue());
  387.                     next = null;
  388.                     return result;
  389.                 }
  390.             };
  391.         }
  392.     }
  393. }
Created with JaCoCo 0.8.7.202105040129