CAS Server Core Authentication API

<dependency>
    <groupId>org.apereo.cas</groupId>
    <artifactId>cas-server-core-authentication-api</artifactId>
    <version>${cas.version}</version>
</dependency>

// Core authentication management
import org.apereo.cas.authentication.Authentication;
import org.apereo.cas.authentication.AuthenticationBuilder;
import org.apereo.cas.authentication.AuthenticationHandler;
import org.apereo.cas.authentication.AuthenticationManager;
import org.apereo.cas.authentication.AuthenticationResult;
import org.apereo.cas.authentication.AuthenticationTransaction;
import org.apereo.cas.authentication.Credential;
import org.apereo.cas.authentication.Principal;

// Authentication builders and factories
import org.apereo.cas.authentication.DefaultAuthentication;
import org.apereo.cas.authentication.DefaultAuthenticationBuilder;
import org.apereo.cas.authentication.DefaultAuthenticationManager;
import org.apereo.cas.authentication.DefaultAuthenticationTransaction;

// Core utilities
import org.apereo.cas.authentication.CoreAuthenticationUtils;
import org.apereo.cas.authentication.AuthenticationHolder;

// Principal management
import org.apereo.cas.authentication.principal.DefaultPrincipalFactory;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.authentication.principal.PrincipalElectionStrategy;
import org.apereo.cas.authentication.principal.SimplePrincipal;

// Common credentials
import org.apereo.cas.authentication.credential.UsernamePasswordCredential;
import org.apereo.cas.authentication.credential.RememberMeUsernamePasswordCredential;
import org.apereo.cas.authentication.credential.OneTimePasswordCredential;
import org.apereo.cas.authentication.credential.BasicIdentifiableCredential;

// Create authentication manager
AuthenticationManager authenticationManager = new DefaultAuthenticationManager(
    authenticationEventExecutionPlan,
    authenticationHandlerResolvers,
    authenticationTransactionFactory
);

// Create authentication transaction
AuthenticationTransaction transaction = DefaultAuthenticationTransaction.of(credential);

// Perform authentication
AuthenticationResult result = authenticationManager.authenticate(transaction);
Authentication authentication = result.getAuthentication();

// Username/password authentication
UsernamePasswordCredential credential = new UsernamePasswordCredential("username", "password");

// Remember-me authentication
RememberMeUsernamePasswordCredential rememberMeCredential = 
    new RememberMeUsernamePasswordCredential("username", "password", true);

// One-time password
OneTimePasswordCredential otpCredential = new OneTimePasswordCredential("user", "123456");

// Validate credentials
ValidationContext context = new ValidationContext();
boolean isValid = credential.validate(context);

// Create principal factory
PrincipalFactory principalFactory = new DefaultPrincipalFactory();

// Create principal with attributes
Map<String, Object> attributes = Map.of(
    "email", "user@example.com",
    "role", "admin"
);
Principal principal = principalFactory.createPrincipal("username", attributes);

// Principal election strategy
PrincipalElectionStrategy electionStrategy = new DefaultPrincipalElectionStrategy();
Principal elected = electionStrategy.electPrincipal(authentications);

// Store authentication in thread-local context
AuthenticationHolder.setCurrentAuthentication(authentication);

// Retrieve current authentication
Authentication current = AuthenticationHolder.getCurrentAuthentication();

// Clear authentication context
AuthenticationHolder.clear();

// Abstract base handler
public abstract class AbstractAuthenticationHandler implements AuthenticationHandler {
    protected AbstractAuthenticationHandler(String name, ServicesManager servicesManager, 
                                          PrincipalFactory principalFactory, Integer order) { }
    
    public abstract boolean supports(Credential credential);
    public abstract AuthenticationHandlerExecutionResult authenticate(Credential credential) 
        throws GeneralSecurityException, PreventedException;
}

