Keycloak Common Library

<dependency>
    <groupId>org.keycloak</groupId>
    <artifactId>keycloak-common</artifactId>
    <version>26.2.5</version>
</dependency>

// Core functionality
import org.keycloak.common.Profile;
import org.keycloak.common.Version;
import org.keycloak.common.ClientConnection;
import org.keycloak.common.VerificationException;

// Constants
import org.keycloak.common.constants.GenericConstants;
import org.keycloak.common.constants.KerberosConstants;
import org.keycloak.common.constants.ServiceAccountConstants;

// Cryptographic utilities
import org.keycloak.common.crypto.CryptoIntegration;
import org.keycloak.common.crypto.CryptoProvider;
import org.keycloak.common.crypto.FipsMode;

// Enums
import org.keycloak.common.enums.SslRequired;
import org.keycloak.common.enums.HostnameVerificationPolicy;

// Profile management
import org.keycloak.common.profile.ProfileConfigResolver;
import org.keycloak.common.profile.PropertiesProfileConfigResolver;

// Utilities
import org.keycloak.common.util.Base64;
import org.keycloak.common.util.MultivaluedMap;
import org.keycloak.common.util.KeycloakUriBuilder;

// Reflection utilities
import org.keycloak.common.util.reflections.Reflections;
import org.keycloak.common.util.reflections.Types;

import org.keycloak.common.Profile;
import org.keycloak.common.Profile.Feature;

// Configure and check features
Profile profile = Profile.defaults();
boolean authzEnabled = Profile.isFeatureEnabled(Feature.AUTHORIZATION);

// Get all enabled features
Set<Feature> allFeatures = profile.getAllFeatures();
Set<Feature> previewFeatures = profile.getPreviewFeatures();

import org.keycloak.common.Version;

// Get version information
String version = Version.VERSION;
String buildTime = Version.BUILD_TIME;
String name = Version.NAME; // "Keycloak"

import org.keycloak.common.crypto.CryptoIntegration;
import org.keycloak.common.crypto.CryptoProvider;
import org.keycloak.common.crypto.FipsMode;

// Initialize crypto provider
CryptoIntegration.init(ClassLoader.getSystemClassLoader());
CryptoProvider provider = CryptoIntegration.getProvider();

// Check FIPS mode
FipsMode fipsMode = FipsMode.DISABLED;
boolean isFipsEnabled = fipsMode.isFipsEnabled();

// Feature profile management
public class Profile {
    public static Profile getInstance();
    public static boolean isFeatureEnabled(Feature feature);
    public Set<Feature> getAllFeatures();
    public ProfileName getName();
}

// Version information
public class Version {
    public static final String VERSION;
    public static final String BUILD_TIME;
    public static final String NAME;
}

// Client connection information
public interface ClientConnection {
    String getRemoteAddr();
    String getRemoteHost();
    int getRemotePort();
    String getLocalAddr();
    int getLocalPort();
}

// Generic constants
public class GenericConstants {
    public static final String PROTOCOL_CLASSPATH = "classpath:";
}

// Kerberos constants
public class KerberosConstants {
    public static final String NEGOTIATE = "Negotiate";
    public static final Oid SPNEGO_OID;
    public static final String KERBEROS_REALM = "kerberosRealm";
}

// Service account constants
public interface ServiceAccountConstants {
    String CLIENT_AUTH = "client_auth";
    String SERVICE_ACCOUNT_USER_PREFIX = "service-account-";
}

// Crypto integration
public class CryptoIntegration {
    public static void init(ClassLoader classLoader);
    public static CryptoProvider getProvider();
    public static void setProvider(CryptoProvider provider);
}

// Crypto provider interface
public interface CryptoProvider {
    Provider getBouncyCastleProvider();
    <T> T getAlgorithmProvider(Class<T> clazz, String algorithm);
    CertificateUtilsProvider getCertificateUtils();
    KeyPairGenerator getKeyPairGen(String algorithm);
}

// FIPS mode configuration
public enum FipsMode {
    NON_STRICT, STRICT, DISABLED;
    boolean isFipsEnabled();
}

// SSL requirement levels
public enum SslRequired {
    ALL, EXTERNAL, NONE;
    boolean isRequired(ClientConnection connection);
    boolean isRequired(String host);
}

// Hostname verification policies
public enum HostnameVerificationPolicy {
    ANY, WILDCARD, STRICT, DEFAULT;
}

// Account API versions
public enum AccountRestApiVersion {
    V1_ALPHA1("v1alpha1");
    String getStrVersion();
}

// Profile configuration resolver
public interface ProfileConfigResolver {
    Profile.ProfileName getProfileName();
    FeatureConfig getFeatureConfig(String feature);
}

// Properties-based resolver
public class PropertiesProfileConfigResolver implements ProfileConfigResolver {
    public PropertiesProfileConfigResolver(Properties properties);
    public static String getPropertyKey(Feature feature);
}

// Comma-separated list resolver
public class CommaSeparatedListProfileConfigResolver implements ProfileConfigResolver {
    public CommaSeparatedListProfileConfigResolver(String enabledFeatures, String disabledFeatures);
}

// Base64 encoding utilities
public class Base64 {
    public static String encodeBytes(byte[] source);
    public static String encodeObject(Serializable serializableObject);
    public static void encode(ByteBuffer raw, ByteBuffer encoded);
}

// Multivalued map interface
public interface MultivaluedMap<K, V> extends Map<K, List<V>> {
    void putSingle(K key, V value);
    void add(K key, V value);
    V getFirst(K key);
    List<V> getList(K key);
}

// URI builder for Keycloak
public class KeycloakUriBuilder {
    public static KeycloakUriBuilder fromUri(String uriTemplate);
    public KeycloakUriBuilder path(String segment);
    public URI build(Object... values);
}

// Comprehensive reflection utilities
public class Reflections {
    public static <T> T cast(Object obj);
    public static Set<Field> getAllDeclaredFields(Class<?> clazz);
    public static Method findDeclaredMethod(Class<?> clazz, String name, Class<?>... args);
    public static Object invokeMethod(Method method, Object instance, Object... args);
    public static <T> Class<T> getRawType(Type type);
}

// Type resolution utilities
public class Types {
    public static Type boxedType(Type type);
    public static Class<?> getRawType(Type type);
    public static Type resolveTypeVariables(Class<?> root, Type type);
    public static Class getCollectionBaseType(Class type, Type genericType);
}

// Verification exception for crypto operations
public class VerificationException extends Exception {
    public VerificationException();
    public VerificationException(String message);
    public VerificationException(String message, Throwable cause);
    public VerificationException(Throwable cause);
}

// Profile-related exceptions
public class ProfileException extends RuntimeException {
    public ProfileException(String message);
    public ProfileException(String message, Throwable cause);
}

// PEM utility exceptions
public class PemException extends Exception {
    public PemException();
    public PemException(String message);
    public PemException(String message, Throwable cause);
    public PemException(Throwable cause);
}