How to use

getType

method

in

org.keycloak.models.UserCredentialModel

@Override
public boolean validCredentials(RealmModel realm, UserModel user, List<UserCredentialModel> input) {
  if (user.getUsername().equals("test-user") && input.size() == 1) {
    UserCredentialModel password = input.get(0);
    if (password.getType().equals(UserCredentialModel.PASSWORD)) {
      return "secret".equals(password.getValue());
    }
  }
  return false;
}

  private static boolean validCredential(KeycloakSession session, RealmModel realm, UserModel user, UserCredentialModel credential) {
    if (credential.getType().equals(UserCredentialModel.PASSWORD)) {
      if (!validPassword(session, realm, user, credential.getValue())) {
        return false;
      }
    } else if (credential.getType().equals(UserCredentialModel.PASSWORD_TOKEN)) {
      if (!validPasswordToken(realm, user, credential.getValue())) {
        return false;
      }
    } else if (credential.getType().equals(UserCredentialModel.TOTP)) {
      if (!validTOTP(realm, user, credential.getValue())) {
        return false;
      }
    } else if (credential.getType().equals(UserCredentialModel.HOTP)) {
      if (!validHOTP(realm, user, credential.getValue())) {
        return false;
      }
    } else if (credential.getType().equals(UserCredentialModel.SECRET)) {
      if (!validSecret(realm, user, credential.getValue())) {
        return false;
      }
    } else {
      return false;
    }
    return true;
  }
}

@Override
public CredentialValidationOutput validCredentials(KeycloakSession session, RealmModel realm, UserCredentialModel... input) {
  List<UserFederationProviderModel> fedProviderModels = realm.getUserFederationProviders();
  List<UserFederationProvider> fedProviders = new ArrayList<UserFederationProvider>();
  for (UserFederationProviderModel fedProviderModel : fedProviderModels) {
    fedProviders.add(getFederationProvider(fedProviderModel));
  }
  CredentialValidationOutput result = null;
  for (UserCredentialModel cred : input) {
    UserFederationProvider providerSupportingCreds = null;
    // Find first provider, which supports required credential type
    for (UserFederationProvider fedProvider : fedProviders) {
      if (fedProvider.getSupportedCredentialTypes().contains(cred.getType())) {
        providerSupportingCreds = fedProvider;
        break;
      }
    }
    if (providerSupportingCreds == null) {
      logger.warn("Don't have provider supporting credentials of type " + cred.getType());
      return CredentialValidationOutput.failed();
    }
    logger.debug("Found provider [" + providerSupportingCreds + "] supporting credentials of type " + cred.getType());
    CredentialValidationOutput currentResult = providerSupportingCreds.validCredentials(realm, cred);
    result = (result == null) ? currentResult : result.merge(currentResult);
  }
  // For now, validCredentials(realm, input) is not supported for local userProviders
  return (result != null) ? result : CredentialValidationOutput.failed();
}

@Override
public boolean validCredentials(KeycloakSession session, RealmModel realm, UserModel user, List<UserCredentialModel> input) {
  UserFederationProvider link = getFederationLink(realm, user);
  if (link != null) {
    validateUser(realm, user);
    Set<String> supportedCredentialTypes = link.getSupportedCredentialTypes(user);
    if (supportedCredentialTypes.size() > 0) {
      List<UserCredentialModel> fedCreds = new ArrayList<UserCredentialModel>();
      List<UserCredentialModel> localCreds = new ArrayList<UserCredentialModel>();
      for (UserCredentialModel cred : input) {
        if (supportedCredentialTypes.contains(cred.getType())) {
          fedCreds.add(cred);
        } else {
          localCreds.add(cred);
        }
      }
      if (!link.validCredentials(realm, user, fedCreds)) {
        return false;
      }
      return session.userStorage().validCredentials(session, realm, user, localCreds);
    }
  }
  return session.userStorage().validCredentials(session, realm, user, input);
}

public void updateCredential(RealmModel realm, UserModel user, UserCredentialModel credential) {
  if (credential.getType().equals(UserCredentialModel.PASSWORD)) {
    if (realm.getPasswordPolicy() != null) {
      PasswordPolicy.Error error = realm.getPasswordPolicy().validate(session, user, credential.getValue());
      if (error != null) throw new ModelException(error.getMessage(), error.getParameters());
    }
  }
  user.updateCredential(credential);
}

@Override
public CredentialValidationOutput authenticate(RealmModel realm, CredentialInput input) {
  if (!(input instanceof UserCredentialModel)) return null;
  UserCredentialModel credential = (UserCredentialModel)input;
  if (credential.getType().equals(UserCredentialModel.KERBEROS)) {
    String spnegoToken = credential.getValue();
    SPNEGOAuthenticator spnegoAuthenticator = factory.createSPNEGOAuthenticator(spnegoToken, kerberosConfig);
    spnegoAuthenticator.authenticate();
    Map<String, String> state = new HashMap<String, String>();
    if (spnegoAuthenticator.isAuthenticated()) {
      String username = spnegoAuthenticator.getAuthenticatedUsername();
      UserModel user = findOrCreateAuthenticatedUser(realm, username);
      if (user == null) {
        return CredentialValidationOutput.failed();
      } else {
        String delegationCredential = spnegoAuthenticator.getSerializedDelegationCredential();
        if (delegationCredential != null) {
          state.put(KerberosConstants.GSS_DELEGATION_CREDENTIAL, delegationCredential);
        }
        return new CredentialValidationOutput(user, CredentialValidationOutput.Status.AUTHENTICATED, state);
      }
    }  else {
      state.put(KerberosConstants.RESPONSE_TOKEN, spnegoAuthenticator.getResponseToken());
      return new CredentialValidationOutput(null, CredentialValidationOutput.Status.CONTINUE, state);
    }
  } else {
    return null;
  }
}