// Username/password handler
public class AcceptUsersAuthenticationHandler extends AbstractUsernamePasswordAuthenticationHandler {
    public AcceptUsersAuthenticationHandler(Map<String, String> users) { }
}

// Principal factory
public interface PrincipalFactory {
    Principal createPrincipal(String id);
    Principal createPrincipal(String id, Map<String, Object> attributes);
}

// Principal election strategy
public interface PrincipalElectionStrategy {
    Principal electPrincipal(Collection<Authentication> authentications);
}

// Attribute merging
public interface AttributeMerger {
    Map<String, List<Object>> mergeAttributes(Map<String, List<Object>> toModify, 
                                            Map<String, List<Object>> toMerge);
}

// Base authentication policy
public abstract class BaseAuthenticationPolicy implements AuthenticationPolicy {
    public abstract AuthenticationPolicyExecutionResult execute(AuthenticationTransaction transaction) 
        throws Exception;
}

// Policy implementations
public class AllAuthenticationHandlersSucceededAuthenticationPolicy extends BaseAuthenticationPolicy { }
public class AtLeastOneCredentialValidatedAuthenticationPolicy extends BaseAuthenticationPolicy { }
public class RequiredAuthenticationHandlerAuthenticationPolicy extends BaseAuthenticationPolicy { }

// Base credential class
public abstract class AbstractCredential implements Credential {
    public abstract String getId();
    public boolean isValid() { return true; }
    public void validate(ValidationContext context) throws Exception { }
}

// Credential implementations
public class UsernamePasswordCredential extends AbstractCredential { }
public class OneTimePasswordCredential extends AbstractCredential { }
public class OneTimeTokenCredential extends AbstractCredential { }
public class HttpBasedServiceCredential extends AbstractCredential { }

// Password policy handling strategy
public interface AuthenticationPasswordPolicyHandlingStrategy {
    List<MessageDescriptor> handle(Principal principal, PasswordPolicyContext passwordPolicyConfiguration) 
        throws Exception;
}

// Password policy context
public class PasswordPolicyContext {
    public PasswordPolicyContext(PasswordPolicy passwordPolicy) { }
    public PasswordPolicy getPasswordPolicy() { }
}

// Adaptive authentication policy
public interface AdaptiveAuthenticationPolicy {
    boolean isAuthenticationRequestAllowed(RequestContext requestContext, 
                                         String userAgent, 
                                         GeoLocationRequest location);
}

// IP address intelligence
public interface IPAddressIntelligenceService {
    IPAddressIntelligenceResponse examine(RequestContext requestContext, String clientIpAddress);
}

// Authentication utilities
public class CoreAuthenticationUtils {
    public static Map<String, Object> convertAttributeValuesToObjects(Map<String, ?> attributes);
    public static AttributeMerger getAttributeMerger(PrincipalAttributesCoreProperties.MergingStrategyTypes mergingPolicy);
    public static boolean isRememberMeAuthentication(Authentication authentication);
    public static Predicate<Credential> newCredentialSelectionPredicate(String selectionCriteria);
    public static List<AuthenticationPolicy> newAuthenticationPolicy(AuthenticationPolicyProperties policyProps);
}

// SSL context management
public interface CasSSLContext {
    SSLContext getSslContext();
    TrustManager[] getTrustManagers();
    KeyManager[] getKeyManagers();
    HostnameVerifier getHostnameVerifier();
    
    static CasSSLContext system() { }
    static CasSSLContext disabled() { }
}

// Account-related exceptions
public class AccountDisabledException extends AccountException { }
public class AccountPasswordMustChangeException extends AccountException { }
public class InvalidLoginLocationException extends AccountException { }
public class InvalidLoginTimeException extends AccountException { }

// Principal-related exceptions
public class MixedPrincipalException extends Exception { }
public class UniquePrincipalRequiredException extends Exception { }
public class UnresolvedPrincipalException extends Exception { }

// Policy exceptions
public class UnsatisfiedAuthenticationPolicyException extends AbstractTicketException { }