Cookie Management

/**
 * HTTP cookie manager for browser session
 */
public class CookieManager {
    /** Create cookie manager with default settings */
    public CookieManager();
    
    /** Add cookie to manager */
    public void addCookie(Cookie cookie);
    
    /** Get all cookies */
    public Set<Cookie> getCookies();
    
    /** Get cookies for specific URL */
    public Set<Cookie> getCookies(URL url);
    
    /** Get cookies for specific domain */
    public Set<Cookie> getCookies(String domain);
    
    /** Get cookies matching criteria */
    public Set<Cookie> getCookies(String domain, String path);
    
    /** Remove specific cookie */
    public void removeCookie(Cookie cookie);
    
    /** Remove cookies by name and domain */
    public void removeCookies(String name, String domain);
    
    /** Clear all cookies */
    public void clearCookies();
    
    /** Clear expired cookies */
    public void clearExpiredCookies();
    
    /** Check if cookies are enabled */
    public boolean isCookiesEnabled();
    
    /** Enable or disable cookie support */
    public void setCookiesEnabled(boolean enabled);
    
    /** Get cookie count */
    public int getCookieCount();
    
    /** Check if cookie exists */
    public boolean hasCookie(String name, String domain);
    
    /** Get specific cookie */
    public Cookie getCookie(String name, String domain);
    
    /** Import cookies from string (Netscape format) */
    public void importCookies(String cookieData);
    
    /** Export cookies to string (Netscape format) */
    public String exportCookies();
    
    /** Load cookies from file */
    public void loadCookies(File file) throws IOException;
    
    /** Save cookies to file */
    public void saveCookies(File file) throws IOException;
}

import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.CookieManager;
import com.gargoylesoftware.htmlunit.util.Cookie;
import java.util.Date;
import java.util.Set;

try (WebClient webClient = new WebClient()) {
    CookieManager cookieManager = webClient.getCookieManager();
    
    // Create and add cookies
    Cookie sessionCookie = new Cookie("example.com", "sessionId", "abc123");
    cookieManager.addCookie(sessionCookie);
    
    // Create persistent cookie with expiration
    Date expiration = new Date(System.currentTimeMillis() + 86400000); // 1 day
    Cookie persistentCookie = new Cookie("example.com", "userId", "user123", "/", expiration, false, false);
    cookieManager.addCookie(persistentCookie);
    
    // Load a page (cookies will be sent automatically)
    HtmlPage page = webClient.getPage("https://example.com");
    
    // Check cookies received from server
    Set<Cookie> allCookies = cookieManager.getCookies();
    System.out.println("Total cookies: " + allCookies.size());
    
    for (Cookie cookie : allCookies) {
        System.out.println("Cookie: " + cookie.getName() + "=" + cookie.getValue() + 
                          " (domain: " + cookie.getDomain() + ", path: " + cookie.getPath() + ")");
    }
    
    // Get cookies for specific domain
    Set<Cookie> exampleCookies = cookieManager.getCookies("example.com");
    System.out.println("Cookies for example.com: " + exampleCookies.size());
    
    // Check specific cookie
    if (cookieManager.hasCookie("sessionId", "example.com")) {
        Cookie cookie = cookieManager.getCookie("sessionId", "example.com");
        System.out.println("Session ID: " + cookie.getValue());
    }
    
    // Clear expired cookies
    cookieManager.clearExpiredCookies();
    
    // Save cookies to file for later use
    cookieManager.saveCookies(new File("cookies.txt"));
}

/**
 * HTTP cookie with standard attributes
 */
public class Cookie {
    /** Create basic cookie */
    public Cookie(String domain, String name, String value);
    
    /** Create cookie with path */
    public Cookie(String domain, String name, String value, String path);
    
    /** Create cookie with expiration */
    public Cookie(String domain, String name, String value, String path, Date expires);
    
    /** Create cookie with all attributes */
    public Cookie(String domain, String name, String value, String path, Date expires, boolean secure, boolean httpOnly);
    
