if (c instanceof NameCallback) { NameCallback nc = (NameCallback) c; nc.setName(username); } else if (c instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) c; if (password != null) { pc.setPassword(password.toCharArray()); String authid = ac.getAuthenticationID(); String authzid = ac.getAuthorizationID(); if (authid.equals(authzid)) { ac.setAuthorized(true); } else { ac.setAuthorized(false); ((RealmCallback) c).setText(rc.getDefaultText()); } else { throw new UnsupportedCallbackException(c);
@Override public boolean login() throws LoginException { Callback[] callbacks = new Callback[2]; callbacks[0] = new NameCallback("User name"); callbacks[1] = new PasswordCallback("Password", false); try { handler.handle(callbacks); } catch (IOException ioe) { throw (LoginException)new LoginException().initCause(ioe); } catch (UnsupportedCallbackException uce) { throw (LoginException)new LoginException().initCause(uce); } String password; String username = ((NameCallback)callbacks[0]).getName(); if (username == null) return false; if (((PasswordCallback)callbacks[1]).getPassword() != null) password = new String(((PasswordCallback)callbacks[1]).getPassword()); else password=""; // authenticate will throw LoginException // in case of failed authentication authenticate(username, password); user = new UserPrincipal(username); succeeded = true; return true; }
@Override public boolean login() throws LoginException { succeeded = true; if (credentialsInvalidate) { PasswordCallback passwordCallback = new PasswordCallback("Password: ", false); try { callbackHandler.handle(new Callback[]{passwordCallback}); if (passwordCallback.getPassword() != null) { if (debug) { LOG.debug("Guest login failing (credentialsInvalidate=true) on presence of a password"); } succeeded = false; passwordCallback.clearPassword(); }; } catch (IOException ioe) { } catch (UnsupportedCallbackException uce) { } } if (debug) { LOG.debug("Guest login " + succeeded); } return succeeded; }
NameCallback nc = new NameCallback("SASL PLAIN"); nc.setName(parts[1]); PasswordCallback pc = new PasswordCallback("SASL PLAIN", false); pc.setPassword(parts[2].toCharArray()); AuthorizeCallback ac = new AuthorizeCallback(parts[1], parts[0]); cbh.handle(new Callback[]{ nc, pc, ac }); if (ac.isAuthorized()) { authz = ac.getAuthorizedID();
@Override public void handle(Callback[] callbacks) { for (Callback cb : callbacks) { if (cb instanceof NameCallback) { ((NameCallback)cb).setName(clientId); } else if (cb instanceof PasswordCallback) { ((PasswordCallback)cb).setPassword(secret.toCharArray()); } else if (cb instanceof RealmCallback) { RealmCallback rb = (RealmCallback) cb; rb.setText(rb.getDefaultText()); } } }
@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 ) );
/** * Tests that the authentication callbacks matches. */ @Test public void authenticateNameMatch() throws Exception { String authenticateId = "alluxio-1"; NameCallback ncb = new NameCallback(" authentication id: "); ncb.setName(authenticateId); PasswordCallback pcb = new PasswordCallback(" password: ", false); pcb.setPassword("password".toCharArray()); Callback[] callbacks = new Callback[] {ncb, pcb, new AuthorizeCallback(authenticateId, authenticateId)}; mPlainServerCBHandler.handle(callbacks); }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback c : callbacks) { if (c instanceof NameCallback) { ((NameCallback) c).setName(PRINCIPAL); } else if (c instanceof PasswordCallback) { ((PasswordCallback) c).setPassword("wrong".toCharArray()); } else if (c instanceof AuthorizeCallback) { ((AuthorizeCallback) c).setAuthorized(true); } else if (c instanceof RealmCallback) { ((RealmCallback) c).setText(REALM); } else { throw new UnsupportedCallbackException(c); } } } }
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()); String principal = authCallback.getAuthenticationID(); String username = authCallback.getAuthorizationID(); authCallback.setAuthorized(true); authCallback.setAuthorizedID(username); throw new UnsupportedCallbackException(callback, "Unrecognized Callback");
/** * Tests that the callback is handled correctly. */ @Test public void clientCallbackHandler() throws Exception { Callback[] callbacks = new Callback[2]; callbacks[0] = new NameCallback("Username:"); callbacks[1] = new PasswordCallback("Password:", true); String user = "alluxio-user-1"; String password = "alluxio-user-1-password"; CallbackHandler clientCBHandler = new PlainSaslClientCallbackHandler(user, password); clientCBHandler.handle(callbacks); validateCallbacks(user, password, callbacks); }
@Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof PasswordCallback) { ((PasswordCallback) callback).setPassword(password); } else if (callback instanceof RealmCallback) { ((RealmCallback) callback).setText(realm); } else if (callback instanceof NameCallback) { ((NameCallback) callback).setName(name); } } }
@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); } } }
private byte[] getSaltedPasswordFromPasswordCallback() throws AuthenticationMechanismException { PasswordCallback passwordCallback = new PasswordCallback("User password: ", false); callbackHandler.handle(new Callback[]{ realmChoiceCallBack, nameCallback, passwordCallback }); int[] selected = realmChoiceCallBack.getSelectedIndexes(); if (selected == null || selected.length == 0) { callbackHandler.handle(new Callback[]{ realmCallback, nameCallback, passwordCallback }); if (realmCallback.getText() != null) realm = realmCallback.getText(); } catch (UnsupportedCallbackException e) { if (e.getCallback() == realmCallback) { callbackHandler.handle(new Callback[]{ nameCallback, passwordCallback }); } catch (UnsupportedCallbackException e) { if (e.getCallback() == nameCallback) { char[] passwordChars = passwordCallback.getPassword(); passwordCallback.clearPassword(); if ( ! readOnlyRealmUsername) { username = nameCallback.getName(); if (username == null) { throw log.mechNotProvidedUserName();
@Override public void handle(Callback[] callbacks) { if (!configured) throw new IllegalStateException("Login callback handler not configured"); for (Callback callback : callbacks) { if (callback instanceof NameCallback) ((NameCallback) callback).setName(TestJaasConfig.USERNAME); else if (callback instanceof PasswordCallback) ((PasswordCallback) callback).setPassword(TestJaasConfig.PASSWORD.toCharArray()); } }
private static void log(String type, AuthorizeCallback ac, NameCallback nc, PasswordCallback pc, RealmCallback rc) { if (LOG.isDebugEnabled()) { String acs = "null"; if (ac != null) { acs = "athz: " + ac.getAuthorizationID() + " athn: " + ac.getAuthenticationID() + " authorized: " + ac.getAuthorizedID(); } String ncs = "null"; if (nc != null) { ncs = "default: " + nc.getDefaultName() + " name: " + nc.getName(); } String pcs = "null"; if (pc != null) { char[] pwd = pc.getPassword(); pcs = "password: " + (pwd == null ? "null" : "not null " + pwd.length); } String rcs = "null"; if (rc != null) { rcs = "default: " + rc.getDefaultText() + " text: " + rc.getText(); } LOG.debug("{}\nAC: {}\nNC: {}\nPC: {}\nRC: {}", type, acs, ncs, pcs, rcs); } }
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws IOException { if (PasswordCredential.class.isAssignableFrom(credentialType) && (algorithmName == null || algorithmName.equals(ClearPassword.ALGORITHM_CLEAR)) && parameterSpec == null) { try { final PasswordCallback passwordCallback = new PasswordCallback("Password", false); callbackHandler.handle(new Callback[] { passwordCallback }); final char[] chars = passwordCallback.getPassword(); return chars == null ? null : credentialType.cast(new PasswordCredential(ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, chars))); } catch (UnsupportedCallbackException e) { // fall out and try CredentialCallback } } try { final CredentialCallback credentialCallback = new CredentialCallback(credentialType, algorithmName, parameterSpec); callbackHandler.handle(new Callback[] { credentialCallback }); return credentialCallback.getCredential(credentialType, algorithmName, parameterSpec); } catch (UnsupportedCallbackException e) { // no credentials can be acquired; fall out } return null; } }
/** * Tests that an exception is thrown in case an unsupported callback is used. */ @Test public void unsupportCallback() throws Exception { mThrown.expect(UnsupportedCallbackException.class); mThrown.expectMessage(RealmCallback.class + " is unsupported."); Callback[] callbacks = new Callback[3]; callbacks[0] = new NameCallback("Username:"); callbacks[1] = new PasswordCallback("Password:", true); callbacks[2] = new RealmCallback("Realm:"); String user = "alluxio-user-2"; String password = "alluxio-user-2-password"; CallbackHandler clientCBHandler = new PlainSaslClientCallbackHandler(user, password); clientCBHandler.handle(callbacks); }
private void handlePasswordCallback(PasswordCallback pc) { if (credentials.containsKey(userName) ) { pc.setPassword(credentials.get(userName).toCharArray()); } else { LOG.warn("No password found for user: {}", userName); } }
/** * @see org.jboss.security.auth.spi.UsernamePasswordLoginModule#getUsersPassword() */ @Override protected String getUsersPassword() throws LoginException { if (validationMode == ValidationMode.VALIDATION) { return null; } RealmCallback rcb = new RealmCallback("Realm", securityRealm.getName()); NameCallback ncb = new NameCallback("User Name", getUsername()); String password = null; switch (validationMode) { case DIGEST: CredentialCallback cc = new CredentialCallback(PasswordCredential.class, ALGORITHM_DIGEST_MD5); handle(new Callback[]{rcb, ncb, cc}); PasswordCredential passwordCredential = (PasswordCredential) cc.getCredential(); DigestPassword digestPassword = passwordCredential.getPassword(DigestPassword.class); password = ByteIterator.ofBytes(digestPassword.getDigest()).hexEncode().drainToString(); break; case PASSWORD: PasswordCallback pcb = new PasswordCallback("Password", false); handle(new Callback[]{rcb, ncb, pcb}); password = String.valueOf(pcb.getPassword()); break; } return password; }