Java 类java.net.PasswordAuthentication 实例源码

public void testIsAuthenticationDialogSuppressed() throws Exception {
    final boolean[] suppressed = new boolean[1];
    Authenticator.setDefault(new Authenticator() {

        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            suppressed[0] = NetworkSettings.isAuthenticationDialogSuppressed();
            return super.getPasswordAuthentication();
        }
    });

    Callable<Void> callable = new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            Authenticator.requestPasswordAuthentication("wher.ev.er", Inet4Address.getByName("1.2.3.4"), 1234, "http", null, "http");
            return null;
        }
    };
    NetworkSettings.suppressAuthenticationDialog(callable);
    assertTrue(suppressed[0]);
}

private RemoteRepository(PasswordAuthentication pa, String forPath, boolean fixedUrl) {
    assert !fixedUrl || forPath != null && !forPath.trim().isEmpty();
    this.panel = new RemoteRepositoryPanel();

    this.urlFixed = fixedUrl;
    settingTypes = new ConnectionSettingsType[] {
        new GitConnectionSettingsType(),
        new SSHConnectionSettingsType(),
        new FileConnectionSettingsType(),
        new DefaultConnectionSettingsType()
    };
    this.activeSettingsType = settingTypes[0];
    initHeight();
    attachListeners();
    initUrlComboValues(forPath, pa);
    updateCurrentSettingsType();
    validateFields();
}

private void getAnswer() {
    if (!answered) {
        answered = true;
        PasswordAuthentication passAuth =
                Authenticator.requestPasswordAuthentication(
                hci.host, hci.addr, hci.port, hci.protocol,
                hci.prompt, hci.scheme, hci.url, hci.authType);
        /**
         * To be compatible with existing callback handler implementations,
         * when the underlying Authenticator is canceled, username and
         * password are assigned null. No exception is thrown.
         */
        if (passAuth != null) {
            username = passAuth.getUserName();
            password = passAuth.getPassword();
        }
    }
}

private void init (PasswordAuthentication pw) {
    this.pw = pw;
    if (pw != null) {
        String s = pw.getUserName();
        int i = s.indexOf ('\\');
        if (i == -1) {
            username = s;
            ntdomain = defaultDomain;
        } else {
            ntdomain = s.substring (0, i).toUpperCase();
            username = s.substring (i+1);
        }
        password = new String (pw.getPassword());
    } else {
        /* credentials will be acquired from OS */
        username = null;
        ntdomain = null;
        password = null;
    }
    init0();
}

private void init (PasswordAuthentication pw) {
    this.pw = pw;
    if (pw != null) {
        String s = pw.getUserName();
        int i = s.indexOf ('\\');
        if (i == -1) {
            username = s;
            ntdomain = defaultDomain;
        } else {
            ntdomain = s.substring (0, i).toUpperCase();
            username = s.substring (i+1);
        }
        password = new String (pw.getPassword());
    } else {
        /* credentials will be acquired from OS */
        username = null;
        ntdomain = null;
        password = null;
    }
    init0();
}

public PasswordAuthentication getPasswordAuthentication(String url, boolean forceRelogin) {
    if(kenaiAccessor != null) {
        if(forceRelogin && queriedUrls.contains(url)) {
            // we already queried the authentication for this url, but it didn't
            // seem to be accepted -> force a new login, the current user
            // might not be authorized for the given kenai project (url).
            if(!kenaiAccessor.showLogin()) {
                return null;
            }
        }
        queriedUrls.add(url);
        return kenaiAccessor.getPasswordAuthentication(url);
    } else {
        return null;
    }
}

@Test
public void testUserPassword() throws Exception {
  startServer(buildUserPasswordConfig());

  Authenticator.setDefault(new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
      return new PasswordAuthentication("oryx", "pass".toCharArray());
    }
  });

  try {
    String response = Resources.toString(
        new URL("http://localhost:" + getHTTPPort() + "/helloWorld"),
        StandardCharsets.UTF_8);
    assertEquals("Hello, World", response);
  } finally {
    Authenticator.setDefault(null);
  }
}

