-- 配置国密SSL连接
ALTER SYSTEM SET ssl = on;
ALTER SYSTEM SET ssl_ciphers = 'SM4-GCM-SM3:SM4-CCM-SM3';
ALTER SYSTEM SET ssl_cert_file = 'server-sm2.crt';
ALTER SYSTEM SET ssl_key_file = 'server-sm2.key';

-- 启用TDE透明数据加密，使用SM4算法
CREATE KEY ENCRYPTION KEY water_biz_kek 
WITH ALGORITHM = 'SM4-CTR', KEY_STORE = 'localkms';

-- 为敏感表启用加密
CREATE TABLE water_customer (
    id SERIAL PRIMARY KEY,
    customer_name VARCHAR(100) ENCRYPTED WITH (
        COLUMN_ENCRYPTION_KEY = water_biz_kek,
        ENCRYPTION_TYPE = DETERMINISTIC,
        ALGORITHM = 'SM4-CTR'
    ),
    id_card VARCHAR(18) ENCRYPTED WITH (
        COLUMN_ENCRYPTION_KEY = water_biz_kek,
        ENCRYPTION_TYPE = RANDOMIZED,
        ALGORITHM = 'SM4-CTR'
    )
);

-- 创建多租户行级安全策略
CREATE ROW LEVEL SECURITY POLICY tenant_isolation_policy
ON water_customer
USING (tenant_id = current_setting('app.current_tenant_id')::bigint);

-- 启用行级安全
ALTER TABLE water_customer ENABLE ROW LEVEL SECURITY;

-- 创建数据访问角色
CREATE ROLE water_data_reader;
CREATE ROLE water_data_writer;

-- 配置列级权限
GRANT SELECT (id, customer_name, phone) ON water_customer TO water_data_reader;
GRANT ALL ON water_customer TO water_data_writer;

-- 创建数据脱敏函数
CREATE OR REPLACE FUNCTION mask_phone(phone_num TEXT) 
RETURNS TEXT AS $$
BEGIN
    RETURN SUBSTRING(phone_num, 1, 3) || '****' || SUBSTRING(phone_num, 8, 4);
END;
$$ LANGUAGE plpgsql;

-- 创建脱敏视图
CREATE VIEW water_customer_masked AS
SELECT 
    id,
    customer_name,
    mask_phone(phone) as phone,
    LEFT(id_card, 6) || '********' || RIGHT(id_card, 4) as id_card_masked
FROM water_customer;

-- 授权普通用户只能访问脱敏视图
GRANT SELECT ON water_customer_masked TO water_normal_user;

@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        // 使用国密SM3哈希算法
        return new SM3PasswordEncoder();
    }
    
    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
        return new JwtAuthenticationTokenFilter();
    }
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            // CSRF防护
            .csrf(csrf -> csrf.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))
            // 请求授权
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/login", "/api/register").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            // JWT过滤器
            .addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class)
            // 会话管理
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .build();
    }
}

@Service
public class MFAService {
    
    @Autowired
    private SmsService smsService;
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean sendSmsCode(String phone) {
        String code = generateRandomCode();
        String key = "mfa:sms:" + phone;
        
        // 存储验证码，5分钟过期
        redisTemplate.opsForValue().set(key, code, Duration.ofMinutes(5));
        
        // 发送短信
        return smsService.send(phone, "您的验证码是：" + code + "，5分钟内有效。");
    }
    
    public boolean verifySmsCode(String phone, String code) {
        String key = "mfa:sms:" + phone;
        String storedCode = redisTemplate.opsForValue().get(key);
        
        if (storedCode != null && storedCode.equals(code)) {
            redisTemplate.delete(key);
            return true;
        }
        return false;
    }
}

server:
  port: 8443
  ssl:
    enabled: true
    key-store: classpath:keystore/server.p12
    key-store-password: ${SSL_KEYSTORE_PASSWORD}
    key-store-type: PKCS12
    # 支持国密算法
    ciphers: SM4-GCM-SM3,SM4-CCM-SM3,ECDHE-SM2-WITH-SM4-SM3
    protocols: TLSv1.2,TLSv1.3

@Component
public class DataEncryptionService {
    
    private final SM4Cipher sm4Cipher = new SM4Cipher();
    
    public String encryptSensitiveData(String plaintext) {
        try {
            return sm4Cipher.encrypt(plaintext);
        } catch (Exception e) {
            throw new SecurityException("数据加密失败", e);
        }
    }
    