    /** Create cookie with max age */
    public Cookie(String domain, String name, String value, String path, int maxAge, boolean secure, boolean httpOnly);
    
    /** Get cookie name */
    public String getName();
    
    /** Get cookie value */
    public String getValue();
    
    /** Set cookie value */
    public void setValue(String value);
    
    /** Get cookie domain */
    public String getDomain();
    
    /** Set cookie domain */
    public void setDomain(String domain);
    
    /** Get cookie path */
    public String getPath();
    
    /** Set cookie path */
    public void setPath(String path);
    
    /** Get expiration date */
    public Date getExpires();
    
    /** Set expiration date */
    public void setExpires(Date expires);
    
    /** Get max age in seconds */
    public int getMaxAge();
    
    /** Set max age in seconds */
    public void setMaxAge(int maxAge);
    
    /** Check if cookie is secure (HTTPS only) */
    public boolean isSecure();
    
    /** Set secure flag */
    public void setSecure(boolean secure);
    
    /** Check if cookie is HTTP only (no JavaScript access) */
    public boolean isHttpOnly();
    
    /** Set HTTP only flag */
    public void setHttpOnly(boolean httpOnly);
    
    /** Get SameSite attribute */
    public String getSameSite();
    
    /** Set SameSite attribute (Strict, Lax, None) */
    public void setSameSite(String sameSite);
    
    /** Check if cookie is expired */
    public boolean isExpired();
    
    /** Check if cookie is session cookie (no expiration) */
    public boolean isSessionCookie();
    
    /** Check if cookie is persistent (has expiration) */
    public boolean isPersistent();
    
    /** Get cookie version */
    public int getVersion();
    
    /** Set cookie version */
    public void setVersion(int version);
    
    /** Get cookie comment */
    public String getComment();
    
    /** Set cookie comment */
    public void setComment(String comment);
    
    /** Get cookie comment URL */
    public String getCommentURL();
    
    /** Set cookie comment URL */
    public void setCommentURL(String commentURL);
    
    /** Check if cookie should be discarded */
    public boolean isToBeDiscarded();
    
    /** Set discard flag */
    public void setToBeDiscarded(boolean toBeDiscarded);
    
    /** Get cookie ports */
    public int[] getPorts();
    
    /** Set cookie ports */
    public void setPorts(int[] ports);
    
    /** Convert cookie to header string */
    public String toString();
    
    /** Convert cookie to Set-Cookie header format */
    public String toExternalForm();
    
    /** Check if cookie matches domain and path */
    public boolean matches(String domain, String path);
    
    /** Clone the cookie */
    public Cookie clone();
}

import java.util.Calendar;
import java.util.Date;

// Create different types of cookies
Cookie sessionCookie = new Cookie("example.com", "JSESSIONID", "1234567890");

// Persistent cookie with 1 hour expiration
Calendar cal = Calendar.getInstance();
cal.add(Calendar.HOUR, 1);
Cookie persistentCookie = new Cookie("example.com", "rememberMe", "true", "/", cal.getTime(), false, true);

// Secure cookie for HTTPS
Cookie secureCookie = new Cookie("secure.example.com", "authToken", "token123", "/", null, true, true);
secureCookie.setSameSite("Strict");

// Cookie with max age (30 days)
Cookie maxAgeCookie = new Cookie("example.com", "preferences", "theme=dark", "/", 30 * 24 * 3600, false, false);

// Working with cookie attributes
System.out.println("Cookie name: " + sessionCookie.getName());
System.out.println("Cookie value: " + sessionCookie.getValue());
System.out.println("Cookie domain: " + sessionCookie.getDomain());
System.out.println("Cookie path: " + sessionCookie.getPath());
System.out.println("Is secure: " + sessionCookie.isSecure());
System.out.println("Is HTTP only: " + sessionCookie.isHttpOnly());
System.out.println("Is session cookie: " + sessionCookie.isSessionCookie());
System.out.println("Is expired: " + sessionCookie.isExpired());

