@Override public void handle(Callback[] callbacks) throws UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nc = (NameCallback) callback; nc.setName(nc.getDefaultName()); } else if (callback instanceof PasswordCallback) { String errorMessage = "Could not login: the client is being asked for a password, but the Kafka" + " client code does not currently support obtaining a password from the user."; throw new UnsupportedCallbackException(callback, errorMessage); } else if (callback instanceof RealmCallback) { RealmCallback rc = (RealmCallback) callback; rc.setText(rc.getDefaultText()); } else { throw new UnsupportedCallbackException(callback, "Unrecognized SASL Login callback"); } } }
Callback[] callbacks = new Callback[2]; callbacks[0] = new NameCallback("Username: "); callbacks[1] = new PasswordCallback("Password: ", false); try { callbackHandler.handle(callbacks); } catch (IOException ioe) { throw new LoginException(ioe.getMessage()); } catch (UnsupportedCallbackException uce) { throw new LoginException(uce.getMessage() + " not available to obtain information from user"); user = ((NameCallback) callbacks[0]).getName(); char[] tmpPassword = ((PasswordCallback) callbacks[1]).getPassword(); if (tmpPassword == null) { tmpPassword = new char[0];
private byte[] getSaltedPasswordFromPasswordCallback() throws AuthenticationMechanismException { PasswordCallback passwordCallback = new PasswordCallback("User password: ", false); if (e.getCallback() == realmChoiceCallBack) { realmChoiceCallBack = null; } else if (e.getCallback() == nameCallback) { throw log.mechCallbackHandlerDoesNotSupportUserName(e); } else if (e.getCallback() == passwordCallback) { throw log.mechCallbackHandlerDoesNotSupportCredentialAcquisition(e); } else { callbackHandler.handle(new Callback[]{ realmCallback, nameCallback, passwordCallback }); if (realmCallback.getText() != null) realm = realmCallback.getText(); } catch (UnsupportedCallbackException e) { if (e.getCallback() == realmCallback) { realmCallback = null; } else if (e.getCallback() == nameCallback) { throw log.mechCallbackHandlerDoesNotSupportUserName(e); } else if (e.getCallback() == passwordCallback) { throw log.mechCallbackHandlerDoesNotSupportCredentialAcquisition(e); } else { callbackHandler.handle(new Callback[]{ nameCallback, passwordCallback }); } catch (UnsupportedCallbackException e) { if (e.getCallback() == nameCallback) { throw log.mechCallbackHandlerDoesNotSupportUserName(e); } else if (e.getCallback() == passwordCallback) { throw log.mechCallbackHandlerDoesNotSupportCredentialAcquisition(e); } else {
final NameCallback nameCallback = new NameCallback(getRequestingPrompt()); final CredentialCallback credentialCallback = new CredentialCallback(PasswordCredential.class); callbackHandler.handle(new Callback[] { nameCallback, credentialCallback }); final TwoWayPassword twoWayPassword = credentialCallback.applyToCredential(PasswordCredential.class, c -> c.getPassword().castAs(TwoWayPassword.class)); if (twoWayPassword == null) { password = factory.getKeySpec(factory.translate(twoWayPassword), ClearPasswordSpec.class).getEncodedPassword(); } catch (UnsupportedCallbackException e) { if (e.getCallback() == credentialCallback) { final PasswordCallback passwordCallback = new PasswordCallback("Password", false); try { callbackHandler.handle(new Callback[] { nameCallback, passwordCallback }); password = passwordCallback.getPassword(); } catch (IOException | UnsupportedCallbackException e1) { log.trace("Error handling callback:", e1); return null; final String name = nameCallback.getName(); if (name == null || password == null) return null; return new PasswordAuthentication(name, password);
@Override public void handle( Callback[] callbacks ) throws IOException, UnsupportedCallbackException { for ( Callback callback : callbacks ) { if ( callback instanceof NameCallback ) { ( (NameCallback) callback ).setName( principal ); } else if ( callback instanceof PasswordCallback ) { ( (PasswordCallback) callback ).setPassword( password.toCharArray() ); } else { throw new UnsupportedCallbackException( callback ); } } } }, new PentahoLoginConfiguration( appConfigurationEntries ) );
if (callback instanceof NameCallback) { final NameCallback nameCallback = (NameCallback) callback; final String defaultName = nameCallback.getDefaultName(); log.tracef("User name requested; prompt '%s', default is '%s', ours is '%s'", nameCallback.getPrompt(), defaultName, actualUserName); if (actualUserName == null) { if (defaultName != null) { nameCallback.setName(defaultName); final String defaultRealm = realmCallback.getDefaultText(); log.tracef("Realm requested; prompt '%s', default is '%s', ours is '%s'", realmCallback.getPrompt(), defaultRealm, actualUserRealm); if (actualUserRealm == null) { if (defaultRealm != null) { realmCallback.setText(defaultRealm); throw new UnsupportedCallbackException(callback, "No realm choices match realm '" + actualUserRealm + "'"); } else if (callback instanceof TextOutputCallback) { final TextOutputCallback textOutputCallback = (TextOutputCallback) callback; } else if (callback instanceof PasswordCallback) { final PasswordCallback passwordCallback = (PasswordCallback) callback; passwordCallback.setPassword(password); } else { throw new UnsupportedCallbackException(callback);
((RealmCallback) callback).setText( XMPPServer.getInstance().getServerInfo().getXMPPDomain() ); name = ((NameCallback) callback).getName(); if (name == null) { name = ((NameCallback) callback).getDefaultName(); .setPassword(AuthFactory.getPassword(name).toCharArray()); throw new UnsupportedCallbackException(callback, "Unrecognized Callback");
@Override protected void handleInternal(Callback callback) throws IOException, UnsupportedCallbackException { boolean allUnsupported = true; for (CallbackHandler callbackHandler : callbackHandlers) { try { callbackHandler.handle(new Callback[]{callback}); allUnsupported = false; } catch (UnsupportedCallbackException ex) { // if an UnsupportedCallbackException occurs, go to the next handler } } if (allUnsupported) { throw new UnsupportedCallbackException(callback); } } }
@Override public void handle(Callback[] callbacks) throws UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof RealmCallback) handleRealmCallback((RealmCallback) callback); else if (callback instanceof AuthorizeCallback && mechanism.equals(SaslConfigs.GSSAPI_MECHANISM)) handleAuthorizeCallback((AuthorizeCallback) callback); else throw new UnsupportedCallbackException(callback); } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { String username = null; String password = null; AuthorizeCallback ac = null; for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nc = (NameCallback) callback; username = nc.getName(); } else if (callback instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callback; password = new String(pc.getPassword()); } else if (callback instanceof AuthorizeCallback) { ac = (AuthorizeCallback) callback; } else { throw new UnsupportedCallbackException(callback); } } PasswdAuthenticationProvider provider = AuthenticationProviderFactory.getAuthenticationProvider(authMethod); provider.Authenticate(username, password); if (ac != null) { ac.setAuthorized(true); } } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof NameCallback) { NameCallback nameCallback = (NameCallback) callback; nameCallback.setName(mUserName); } else { Class<?> callbackClass = (callback == null) ? null : callback.getClass(); throw new UnsupportedCallbackException(callback, callbackClass + " is unsupported."); } } } }
throw new LoginException("Error: no CallbackHandler available for collecting authentication information."); NameCallback nc = new NameCallback("DN"); ObjectCallback oc = new ObjectCallback("Certificate"); Callback[] callbacks = new Callback[] {nc, oc}; callbackHandler.handle(callbacks); Principal loginPrincipal = new SimplePrincipal(nc.getName()); Object credential = oc.getCredential(); X509Certificate loginCredential; } else { String clazz = (credential == null) ? "null" : credential.getClass().getName(); throw new LoginException("Supplied credential is a " + clazz + " but needs to be an " + X509Certificate.class.getName()); LoginException le = new LoginException(e.toString()); le.initCause(e); throw le; } catch (UnsupportedCallbackException e) { LoginException le = new LoginException("Error: " + e.getCallback() + ", not available to use this callback."); le.initCause(e); throw le;
throw new LoginException("Error: no CallbackHandler available " + "to garner authentication information from the user"); callbacks[0] = new NameCallback("user name: "); callbacks[1] = new PasswordCallback("password: ", false); callbacks[2] = new PasswordCallback("new password 1: ", false); callbacks[3] = new PasswordCallback("new password 2: ", false); callbackHandler.handle(callbacks); } catch (final java.io.IOException ioe) { throw new LoginException(ioe.toString()); } catch (final UnsupportedCallbackException uce) { throw new LoginException("Error: " + uce.getCallback().toString() + " not available to garner authentication information " + "from the user");
PasswordCallback pwdcb = new PasswordCallback(GT.tr("Enter SSL password: "), false); try { cbh.handle(new Callback[]{pwdcb}); } catch (UnsupportedCallbackException ucex) { if ((cbh instanceof LibPQFactory.ConsoleCallbackHandler) && ("Console is not available".equals(ucex.getMessage()))) { error = new PSQLException(GT .tr("Could not read password for SSL key file, console is not available."), PBEKeySpec pbeKeySpec = new PBEKeySpec(pwdcb.getPassword()); pwdcb.clearPassword();
/** * Overriding to allow for certificate-based login. Standard JAAS. */ @Override public boolean login() throws LoginException { Callback[] callbacks = new Callback[1]; callbacks[0] = new CertificateCallback(); try { callbackHandler.handle(callbacks); } catch (IOException ioe) { throw new LoginException(ioe.getMessage()); } catch (UnsupportedCallbackException uce) { throw new LoginException(uce.getMessage() + " Unable to obtain client certificates."); } X509Certificate[] certificates = ((CertificateCallback)callbacks[0]).getCertificates(); username = getUserNameForCertificates(certificates); if (username == null) { throw new FailedLoginException("No user for client certificate: " + getDistinguishedName(certificates)); } if (debug) { LOG.debug("Certificate for user: " + username); } succeeded = true; return true; }
private byte[] getPredigestedSaltedPassword() throws AuthenticationMechanismException { if (realmChoiceCallBack != null) { try { callbackHandler.handle(new Callback[]{ realmChoiceCallBack }); int[] selected = realmChoiceCallBack.getSelectedIndexes(); if (selected == null || selected.length == 0) { callbackHandler.handle(new Callback[]{ realmCallback }); if (realmCallback.getText() != null) realm = realmCallback.getText(); } catch (UnsupportedCallbackException e) { realmCallback = null; callbackHandler.handle(new Callback[]{ nameCallback }); if ( ! readOnlyRealmUsername) { username = nameCallback.getName(); if (username == null) { throw log.mechNotProvidedUserName(); ); } catch (UnsupportedCallbackException e) { if (e.getCallback() == nameCallback) { throw log.mechCallbackHandlerDoesNotSupportUserName(e); } else if (credentialCallback == null || e.getCallback() != credentialCallback) { throw log.mechCallbackHandlerFailedForUnknownReason(e);
public void handle(final Callback[] callbacks) throws IOException, UnsupportedCallbackException { SSLConnection sslConnection; if (! once.compareAndSet(true, false) || (sslConnection = sslConnectionSupplier.get()) == null) { delegate.handle(callbacks); return; } final int length = callbacks.length; final Callback[] newCallbacks = new Callback[length + 1]; newCallbacks[0] = new SSLCallback(sslConnection); System.arraycopy(callbacks, 0, newCallbacks, 1, length); try { delegate.handle(newCallbacks); } catch (UnsupportedCallbackException e) { if (e.getCallback() instanceof SSLCallback) { delegate.handle(callbacks); return; } throw e; } }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { String username = null; for (Callback callback: callbacks) { if (callback instanceof NameCallback) username = ((NameCallback) callback).getDefaultName(); else if (callback instanceof PlainAuthenticateCallback) { PlainAuthenticateCallback plainCallback = (PlainAuthenticateCallback) callback; boolean authenticated = authenticate(username, plainCallback.password()); plainCallback.authenticated(authenticated); } else throw new UnsupportedCallbackException(callback); } }
if (e.getCallback() != credentialCallback) { throw log.mechCallbackHandlerFailedForUnknownReason(e); if (e.getCallback() != credentialCallback) { throw log.mechCallbackHandlerFailedForUnknownReason(e); final PasswordCallback passwordCallback = new PasswordCallback("User password", false); final char[] password = passwordCallback.getPassword(); if (password != null) { if (matchParameters != null) { if (e.getCallback() != passwordCallback) { throw log.mechCallbackHandlerFailedForUnknownReason(e);
/** * Get the message for this exception, formatted with the callback. * * @return the message for this exception, with the callback (not {@code null}) */ public String getMessage() { final String message = super.getMessage(); return message != null ? String.format("%s: %s", getCallback(), message) : String.valueOf(getCallback()); } }