    public String decryptSensitiveData(String ciphertext) {
        try {
            return sm4Cipher.decrypt(ciphertext);
        } catch (Exception e) {
            throw new SecurityException("数据解密失败", e);
        }
    }
}

@Component
public class ApiSignatureValidator {
    
    public boolean validateSignature(HttpServletRequest request) {
        String timestamp = request.getHeader("X-Timestamp");
        String nonce = request.getHeader("X-Nonce");
        String signature = request.getHeader("X-Signature");
        String body = getRequestBody(request);
        
        // 检查时间戳，防止重放攻击
        if (isTimestampExpired(timestamp)) {
            return false;
        }
        
        // 生成签名
        String expectedSignature = generateSignature(timestamp, nonce, body);
        
        // 验证签名
        return signature.equals(expectedSignature);
    }
    
    private String generateSignature(String timestamp, String nonce, String body) {
        String message = timestamp + nonce + body;
        return SM3Utils.hash(message);
    }
}

@Component
public class RateLimitService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean isAllowed(String key, int limit, Duration window) {
        String redisKey = "rate_limit:" + key;
        String current = redisTemplate.opsForValue().get(redisKey);
        
        if (current == null) {
            redisTemplate.opsForValue().set(redisKey, "1", window);
            return true;
        }
        
        int count = Integer.parseInt(current);
        if (count < limit) {
            redisTemplate.opsForValue().increment(redisKey);
            return true;
        }
        
        return false;
    }
}

# 允许HTTPS访问
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 允许HTTP重定向到HTTPS
iptables -A INPUT -p tcp --dport 80 -j ACCEPT

# 禁止直接数据库访问
iptables -A INPUT -p tcp --dport 5432 -s ! 192.168.1.0/24 -j DROP

# 允许内网SSH管理
iptables -A INPUT -p tcp --dport 22 -s 192.168.100.0/24 -j ACCEPT

# 拒绝其他所有入站连接
iptables -A INPUT -j DROP

# 只允许来自DMZ区的连接
iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT

# 允许访问数据库
iptables -A OUTPUT -d 192.168.2.0/24 -p tcp --dport 5432 -j ACCEPT

# 允许访问Redis
iptables -A OUTPUT -d 192.168.2.0/24 -p tcp --dport 6379 -j ACCEPT

# 允许DNS查询
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT

# 拒绝其他出站连接
iptables -A OUTPUT -j DROP

# Suricata规则示例
alert tcp any any -> $HOME_NET 443 (msg:"Suspicious HTTPS traffic"; \
    content:"POST"; http_method; content:"/api/admin"; http_uri; \
    threshold:type limit, track by_src, count 10, seconds 60; \
    sid:10001; rev:1;)

alert tcp any any -> $HOME_NET 5432 (msg:"Direct database access attempt"; \
    content:"SELECT"; content:"FROM"; distance:0; \
    sid:10002; rev:1;)

alert tcp any any -> $HOME_NET any (msg:"Brute force attack detected"; \
    flags:S; threshold:type threshold, track by_src, count 100, seconds 60; \
    sid:10003; rev:1;)

