Security

// Auto-generated encryption key
SecurityEnforcer enforcer = new SecurityEnforcer();

// Custom encryption config
EncryptionConfig config = EncryptionConfig.fromBase64Key(myKey);
SecurityEnforcer enforcer = new SecurityEnforcer(config);

// Access control
enforcer.enforceAccessControl(action, role, callerAgentId, callerRoles);

// Parameter encryption (if @Security(encryptParams=true))
Map<String, Object> secureParams = enforcer.processParameters(action, role, params);

// Execute with timeout (if @Security(securityTimeout=5000))
Object result = enforcer.executeWithTimeout(action, role, () -> doExecute());

// Result encryption (if @Security(encryptResult=true))
Object secureResult = enforcer.processResult(action, role, result);

// Mask fields for logging (if @Security(maskFields={"password","token"}))
Map<String, Object> safeParams = enforcer.maskForLogging(action, role, params);

// Generate a random key
EncryptionConfig config = EncryptionConfig.generateKey();

// From Base64-encoded key
EncryptionConfig config = EncryptionConfig.fromBase64Key(base64String);

// Encrypt/decrypt via SecurityEnforcer
String encrypted = enforcer.encrypt("sensitive data");
String decrypted = enforcer.decrypt(encrypted);
// Format: Base64(IV[12 bytes] + ciphertext + authTag[16 bytes])

public interface PermissionProvider {
    boolean hasPermission(String agentId, String permission);
    static PermissionProvider discover() { /* ServiceLoader lookup */ }
}

// Default patterns (block >= 0.8, warn >= 0.5)
ContentModerator moderator = PatternBasedModerator.withDefaults();

// Strict mode (block >= 0.6, warn >= 0.3)
ContentModerator strict = PatternBasedModerator.strict();

// Custom configuration
ContentModerator custom = PatternBasedModerator.builder()
    .addPattern(Category.TOXIC, "badword1|badword2", 0.9)
    .addPattern(Category.SPAM, "(buy now|free offer)", 0.7)
    .blockThreshold(0.8)
    .warnThreshold(0.5)
    .checkPII(true)
    .enabledCategories(Set.of(Category.VIOLENCE, Category.PII, Category.SPAM))
    .build();

// Check content
ModerationResult result = moderator.checkInput(userMessage);
if (result.isBlocked()) {
    logger.warn("Blocked: {}", result.getReason());
}

// Separate checks for input, output, and tool results
ModerationResult inputResult = moderator.checkInput(userMessage);
ModerationResult outputResult = moderator.checkOutput(modelResponse);
ModerationResult toolResult = moderator.checkToolResult("shell", shellOutput);
// Tool results use less strict checking (mainly PII detection)

// Standard detector (threshold: 0.6)
PromptInjectionDetector detector = PromptInjectionDetector.standard();

// Strict detector (threshold: 0.5)
PromptInjectionDetector strict = PromptInjectionDetector.strict();

// Throwing detector (raises SecurityException on detection)
PromptInjectionDetector throwing = PromptInjectionDetector.throwing();

// Custom configuration
PromptInjectionDetector custom = PromptInjectionDetector.builder()
    .addPattern(InjectionType.JAILBREAK, "my-custom-pattern", 0.9)
    .confidenceThreshold(0.5)
    .throwOnDetection(true)
    .build();

// Check input
InjectionDetectionResult result = detector.detect(userInput);
if (result.isInjectionDetected()) {
    System.out.println("Types: " + result.getDetectedTypes());
    System.out.println("Patterns: " + result.getMatchedPatterns());
    if (result.shouldBlock()) {
        // Block at detector's configured threshold
    }
}

// Convenience methods
boolean safe = detector.isSafe(input);       // No injection detected
boolean block = detector.shouldBlock(input);  // Exceeds threshold

SandboxSpec spec = SandboxSpec.builder()
    .timeout(Duration.ofSeconds(30))
    .maxMemory(256_000_000)   // 256 MB
    .allowNetwork(false)
    .allowFileRead(true)
    .allowFileWrite(false)
    .build();

SandboxedExecutor executor = new SandboxedExecutor(spec);
Object result = executor.execute(() -> runUntrustedCode());

// In-memory (bounded, for development/testing)
AuditStore store = new InMemoryAuditStore();

// File-based (persistent)
AuditStore store = new FileAuditStore(Path.of("/var/log/tnsai/audit.json"));

// Default settings
ValidationService validator = ValidationService.withDefaults();

// Strict settings
ValidationService strict = ValidationService.strict();
// maxStringLength: 10,000  maxParameterCount: 20
// maxNestingDepth: 5       maxArraySize: 100

// Custom configuration
ValidationService validator = ValidationService.builder()
    .maxStringLength(10_000)
    .maxParameterCount(50)
    .maxNestingDepth(5)
    .blockDangerousPatterns(true)
    .allowedFields(Set.of("name", "query", "path"))
    .addPattern("email", Pattern.compile("^[^@]+@[^@]+$"))
    .build();

// Validate string input
ValidationResult result = validator.validateString(userInput, "message");
if (!result.isValid()) {
    result.getErrors().forEach(System.err::println);
}

// Validate parameters (recursive, checks nesting depth)
ValidationResult paramResult = validator.validateParameters(params);

// Validate-and-throw
validator.validateOrThrow(input, "userInput");  // throws SecurityException

// Sanitization (escapes HTML, removes null bytes, truncates)
String safe = validator.sanitize(rawInput);

// Quick danger check
boolean dangerous = validator.containsDangerousPatterns(input);

SecretFilter filter = new SecretFilter();

String sanitized = filter.scrub(userInput);
// "My key is sk-abc123xyz" -> "My key is [REDACTED:API_KEY]"

// Check without redacting
boolean hasSecrets = filter.containsSecrets(userInput);

// Get detailed findings
List<SecretFinding> findings = filter.scan(userInput);
for (SecretFinding finding : findings) {
    System.out.println(finding.type());      // e.g., "AWS_ACCESS_KEY"
    System.out.println(finding.location());  // character offset
}

Agent agent = AgentBuilder.create()
    .model("claude-sonnet-4")
    .secretFilter(new SecretFilter())
    .build();
// All user inputs and tool results are scrubbed before reaching the LLM

public enum PermissionLevel {
    ALWAYS,  // Tool executes without any approval
    ASK,     // Requires user confirmation before execution
    DENY     // Tool is blocked entirely
}

Map<String, PermissionLevel> permissions = Map.of(
    "file_read", PermissionLevel.ALWAYS,
    "file_write", PermissionLevel.ASK,
    "shell", PermissionLevel.ASK,
    "git_write", PermissionLevel.DENY
);

ToolFilter toolFilter = ToolFilter.fromPermissions(permissions);
agent.setToolCallFilter(toolFilter);

ToolFilter filter = ToolFilter.builder()
    .allow("file_*")           // allow all file tools
    .allow("search_*")         // allow all search tools
    .deny("file_write")        // except file_write
    .deny("shell")             // block shell access
    .defaultPermission(PermissionLevel.ASK)  // ask for unlisted tools
    .build();

agent.setToolCallFilter(filter);

// Check a tool explicitly
PermissionLevel level = filter.getPermission("file_read");  // ALWAYS
PermissionLevel level = filter.getPermission("shell");      // DENY
PermissionLevel level = filter.getPermission("unknown");    // ASK (default)