public static void main(String[] args) throws Exception {
    final String user = "probe";
    final String password = "probe";

    Proxy proxyTest = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("127.0.0.1", 10779));

    java.net.Authenticator.setDefault(new java.net.Authenticator() {
        private PasswordAuthentication authentication = new PasswordAuthentication(user, password.toCharArray());

        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return authentication;
        }
    });

    OkHttpClient client = new OkHttpClient.Builder().proxy(proxyTest).build();
    Request request = new Request.Builder().url("https://www.baidu.com").build();
    Response response = client.newCall(request).execute();
    System.out.println("状态码: " + response.code());
    System.out.println("响应内容: \n" + response.body().string());

    client.dispatcher().executorService().shutdown();
    client.connectionPool().evictAll();
}

private static PasswordAuthentication
privilegedRequestPasswordAuthentication(
                        final String host,
                        final InetAddress addr,
                        final int port,
                        final String protocol,
                        final String prompt,
                        final String scheme,
                        final URL url,
                        final RequestorType authType) {
    return java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<PasswordAuthentication>() {
            public PasswordAuthentication run() {
                if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
                    logger.finest("Requesting Authentication: host =" + host + " url = " + url);
                }
                PasswordAuthentication pass = Authenticator.requestPasswordAuthentication(
                    host, addr, port, protocol,
                    prompt, scheme, url, authType);
                if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
                    logger.finest("Authentication returned: " + (pass != null ? pass.toString() : "null"));
                }
                return pass;
            }
        });
}

private void getAnswer() {
    if (!answered) {
        answered = true;
        PasswordAuthentication passAuth =
                Authenticator.requestPasswordAuthentication(
                hci.host, hci.addr, hci.port, hci.protocol,
                hci.prompt, hci.scheme, hci.url, hci.authType);
        /**
         * To be compatible with existing callback handler implementations,
         * when the underlying Authenticator is canceled, username and
         * password are assigned null. No exception is thrown.
         */
        if (passAuth != null) {
            username = passAuth.getUserName();
            password = passAuth.getPassword();
        }
    }
}

private void init (PasswordAuthentication pw) {
    this.pw = pw;
    if (pw != null) {
        String s = pw.getUserName();
        int i = s.indexOf ('\\');
        if (i == -1) {
            username = s;
            ntdomain = defaultDomain;
        } else {
            ntdomain = s.substring (0, i).toUpperCase();
            username = s.substring (i+1);
        }
        password = new String (pw.getPassword());
    } else {
        /* credentials will be acquired from OS */
        username = null;
        ntdomain = null;
        password = null;
    }
    init0();
}

@Override public Credential authenticateProxy(
    Proxy proxy, URL url, List<Challenge> challenges) throws IOException {
  for (Challenge challenge : challenges) {
    if (!"Basic".equalsIgnoreCase(challenge.getScheme())) {
      continue;
    }

    InetSocketAddress proxyAddress = (InetSocketAddress) proxy.address();
    PasswordAuthentication auth = Authenticator.requestPasswordAuthentication(
        proxyAddress.getHostName(), getConnectToInetAddress(proxy, url), proxyAddress.getPort(),
        url.getProtocol(), challenge.getRealm(), challenge.getScheme(), url,
        Authenticator.RequestorType.PROXY);
    if (auth != null) {
      return Credential.basic(auth.getUserName(), new String(auth.getPassword()));
    }
  }
  return null;
}

public Request authenticateProxy(Proxy proxy, Response response) throws IOException {
    List<Challenge> challenges = response.challenges();
    Request request = response.request();
    HttpUrl url = request.httpUrl();
    int size = challenges.size();
    for (int i = 0; i < size; i++) {
        Challenge challenge = (Challenge) challenges.get(i);
        if ("Basic".equalsIgnoreCase(challenge.getScheme())) {
            InetSocketAddress proxyAddress = (InetSocketAddress) proxy.address();
            PasswordAuthentication auth = java.net.Authenticator
                    .requestPasswordAuthentication(proxyAddress.getHostName(),
                            getConnectToInetAddress(proxy, url), proxyAddress.getPort(), url
                                    .scheme(), challenge.getRealm(), challenge.getScheme(),
                            url.url(), RequestorType.PROXY);
            if (auth != null) {
                return request.newBuilder().header("Proxy-Authorization", Credentials.basic
                        (auth.getUserName(), new String(auth.getPassword()))).build();
            }
        }
    }
    return null;
}