-- 客户敏感信息表(机密级)
CREATE TABLE water_customer_sensitive (
    id SERIAL PRIMARY KEY,
    customer_id BIGINT NOT NULL,
    -- 身份证号：强加密存储
    id_card_encrypted VARCHAR(200) ENCRYPTED WITH (
        COLUMN_ENCRYPTION_KEY = customer_sensitive_key,
        ENCRYPTION_TYPE = RANDOMIZED,
        ALGORITHM = 'SM4-CTR'
    ),
    -- 银行卡号：强加密存储
    bank_account_encrypted VARCHAR(200) ENCRYPTED WITH (
        COLUMN_ENCRYPTION_KEY = customer_sensitive_key,
        ENCRYPTION_TYPE = RANDOMIZED,
        ALGORITHM = 'SM4-CTR'
    ),
    -- 手机号：确定性加密，支持查询
    phone_encrypted VARCHAR(200) ENCRYPTED WITH (
        COLUMN_ENCRYPTION_KEY = customer_sensitive_key,
        ENCRYPTION_TYPE = DETERMINISTIC,
        ALGORITHM = 'SM4-CTR'
    ),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 创建行级安全策略
CREATE POLICY customer_sensitive_policy ON water_customer_sensitive
FOR ALL TO water_customer_service_role
USING (
    customer_id IN (
        SELECT customer_id FROM water_customer 
        WHERE tenant_id = current_setting('app.current_tenant_id')::bigint
    )
);

#!/bin/bash
# OpenGauss安全备份脚本

# 设置备份参数
BACKUP_DIR="/backup/opengauss"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="water_biz_backup_${DATE}.tar.gz"
ENCRYPT_KEY="/etc/opengauss/backup_key.key"

# 创建加密备份
gs_backup -D $GAUSSDATA -U gaussdb \
    --encrypt --encrypt-key-file=$ENCRYPT_KEY \
    --backup-format=tar \
    --backup-path=$BACKUP_DIR/$BACKUP_FILE

# 验证备份完整性
openssl dgst -sm3 $BACKUP_DIR/$BACKUP_FILE > $BACKUP_DIR/$BACKUP_FILE.sm3

# 安全传输到异地备份中心
rsync -avz --delete $BACKUP_DIR/ backup-server:/backup/remote/

-- 恢复前验证备份完整性
-- 1. 验证SM3摘要
-- 2. 解密备份文件
-- 3. 验证数据库结构
-- 4. 执行恢复操作

-- 创建恢复测试环境
CREATE DATABASE water_biz_recovery_test;

-- 恢复数据到测试环境
-- 执行恢复SQL脚本
\i /backup/water_biz_recovery.sql;

-- 验证数据完整性
SELECT COUNT(*) FROM water_customer;
SELECT COUNT(*) FROM water_meter_reading;
SELECT COUNT(*) FROM water_billing;

-- 验证加密数据
SELECT id, 
       pgp_sym_decrypt(id_card_encrypted, 'encryption_key') as id_card
FROM water_customer_sensitive LIMIT 1;

-- 创建安全数据销毁函数
CREATE OR REPLACE FUNCTION secure_data_destroy(table_name TEXT, where_clause TEXT)
RETURNS BOOLEAN AS $$
DECLARE
    sql_cmd TEXT;
    affected_rows INTEGER;
BEGIN
    -- 构建删除SQL
    sql_cmd := 'DELETE FROM ' || table_name || ' WHERE ' || where_clause;
    
    -- 执行删除
    EXECUTE sql_cmd;
    GET DIAGNOSTICS affected_rows = ROW_COUNT;
    
    -- 记录审计日志
    INSERT INTO data_destroy_audit (
        table_name, where_clause, affected_rows, 
        operator, operation_time
    ) VALUES (
        table_name, where_clause, affected_rows,
        current_user, current_timestamp
    );
    
    -- 执行VACUUM清理物理空间
    EXECUTE 'VACUUM FULL ' || table_name;
    
    RETURN TRUE;
EXCEPTION
    WHEN OTHERS THEN
        RAISE EXCEPTION '数据销毁失败: %', SQLERRM;
        RETURN FALSE;
END;
$$ LANGUAGE plpgsql;

-- 示例：销毁3年前的历史数据
SELECT secure_data_destroy(
    'water_meter_reading_history',
    'reading_date < CURRENT_DATE - INTERVAL ''3 years'''
);

# 安全事件检测规则配置
security_rules:
  - name: "暴力破解检测"
    type: "authentication"
    condition: "failed_login_count > 5 in 5 minutes"
    severity: "high"
    action: ["block_ip", "send_alert"]
    
  - name: "异常数据访问"
    type: "data_access"
    condition: "query_count > 1000 in 1 minute"
    severity: "medium"
    action: ["rate_limit", "send_alert"]
    
  - name: "权限提升检测"
    type: "privilege_escalation"
    condition: "role_change to admin"
    severity: "critical"
    action: ["block_user", "send_alert", "create_incident"]
    
  - name: "异常时间访问"
    type: "abnormal_access"
    condition: "access_time between 22:00 and 06:00"
    severity: "medium"
    action: ["log_event", "send_alert"]

#!/bin/bash
# 系统漏洞扫描脚本

# 扫描操作系统漏洞
nmap -sV --script vulners localhost

# 扫描Web应用漏洞
nikto -h https://water.example.com -ssl

# 扫描数据库漏洞
nmap -p 5432 --script pgsql-brute,pgsql-databases localhost

# 生成漏洞报告
cat > vulnerability_report.html << EOF
<!DOCTYPE html>
<html>
<head>
    <title>安全漏洞扫描报告</title>
</head>
<body>
    <h1>福建水务营收系统漏洞扫描报告</h1>
    <p>扫描时间：$(date)</p>
    <h2>高危漏洞</h2>
    <pre>$(grep -i "high\|critical" scan_results.txt)</pre>
    <h2>中危漏洞</h2>
    <pre>$(grep -i "medium" scan_results.txt)</pre>
</body>
</html>
EOF