// Modify cookie
sessionCookie.setValue("newValue123");
sessionCookie.setSecure(true);
sessionCookie.setHttpOnly(true);

// Check if cookie matches domain/path
boolean matches = sessionCookie.matches("example.com", "/");
System.out.println("Cookie matches example.com/: " + matches);

// Convert to header format
String headerValue = sessionCookie.toExternalForm();
System.out.println("Set-Cookie header: " + headerValue);

/**
 * Cookie storage interface for custom implementations
 */
public interface CookieStore {
    /** Add cookie to store */
    void addCookie(Cookie cookie);
    
    /** Get all cookies from store */
    List<Cookie> getCookies();
    
    /** Clear all cookies */
    boolean clearExpired(Date date);
    
    /** Clear all cookies */
    void clear();
}

/**
 * Basic in-memory cookie store
 */
public class BasicCookieStore implements CookieStore {
    /** Create empty cookie store */
    public BasicCookieStore();
    
    /** Add cookie */
    public void addCookie(Cookie cookie);
    
    /** Get all cookies */
    public List<Cookie> getCookies();
    
    /** Clear expired cookies */
    public boolean clearExpired(Date date);
    
    /** Clear all cookies */
    public void clear();
    
    /** Get cookie count */
    public int size();
}

/**
 * Cookie specification for parsing and matching
 */
public interface CookieSpec {
    /** Parse Set-Cookie header */
    List<Cookie> parse(Header header, CookieOrigin origin) throws MalformedCookieException;
    
    /** Validate cookie */
    void validate(Cookie cookie, CookieOrigin origin) throws MalformedCookieException;
    
    /** Check if cookie matches origin */
    boolean match(Cookie cookie, CookieOrigin origin);
    
    /** Format cookies for Cookie header */
    List<Header> formatCookies(List<Cookie> cookies);
    
    /** Get version handled by this spec */
    int getVersion();
    
    /** Get version header */
    Header getVersionHeader();
}

/**
 * Cookie origin for domain/path matching
 */
public class CookieOrigin {
    /** Create cookie origin */
    public CookieOrigin(String host, int port, String path, boolean secure);
    
    /** Get host */
    public String getHost();
    
    /** Get port */
    public int getPort();
    
    /** Get path */
    public String getPath();
    
    /** Check if secure */
    public boolean isSecure();
}

// Filter cookies by criteria
CookieManager cookieManager = webClient.getCookieManager();

// Get only secure cookies
Set<Cookie> secureCookies = cookieManager.getCookies().stream()
    .filter(Cookie::isSecure)
    .collect(Collectors.toSet());

// Get only session cookies
Set<Cookie> sessionCookies = cookieManager.getCookies().stream()
    .filter(Cookie::isSessionCookie)
    .collect(Collectors.toSet());

// Get cookies for subdomain
Set<Cookie> subdomainCookies = cookieManager.getCookies().stream()
    .filter(cookie -> cookie.getDomain().endsWith(".example.com"))
    .collect(Collectors.toSet());

// Remove expired cookies
cookieManager.getCookies().stream()
    .filter(Cookie::isExpired)
    .forEach(cookieManager::removeCookie);

// Export cookies to Netscape format
String cookieData = cookieManager.exportCookies();
System.out.println("Exported cookies:\n" + cookieData);

// Save to file
try (FileWriter writer = new FileWriter("cookies.txt")) {
    writer.write(cookieData);
}

// Import cookies from string
String importData = """
    # Netscape HTTP Cookie File
    .example.com	TRUE	/	FALSE	1609459200	sessionId	abc123
    .example.com	TRUE	/admin	TRUE	1609459200	adminToken	xyz789
    """;
cookieManager.importCookies(importData);

// Load from file
cookieManager.loadCookies(new File("saved-cookies.txt"));