@Override public Credential authenticate(
    Proxy proxy, URL url, List<Challenge> challenges) throws IOException {
  for (Challenge challenge : challenges) {
    if (!"Basic".equalsIgnoreCase(challenge.getScheme())) {
      continue;
    }

    PasswordAuthentication auth = Authenticator.requestPasswordAuthentication(url.getHost(),
        getConnectToInetAddress(proxy, url), url.getPort(), url.getProtocol(),
        challenge.getRealm(), challenge.getScheme(), url, Authenticator.RequestorType.SERVER);
    if (auth != null) {
      return Credential.basic(auth.getUserName(), new String(auth.getPassword()));
    }
  }
  return null;
}

@Override public Credential authenticateProxy(
    Proxy proxy, URL url, List<Challenge> challenges) throws IOException {
  for (Challenge challenge : challenges) {
    if (!"Basic".equalsIgnoreCase(challenge.getScheme())) {
      continue;
    }

    InetSocketAddress proxyAddress = (InetSocketAddress) proxy.address();
    PasswordAuthentication auth = Authenticator.requestPasswordAuthentication(
        proxyAddress.getHostName(), getConnectToInetAddress(proxy, url), proxyAddress.getPort(),
        url.getProtocol(), challenge.getRealm(), challenge.getScheme(), url,
        Authenticator.RequestorType.PROXY);
    if (auth != null) {
      return Credential.basic(auth.getUserName(), new String(auth.getPassword()));
    }
  }
  return null;
}

@Override protected PasswordAuthentication getPasswordAuthentication() {
  this.calls.add("host=" + getRequestingHost()
      + " port=" + getRequestingPort()
      + " site=" + getRequestingSite().getHostName()
      + " url=" + getRequestingURL()
      + " type=" + getRequestorType()
      + " prompt=" + getRequestingPrompt()
      + " protocol=" + getRequestingProtocol()
      + " scheme=" + getRequestingScheme());
  return authentication;
}

@Override public Request authenticate(Route route, Response response) throws IOException {
  List<Challenge> challenges = response.challenges();
  Request request = response.request();
  HttpUrl url = request.url();
  boolean proxyAuthorization = response.code() == 407;
  Proxy proxy = route.proxy();

  for (int i = 0, size = challenges.size(); i < size; i++) {
    Challenge challenge = challenges.get(i);
    if (!"Basic".equalsIgnoreCase(challenge.scheme())) continue;

    PasswordAuthentication auth;
    if (proxyAuthorization) {
      InetSocketAddress proxyAddress = (InetSocketAddress) proxy.address();
      auth = java.net.Authenticator.requestPasswordAuthentication(
          proxyAddress.getHostName(), getConnectToInetAddress(proxy, url), proxyAddress.getPort(),
          url.scheme(), challenge.realm(), challenge.scheme(), url.url(),
          RequestorType.PROXY);
    } else {
      auth = java.net.Authenticator.requestPasswordAuthentication(
          url.host(), getConnectToInetAddress(proxy, url), url.port(), url.scheme(),
          challenge.realm(), challenge.scheme(), url.url(), RequestorType.SERVER);
    }

    if (auth != null) {
      String credential = Credentials.basic(auth.getUserName(), new String(auth.getPassword()));
      return request.newBuilder()
          .header(proxyAuthorization ? "Proxy-Authorization" : "Authorization", credential)
          .build();
    }
  }

  return null; // No challenges were satisfied!
}

static BadAuthProxyServer startServer() throws IOException {
    Authenticator.setDefault(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("xyz", "xyz".toCharArray());
        }
        });

    BadAuthProxyServer server = new BadAuthProxyServer(new ServerSocket(0));
    Thread serverThread = new Thread(server);
    serverThread.start();
    return server;
}

