import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESUtil {
    private static final String AES_ALGORITHM = "AES";

    // 生成 AES 密鑰
    public static SecretKey generateKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(AES_ALGORITHM);
        keyGenerator.init(256); // 初始化密鑰長(zhǎng)度為 256 位
        return keyGenerator.generateKey();
    }

    // AES 加密
    public static String encrypt(String plainText, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    // AES 解密
    public static String decrypt(String encryptedText, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decodedBytes = Base64.getDecoder().decode(encryptedText);
        byte[] decryptedBytes = cipher.doFinal(decodedBytes);
        return new String(decryptedBytes);
    }

    public static void main(String[] args) {
        try {
            // 生成密鑰
            SecretKey secretKey = generateKey();
            // 待加密的明文
            String plainText = "Sensitive Data";
            // 加密操作
            String encryptedText = encrypt(plainText, secretKey);
            System.out.println("加密后的密文：" + encryptedText);
            // 解密操作
            String decryptedText = decrypt(encryptedText, secretKey);
            System.out.println("解密后的明文：" + decryptedText);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import java.util.Base64;

public class RSAUtil {
    private static final String RSA_ALGORITHM = "RSA";

    // 生成 RSA 密鑰對(duì)
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        keyPairGenerator.initialize(2048); // 初始化密鑰對(duì)長(zhǎng)度為 2048 位
        return keyPairGenerator.generateKeyPair();
    }

    // RSA 公鑰加密
    public static String encrypt(String plainText, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    // RSA 私鑰解密
    public static String decrypt(String encryptedText, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodedBytes = Base64.getDecoder().decode(encryptedText);
        byte[] decryptedBytes = cipher.doFinal(decodedBytes);
        return new String(decryptedBytes);
    }

    public static void main(String[] args) {
        try {
            // 生成密鑰對(duì)
            KeyPair keyPair = generateKeyPair();
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();
            // 待加密的明文
            String plainText = "Sensitive Data";
            // 加密操作
            String encryptedText = encrypt(plainText, publicKey);
            System.out.println("加密后的密文：" + encryptedText);
            // 解密操作
            String decryptedText = decrypt(encryptedText, privateKey);
            System.out.println("解密后的明文：" + decryptedText);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class RBACUtil {
    // 定義角色 - 權(quán)限映射
    private static final Map<String, Set<String>> rolePermissions = new HashMap<>();
    // 定義用戶(hù) - 角色映射
    private static final Map<String, Set<String>> userRoles = new HashMap<>();

    // 初始化 RBAC 模型
    static {
        // 添加角色權(quán)限
        Set<String> adminPermissions = new HashSet<>();
        adminPermissions.add("read_sensitive_data");
        adminPermissions.add("write_sensitive_data");
        rolePermissions.put("admin", adminPermissions);

        Set<String> userPermissions = new HashSet<>();
        userPermissions.add("read_sensitive_data");
        rolePermissions.put("user", userPermissions);

        // 添加用戶(hù)角色
        Set<String> adminRoles = new HashSet<>();
        adminRoles.add("admin");
        userRoles.put("admin_user", adminRoles);

        Set<String> userRolesSet = new HashSet<>();
        userRolesSet.add("user");
        userRoles.put("normal_user", userRolesSet);
    }

    // 檢查用戶(hù)是否具有指定權(quán)限
    public static boolean hasPermission(String userId, String permission) {
        Set<String> roles = userRoles.get(userId);
        if (roles != null) {
            for (String role : roles) {
                Set<String> permissions = rolePermissions.get(role);
                if (permissions != null && permissions.contains(permission)) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        // 檢查用戶(hù)是否具有讀取敏感數(shù)據(jù)的權(quán)限
        boolean adminHasReadPermission = hasPermission("admin_user", "read_sensitive_data");
        System.out.println("管理員用戶(hù)是否具有讀取敏感數(shù)據(jù)權(quán)限：" + adminHasReadPermission);

        boolean normalHasWritePermission = hasPermission("normal_user", "write_sensitive_data");
        System.out.println("普通用戶(hù)是否具有寫(xiě)入敏感數(shù)據(jù)權(quán)限：" + normalHasWritePermission);
    }
}

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class DataAccessAudit {
    private static final Logger logger = LogManager.getLogger(DataAccessAudit.class);

    // 記錄數(shù)據(jù)訪(fǎng)問(wèn)日志
    public static void logDataAccess(String userId, String dataId, String action) {
        String logMessage = String.format("User: %s, Data: %s, Action: %s, Timestamp: %s",
                userId, dataId, action, System.currentTimeMillis());
        logger.info(logMessage);
    }

    public static void main(String[] args) {
        // 模擬數(shù)據(jù)訪(fǎng)問(wèn)行為并記錄日志
        logDataAccess("user123", "data456", "read");
        logDataAccess("admin789", "data789", "write");
    }
}

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="150" SSLEnabled="true">
    <SSLHostConfig>
        <Certificate certificateKeystoreFile="conf/keystore.jks"
                     certificateKeystorePassword="changeit"
                     type="RSA" />
    </SSLHostConfig>
</Connector>

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.util.Base64;

public class DigitalSignature {
    private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    // 生成密鑰對(duì)
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        return keyPairGenerator.generateKeyPair();
    }

    // 生成數(shù)字簽名
    public static String signData(String data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data.getBytes());
        byte[] signatureBytes = signature.sign();
        return Base64.getEncoder().encodeToString(signatureBytes);
    }

    // 驗(yàn)證數(shù)字簽名
    public static boolean verifySignature(String data, String signature, PublicKey publicKey) throws Exception {
        Signature signatureInstance = Signature.getInstance(SIGNATURE_ALGORITHM);
        signatureInstance.initVerify(publicKey);
        signatureInstance.update(data.getBytes());
        byte[] signatureBytes = Base64.getDecoder().decode(signature);
        return signatureInstance.verify(signatureBytes);
    }

    public static void main(String[] args) {
        try {
            // 生成密鑰對(duì)
            KeyPair keyPair = generateKeyPair();
            PrivateKey privateKey = keyPair.getPrivate();
            PublicKey publicKey = keyPair.getPublic();
            // 待簽名的數(shù)據(jù)
            String data = "Sensitive Data";
            // 生成數(shù)字簽名
            String signature = signData(data, privateKey);
            System.out.println("數(shù)字簽名：" + signature);
            // 驗(yàn)證數(shù)字簽名
            boolean isVerified = verifySignature(data, signature, publicKey);
            System.out.println("數(shù)字簽名驗(yàn)證結(jié)果：" + isVerified);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DatabaseEncryptionExample {
    private static final String DB_URL = "jdbc:h2:mem:testdb";
    private static final String CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS SensitiveData (id INT PRIMARY KEY, encrypted_data VARCHAR(255))";
    private static final String INSERT_SQL = "INSERT INTO SensitiveData (id, encrypted_data) VALUES (?, ?)";
    private static final String SELECT_SQL = "SELECT encrypted_data FROM SensitiveData WHERE id = ?";

    public static void main(String[] args) {
        try {
            // 1. 加載數(shù)據(jù)庫(kù)驅(qū)動(dòng)并建立連接
            Connection connection = DriverManager.getConnection(DB_URL, "sa", "");
            // 2. 創(chuàng)建表
            connection.createStatement().executeUpdate(CREATE_TABLE_SQL);
            // 3. 生成 AES 密鑰（在實(shí)際應(yīng)用中，密鑰應(yīng)妥善保管，不應(yīng)硬編碼）
            SecretKey secretKey = AESUtil.generateKey();
            // 4. 待存儲(chǔ)的敏感數(shù)據(jù)
            String plainData = "Sensitive Data";
            // 5. 對(duì)敏感數(shù)據(jù)進(jìn)行加密
            String encryptedData = AESUtil.encrypt(plainData, secretKey);
            // 6. 將加密后的數(shù)據(jù)存儲(chǔ)到數(shù)據(jù)庫(kù)
            PreparedStatement preparedStatement = connection.prepareStatement(INSERT_SQL);
            preparedStatement.setInt(1, 1);
            preparedStatement.setString(2, encryptedData);
            preparedStatement.executeUpdate();
            // 7. 從數(shù)據(jù)庫(kù)查詢(xún)加密數(shù)據(jù)并解密
            PreparedStatement selectStatement = connection.prepareStatement(SELECT_SQL);
            selectStatement.setInt(1, 1);
            ResultSet resultSet = selectStatement.executeQuery();
            if (resultSet.next()) {
                String retrievedEncryptedData = resultSet.getString("encrypted_data");
                String decryptedData = AESUtil.decrypt(retrievedEncryptedData, secretKey);
                System.out.println("從數(shù)據(jù)庫(kù)中檢索并解密后的數(shù)據(jù)：" + decryptedData);
            }
            // 8. 關(guān)閉資源
            resultSet.close();
            selectStatement.close();
            preparedStatement.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class SQLInjectionPreventionExample {
    private static final String DB_URL = "jdbc:h2:mem:testdb";
    private static final String CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS Users (id INT PRIMARY KEY, username VARCHAR(50), password VARCHAR(50))";
    private static final String INSERT_SQL = "INSERT INTO Users (id, username, password) VALUES (?, ?, ?)";
    private static final String SELECT_SQL = "SELECT * FROM Users WHERE username = ? AND password = ?";

    public static void main(String[] args) {
        try {
            // 1. 加載數(shù)據(jù)庫(kù)驅(qū)動(dòng)并建立連接
            Connection connection = DriverManager.getConnection(DB_URL, "sa", "");
            // 2. 創(chuàng)建表
            connection.createStatement().executeUpdate(CREATE_TABLE_SQL);
            // 3. 插入用戶(hù)數(shù)據(jù)
            PreparedStatement insertStatement = connection.prepareStatement(INSERT_SQL);
            insertStatement.setInt(1, 1);
            insertStatement.setString(2, "user1");
            insertStatement.setString(3, "password123");
            insertStatement.executeUpdate();
            // 4. 模擬用戶(hù)輸入的用戶(hù)名和密碼（可能包含惡意 SQL 代碼）
            String userInputUsername = "user1' OR '1'='1";
            String userInputPassword = "password123";
            // 5. 使用預(yù)編譯 SQL 語(yǔ)句防止 SQL 注入
            PreparedStatement selectStatement = connection.prepareStatement(SELECT_SQL);
            selectStatement.setString(1, userInputUsername);
            selectStatement.setString(2, userInputPassword);
            ResultSet resultSet = selectStatement.executeQuery();
            if (resultSet.next()) {
                System.out.println("登錄成功！");
            } else {
                System.out.println("登錄失敗！");
            }
            // 6. 關(guān)閉資源
            resultSet.close();
            selectStatement.close();
            insertStatement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

import java.util.regex.Pattern;

public class XSSPreventionUtil {
    // 過(guò)濾 XSS 攻擊的正則表達(dá)式模式
    private static final Pattern XSS_PATTERN = Pattern.compile("(<\\s*script\\s*>|<\\s*img\\s+src\\s*=|<\\s*a\\s+href\\s*=|javascript:|onerror=|onload=|onmouseover=|onmouseout=|onmousedown=|onmouseup=|ondblclick=|oncontextmenu=|onkeydown=|onkeypress=|onkeyup=|onabort=|onbeforeunload=|onerror=|onhashchange=|onload=|onpageshow=|onpagehide=|onresize=|onscroll=|onselect=|onsubmit=|onunload=|onfocus=|onblur=|onchange=|oninput=|onreset=|onsearch=|onselect=|onsubmit=|onclick=|<\\s*iframe\\s+src\\s*=|<\\s*object\\s+data\\s*=|<\\s*embed\\s+src\\s*=)", Pattern.CASE_INSENSITIVE);

    // 過(guò)濾 XSS 攻擊
    public static String filterXSS(String data) {
        if (data == null) {
            return null;
        }
        return XSS_PATTERN.matcher(data).replaceAll("");
    }

    // 對(duì)輸出內(nèi)容進(jìn)行 HTML 編碼以防止 XSS 攻擊
    public static String encodeForHTML(String data) {
        if (data == null) {
            return null;
        }
        return data.replace("&", "&amp;")
                .replace("<", "&lt;")
                .replace(">", "&gt;")
                .replace("\"", "&quot;")
                .replace("'", "&#39;");
    }

    public static void main(String[] args) {
        // 模擬用戶(hù)輸入的包含 XSS 攻擊代碼的數(shù)據(jù)
        String userInput = "<script>alert('XSS Attack')</script>";
        // 過(guò)濾 XSS 攻擊
        String filteredData = filterXSS(userInput);
        System.out.println("過(guò)濾后的數(shù)據(jù)：" + filteredData);
        // 對(duì)輸出內(nèi)容進(jìn)行 HTML 編碼
        String encodedData = encodeForHTML(filteredData);
        System.out.println("HTML 編碼后的數(shù)據(jù)：" + encodedData);
    }
}