// Create custom cookie manager
CookieManager customManager = new CookieManager() {
    @Override
    public void addCookie(Cookie cookie) {
        // Log all cookies being added
        System.out.println("Adding cookie: " + cookie.getName() + " for " + cookie.getDomain());
        
        // Only accept cookies from trusted domains
        if (cookie.getDomain().endsWith(".trusted.com") || cookie.getDomain().equals("localhost")) {
            super.addCookie(cookie);
        } else {
            System.out.println("Rejected cookie from untrusted domain: " + cookie.getDomain());
        }
    }
};

webClient.setCookieManager(customManager);

/**
 * Security-related cookie methods and checks
 */
public class Cookie {
    /** Check if cookie has secure attributes for sensitive data */
    public boolean isSecureForSensitiveData() {
        return isSecure() && isHttpOnly() && "Strict".equals(getSameSite());
    }
    
    /** Create secure cookie for authentication */
    public static Cookie createSecureAuthCookie(String domain, String name, String value, String path) {
        Cookie cookie = new Cookie(domain, name, value, path, null, true, true);
        cookie.setSameSite("Strict");
        return cookie;
    }
    
    /** Create session cookie with security flags */
    public static Cookie createSecureSessionCookie(String domain, String name, String value) {
        return createSecureAuthCookie(domain, name, value, "/");
    }
}

// Create secure authentication cookie
Cookie authCookie = Cookie.createSecureAuthCookie("example.com", "authToken", "securetoken123", "/");
cookieManager.addCookie(authCookie);

// Create CSRF protection cookie
Cookie csrfCookie = new Cookie("example.com", "csrfToken", "csrf123", "/", null, true, false);
csrfCookie.setSameSite("Strict");
cookieManager.addCookie(csrfCookie);

// Check cookie security
for (Cookie cookie : cookieManager.getCookies()) {
    if (cookie.getName().toLowerCase().contains("auth") || 
        cookie.getName().toLowerCase().contains("session")) {
        
        if (!cookie.isSecure()) {
            System.err.println("WARNING: Insecure authentication cookie: " + cookie.getName());
        }
        
        if (!cookie.isHttpOnly()) {
            System.err.println("WARNING: JavaScript-accessible auth cookie: " + cookie.getName());
        }
        
        if (!"Strict".equals(cookie.getSameSite()) && !"Lax".equals(cookie.getSameSite())) {
            System.err.println("WARNING: Missing SameSite protection: " + cookie.getName());
        }
    }
}

// Debug cookie information
public void debugCookies(CookieManager cookieManager) {
    Set<Cookie> cookies = cookieManager.getCookies();
    
    System.out.println("=== Cookie Debug Information ===");
    System.out.println("Total cookies: " + cookies.size());
    System.out.println("Cookies enabled: " + cookieManager.isCookiesEnabled());
    
    for (Cookie cookie : cookies) {
        System.out.println("\nCookie: " + cookie.getName());
        System.out.println("  Value: " + cookie.getValue());
        System.out.println("  Domain: " + cookie.getDomain());
        System.out.println("  Path: " + cookie.getPath());
        System.out.println("  Expires: " + cookie.getExpires());
        System.out.println("  Max-Age: " + cookie.getMaxAge());
        System.out.println("  Secure: " + cookie.isSecure());
        System.out.println("  HttpOnly: " + cookie.isHttpOnly());
        System.out.println("  SameSite: " + cookie.getSameSite());
        System.out.println("  Session Cookie: " + cookie.isSessionCookie());
        System.out.println("  Expired: " + cookie.isExpired());
        System.out.println("  Version: " + cookie.getVersion());
        
        if (cookie.getComment() != null) {
            System.out.println("  Comment: " + cookie.getComment());
        }
    }
    
    // Group by domain
    Map<String, List<Cookie>> byDomain = cookies.stream()
        .collect(Collectors.groupingBy(Cookie::getDomain));
        
    System.out.println("\n=== Cookies by Domain ===");
    for (Map.Entry<String, List<Cookie>> entry : byDomain.entrySet()) {
        System.out.println(entry.getKey() + ": " + entry.getValue().size() + " cookies");
    }
}