@Override protected PasswordAuthentication getPasswordAuthentication() {
  this.calls.add("host=" + getRequestingHost()
      + " port=" + getRequestingPort()
      + " site=" + getRequestingSite().getHostName()
      + " url=" + getRequestingURL()
      + " type=" + getRequestorType()
      + " prompt=" + getRequestingPrompt()
      + " protocol=" + getRequestingProtocol()
      + " scheme=" + getRequestingScheme());
  return authentication;
}

/**
 * Loads the NTLM authentiation implementation through reflection. If
 * the class is present, then it must have the required constructors and
 * method. Otherwise, it is considered an error.
 */
@SuppressWarnings("unchecked")
private static NTLMAuthenticationProxy tryLoadNTLMAuthentication() {
    Class<? extends AuthenticationInfo> cl;
    Constructor<? extends AuthenticationInfo> fourArg, sixArg;
    try {
        cl = (Class<? extends AuthenticationInfo>)Class.forName(clazzStr, true, null);
        if (cl != null) {
            fourArg = cl.getConstructor(boolean.class,
                                         URL.class,
                                         PasswordAuthentication.class,
                                         String.class);
            sixArg = cl.getConstructor(boolean.class,
                                        String.class,
                                        int.class,
                                        PasswordAuthentication.class,
                                        String.class);
            supportsTA = cl.getDeclaredMethod(supportsTAStr);
            isTrustedSite = cl.getDeclaredMethod(isTrustedSiteStr, java.net.URL.class);
            return new NTLMAuthenticationProxy(fourArg,
                                               sixArg);
        }
    } catch (ClassNotFoundException cnfe) {
        finest(cnfe);
    } catch (ReflectiveOperationException roe) {
        throw new AssertionError(roe);
    }

    return null;
}

@Override public Request authenticate(Route route, Response response) throws IOException {
  List<Challenge> challenges = response.challenges();
  Request request = response.request();
  HttpUrl url = request.url();
  boolean proxyAuthorization = response.code() == 407;
  Proxy proxy = route.proxy();

  for (int i = 0, size = challenges.size(); i < size; i++) {
    Challenge challenge = challenges.get(i);
    if (!"Basic".equalsIgnoreCase(challenge.scheme())) continue;

    PasswordAuthentication auth;
    if (proxyAuthorization) {
      InetSocketAddress proxyAddress = (InetSocketAddress) proxy.address();
      auth = java.net.Authenticator.requestPasswordAuthentication(
          proxyAddress.getHostName(), getConnectToInetAddress(proxy, url), proxyAddress.getPort(),
          url.scheme(), challenge.realm(), challenge.scheme(), url.url(),
          RequestorType.PROXY);
    } else {
      auth = java.net.Authenticator.requestPasswordAuthentication(
          url.host(), getConnectToInetAddress(proxy, url), url.port(), url.scheme(),
          challenge.realm(), challenge.scheme(), url.url(), RequestorType.SERVER);
    }

    if (auth != null) {
      String credential = Credentials.basic(
          auth.getUserName(), new String(auth.getPassword()), challenge.charset());
      return request.newBuilder()
          .header(proxyAuthorization ? "Proxy-Authorization" : "Authorization", credential)
          .build();
    }
  }

  return null; // No challenges were satisfied!
}

public static PasswordAuthentication
getPasswordAuthentication(
    String      realm,
    URL         tracker )
{
    return( SESecurityManagerImpl.getSingleton().getPasswordAuthentication(realm, tracker));
}

synchronized void store(String authscheme,
                        URI domain,
                        boolean proxy,
                        PasswordAuthentication value) {
    remove(authscheme, domain, proxy);
    entries.add(new CacheEntry(authscheme, domain, proxy, value));
}

/**
 * @param url
 * @param forceLogin
 * @return 
 * @see TeamAccessor#getPasswordAuthentication(java.lang.String, boolean)
 */
public static PasswordAuthentication getPasswordAuthentication(String url, boolean forceLogin) {
    for (TeamAccessor ka : getTeamAccessors()) {
        PasswordAuthentication pa = ka.getPasswordAuthentication(url, forceLogin);
        if (pa != null) {
            return pa;
        }
    }
    return null;
}

/**
 * Create a NTLMAuthentication:
 * Username may be specified as domain<BACKSLASH>username in the application Authenticator.
 * If this notation is not used, then the domain will be taken
 * from a system property: "http.auth.ntlm.domain".
 */
public NTLMAuthentication(boolean isProxy, URL url, PasswordAuthentication pw) {
    super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,
          AuthScheme.NTLM,
          url,
          "");
    init (pw);
}

@Override
protected void populateCredentials(PasswordAuthentication pa) {
    settingsPanel.userTextField.setText(pa.getUserName());
    settingsPanel.userPasswordField.setText(new String(pa.getPassword()));
    settingsPanel.savePasswordCheckBox.setSelected(true);
    settingsPanel.savePasswordCheckBox.setEnabled(false);
}

public RepositoryStep (CloneWizard wiz, PasswordAuthentication pa, String forPath) {
    this.wiz = wiz;
    repository = new RemoteRepository(pa, forPath);
    repository.addChangeListener(this);
    panel = new RepositoryStepPanel(repository.getPanel());
    panel.txtDestination.getDocument().addDocumentListener(this);
    validateRepository();
}

public SvnClient getClient(SVNUrl repositoryUrl, SvnProgressSupport progressSupport) throws SVNClientException {
    Parameters.notNull("repositoryUrl", repositoryUrl); //NOI18N
    String username = ""; // NOI18N
    char[] password = null;

    SvnKenaiAccessor kenaiSupport = SvnKenaiAccessor.getInstance();
    if(kenaiSupport.isKenai(repositoryUrl.toString())) {
        PasswordAuthentication pa = kenaiSupport.getPasswordAuthentication(repositoryUrl.toString(), false);
        if(pa != null) {
            username = pa.getUserName();
            password = pa.getPassword();
        }
    } else {
        RepositoryConnection rc = SvnModuleConfig.getDefault().getRepositoryConnection(repositoryUrl.toString());
        if(rc != null) {
            username = rc.getUsername();
            password = rc.getPassword();
        } else if(!Utilities.isWindows()) {
            PasswordFile pf = PasswordFile.findFileForUrl(repositoryUrl);
            if(pf != null) {
                username = pf.getUsername();
                String psswdString = pf.getPassword();
                password = psswdString != null ? psswdString.toCharArray() : null;
            }
        }
    }
    return getClient(repositoryUrl, username, password, progressSupport);
}

private void getKenaiAuthData(SvnKenaiAccessor support) {
    final String urlString = url.toString();

    PasswordAuthentication pa = support.getPasswordAuthentication(urlString, true);
    if(pa == null) {
        throw new RuntimeException(new InterruptedException(org.openide.util.NbBundle.getMessage(SvnClientExceptionHandler.class, "MSG_ActionCanceledByUser"))); //NOI18N
    }
    String user = pa.getUserName();
    char[] psswd = pa.getPassword();

    username = user != null ? user : "";
    password = psswd;
}

@Override
protected PasswordAuthentication getPasswordAuthentication() {
    //If user sets proxy user and passwd and the RequestType is from proxy server then create
    // PasswordAuthentication using proxyUser and proxyPasswd;
    if ((getRequestorType() == RequestorType.PROXY) && proxyUser != null && proxyPasswd != null) {
        return new PasswordAuthentication(proxyUser, proxyPasswd.toCharArray());
    }
    for (AuthInfo auth : authInfo) {
        if (auth.matchingHost(getRequestingURL())) {
            return new PasswordAuthentication(auth.getUser(), auth.getPassword().toCharArray());
        }
    }
    return null;
}

@Override
protected PasswordAuthentication getPasswordAuthentication() {
    Logger.getLogger(NbAuthenticator.class.getName()).log(Level.FINER, "Authenticator.getPasswordAuthentication() with prompt " + this.getRequestingPrompt()); //NOI18N

    if (RequestorType.PROXY == getRequestorType() && ProxySettings.useAuthentication()) {
        Logger.getLogger(NbAuthenticator.class.getName()).log(Level.FINER, "Username set to " + ProxySettings.getAuthenticationUsername() + " while request " + this.getRequestingURL()); //NOI18N
        return new java.net.PasswordAuthentication(ProxySettings.getAuthenticationUsername(), ProxySettings.getAuthenticationPassword());
    } else {
        if (System.currentTimeMillis() - lastTry > TIMEOUT) {
            if (getRequestingProtocol().startsWith("SOCKS")&&(ProxySettings.getAuthenticationUsername().length()>0)) { //NOI18N
                return new java.net.PasswordAuthentication(ProxySettings.getAuthenticationUsername(), ProxySettings.getAuthenticationPassword());
            }
            if (NetworkSettings.isAuthenticationDialogSuppressed()) {
                return null;
            }
            PasswordAuthentication auth = getAuthenticationFromURL();
            if (auth != null) {
                return auth;
            }
            NbAuthenticatorPanel ui = new NbAuthenticatorPanel(getRequestingPrompt());
            Object result = DialogDisplayer.getDefault().notify(
                    new DialogDescriptor(ui, NbBundle.getMessage(NbAuthenticator.class, "CTL_Authentication"))); //NOI18N
            if (DialogDescriptor.OK_OPTION == result) {
                lastTry = 0;
                return new PasswordAuthentication(ui.getUserName(), ui.getPassword());
            } else {
                lastTry = System.currentTimeMillis();
            }
        }
    }

    Logger.getLogger(NbAuthenticator.class.getName()).log(Level.WARNING, "No authentication set while requesting " + this.getRequestingURL()); //NOI18N
    return null;
}

static BadAuthProxyServer startServer() throws IOException {
    Authenticator.setDefault(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("xyz", "xyz".toCharArray());
        }
        });

    BadAuthProxyServer server = new BadAuthProxyServer(new ServerSocket(0));
    Thread serverThread = new Thread(server);
    serverThread.start();
    return server;
}

/**
 * Loads the NTLM authentiation implementation through reflection. If
 * the class is present, then it must have the required constructors and
 * method. Otherwise, it is considered an error.
 */
@SuppressWarnings("unchecked")
private static NTLMAuthenticationProxy tryLoadNTLMAuthentication() {
    Class<? extends AuthenticationInfo> cl;
    Constructor<? extends AuthenticationInfo> threeArg, fiveArg;
    try {
        cl = (Class<? extends AuthenticationInfo>)Class.forName(clazzStr, true, null);
        if (cl != null) {
            threeArg = cl.getConstructor(boolean.class,
                                         URL.class,
                                         PasswordAuthentication.class);
            fiveArg = cl.getConstructor(boolean.class,
                                        String.class,
                                        int.class,
                                        PasswordAuthentication.class);
            supportsTA = cl.getDeclaredMethod(supportsTAStr);
            isTrustedSite = cl.getDeclaredMethod(isTrustedSiteStr, java.net.URL.class);
            return new NTLMAuthenticationProxy(threeArg,
                                               fiveArg);
        }
    } catch (ClassNotFoundException cnfe) {
        finest(cnfe);
    } catch (ReflectiveOperationException roe) {
        throw new AssertionError(roe);
    }

    return null;
}

public void bad7() throws Exception {
    byte[] bytes = new byte[2];
    char[] pwd = "secret7".toCharArray();
    new PBEKeySpec(pwd);
    new PBEKeySpec(pwd, bytes, 1);
    new PBEKeySpec(pwd, bytes, 1, 1);
    PasswordAuthentication auth = new PasswordAuthentication("user", pwd);
    PasswordCallback callback = new PasswordCallback("str", true);
    callback.setPassword(pwd);
    KeyStore.PasswordProtection protection = new KeyStore.PasswordProtection(pwd);
    KerberosKey key = new KerberosKey(null, pwd, "alg");
    KeyManagerFactory.getInstance("").init(null, pwd);
}

public DigestAuthentication(boolean isProxy, String host, int port, String realm,
                            String authMethod, PasswordAuthentication pw,
                            Parameters params, String authenticatorKey) {
    super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,
          AuthScheme.DIGEST,
          host,
          port,
          realm,
          Objects.requireNonNull(authenticatorKey));
    this.authMethod = authMethod;
    this.pw = pw;
    this.params = params;
}

private static PasswordAuthentication handleAuthenticationError(List<String> cmdOutput, File repository, String url, String userName, UserCredentialsSupport credentialsSupport, String hgCommand, boolean showLoginDialog) throws HgException {
    PasswordAuthentication credentials = null;
    String msg = cmdOutput.get(cmdOutput.size() - 1).toLowerCase();
    if (isAuthMsg(msg) && showLoginDialog) {
        HgKenaiAccessor support = HgKenaiAccessor.getInstance();
        if(support.isKenai(url)) {
            checkKenaiPermissions(hgCommand, url, support);
            // try to login
            credentials = handleKenaiAuthorisation(support, url);
        } else {
            credentials = credentialsSupport.getUsernamePasswordCredentials(repository, url, userName);
        }
    }
    return credentials;
}

/**
 * Create a BasicAuthentication
 */
public BasicAuthentication(boolean isProxy, String host, int port,
                           String realm, PasswordAuthentication pw) {
    super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,
          AuthScheme.BASIC, host, port, realm);
    String plain = pw.getUserName() + ":";
    byte[] nameBytes = null;
    try {
        nameBytes = plain.getBytes("ISO-8859-1");
    } catch (java.io.UnsupportedEncodingException uee) {
        assert false;
    }

    // get password bytes
    char[] passwd = pw.getPassword();
    byte[] passwdBytes = new byte[passwd.length];
    for (int i=0; i<passwd.length; i++)
        passwdBytes[i] = (byte)passwd[i];

    // concatenate user name and password bytes and encode them
    byte[] concat = new byte[nameBytes.length + passwdBytes.length];
    System.arraycopy(nameBytes, 0, concat, 0, nameBytes.length);
    System.arraycopy(passwdBytes, 0, concat, nameBytes.length,
                     passwdBytes.length);
    this.auth = "Basic " + Base64.getEncoder().encodeToString(concat);
    this.pw = pw;
}

@Override
public PasswordAuthentication getAuthentication(URL url) throws PasswordInputCanceledException {
    if (url.getProtocol().equals(protocol)) {
        String username = ParameterService.getParameterValue(protocol + ".proxyUsername");
        String password = ParameterService.getParameterValue(protocol + ".proxyPassword");
        // password is stored encrypted, try to decrypt password
        if (password != null && CipherTools.isKeyAvailable()) {
            try {
                password = CipherTools.decrypt(password);
            } catch (CipherException e) {
                // password is in plaintext
            }
        }
        if (username == null || username.isEmpty() || password == null) {  // empty
            // passwords
            // possibly
            // valid!
            PasswordAuthentication passwordAuthentication = PasswordDialog.getPasswordAuthentication("proxy for "
                    + url.toString(), true, false);
            if (passwordAuthentication == null) {
                return null;
            }
            ParameterService.setParameterValue(protocol + ".proxyUsername", passwordAuthentication.getUserName());
            ParameterService.setParameterValue(protocol + ".proxyPassword",
                    new String(passwordAuthentication.getPassword()));
            ParameterService.saveParameters();

            return passwordAuthentication;
        }
        return new PasswordAuthentication(username, password.toCharArray());
    }
    return null;
}

public static void main(String[] args) throws Exception {
    try {
        Class<?> ntlmProxyClass = Class.forName("sun.net.www.protocol.http.NTLMAuthenticationProxy", true, NoNTLM.class.getClassLoader());
        Field ntlmSupportedField = ntlmProxyClass.getDeclaredField("supported");
        ntlmSupportedField.setAccessible(true);
        if (ntlmSupportedField.getBoolean(null)) {
            System.out.println("NTLM is supported. Nothing to do. Exiting.");
            return;
        }
    } catch (ClassNotFoundException okay) { }

    // setup Authenticator
    Authenticator.setDefault(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("user", "pass".toCharArray());
        }
    });

    // test combinations of authentication schemes
    test("Basic");
    test("Digest");
    test("Basic", "Digest");
    test("Basic", "NTLM");
    test("Digest", "NTLM");
    test("Basic", "Digest", "NTLM");

    // test NTLM only, this should fail with "401 Unauthorized"
    testNTLM();

    System.out.println();
    System.out.println("TEST PASSED");
}