-- ❌ 이렇게 하면 절대 안 됨 (root 계정 직접 사용)
-- 앱에서 root로 DB 연결하는 건 자살행위임 ㄹㅇ

-- ✅ 올바른 방법: 역할별 계정 분리

-- 1. 읽기 전용 계정 (조회 API용)
CREATE USER 'app_reader'@'192.168.1.%' IDENTIFIED BY '강력한패스워드!@#';
GRANT SELECT ON myapp_db.* TO 'app_reader'@'192.168.1.%';

-- 2. 쓰기 계정 (일반 앱 서비스용)
CREATE USER 'app_writer'@'192.168.1.%' IDENTIFIED BY '다른강력한패스워드!@#';
GRANT SELECT, INSERT, UPDATE ON myapp_db.* TO 'app_writer'@'192.168.1.%';
-- DELETE는 주지 않음! 실수로 데이터 날리는 거 방지

-- 3. 배치 작업용 계정 (특정 테이블만)
CREATE USER 'batch_user'@'localhost' IDENTIFIED BY '배치전용패스워드!@#';
GRANT SELECT, INSERT ON myapp_db.batch_logs TO 'batch_user'@'localhost';
GRANT SELECT ON myapp_db.users TO 'batch_user'@'localhost';

-- 4. 마이그레이션/배포용 계정 (임시, 작업 후 삭제)
CREATE USER 'deploy_user'@'localhost' IDENTIFIED BY '임시패스워드!@#';
GRANT ALTER, CREATE, DROP, INDEX ON myapp_db.* TO 'deploy_user'@'localhost';
-- 배포 완료 후: DROP USER 'deploy_user'@'localhost';

-- 권한 적용
FLUSH PRIVILEGES;

-- 현재 권한 확인
SHOW GRANTS FOR 'app_writer'@'192.168.1.%';

-- 특정 컬럼만 조회 가능하게 설정
GRANT SELECT (user_id, username, email, created_at) 
ON myapp_db.users 
TO 'app_reader'@'192.168.1.%';

-- 특정 컬럼만 업데이트 가능 (비밀번호, 이메일만 수정 가능)
GRANT UPDATE (password_hash, email, updated_at) 
ON myapp_db.users 
TO 'app_writer'@'192.168.1.%';

-- 민감 컬럼(주민번호, 카드번호 등)은 아예 접근 불가
-- ssn, card_number 컬럼은 권한 목록에서 제외!

-- 특정 권한 회수
REVOKE DELETE ON myapp_db.* FROM 'app_writer'@'192.168.1.%';

-- 모든 권한 회수
REVOKE ALL PRIVILEGES ON myapp_db.* FROM 'old_user'@'localhost';

-- 계정 완전 삭제
DROP USER 'old_user'@'localhost';

-- 권한 변경 후 반드시 적용
FLUSH PRIVILEGES;

-- 역할(Role) 생성 - 권한 묶음
CREATE ROLE readonly_role;
CREATE ROLE readwrite_role;
CREATE ROLE admin_role;

-- readonly_role에 권한 부여
GRANT CONNECT ON DATABASE myapp_db TO readonly_role;
GRANT USAGE ON SCHEMA public TO readonly_role;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly_role;
-- 앞으로 생성될 테이블에도 자동 적용
ALTER DEFAULT PRIVILEGES IN SCHEMA public 
  GRANT SELECT ON TABLES TO readonly_role;

-- readwrite_role에 권한 부여
GRANT readonly_role TO readwrite_role; -- readonly 권한 상속
GRANT INSERT, UPDATE ON ALL TABLES IN SCHEMA public TO readwrite_role;
ALTER DEFAULT PRIVILEGES IN SCHEMA public 
  GRANT INSERT, UPDATE ON TABLES TO readwrite_role;

-- 실제 사용자 계정 생성 및 역할 부여
CREATE USER app_service WITH PASSWORD '강력한패스워드!@#';
GRANT readwrite_role TO app_service;

CREATE USER report_service WITH PASSWORD '다른패스워드!@#';
GRANT readonly_role TO report_service;

-- 특정 테이블만 접근 가능한 계정
CREATE USER log_service WITH PASSWORD '로그패스워드!@#';
GRANT CONNECT ON DATABASE myapp_db TO log_service;
GRANT USAGE ON SCHEMA public TO log_service;
GRANT SELECT, INSERT ON TABLE app_logs TO log_service;

-- RLS 활성화
ALTER TABLE user_data ENABLE ROW LEVEL SECURITY;

-- 정책 생성: 자기 데이터만 볼 수 있음
CREATE POLICY user_isolation_policy ON user_data
  USING (user_id = current_user::integer);

-- 관리자는 모든 데이터 접근 가능
CREATE POLICY admin_all_policy ON user_data
  TO admin_role
  USING (true);

-- 특정 조건의 데이터만 INSERT 가능
CREATE POLICY insert_own_data ON user_data
  FOR INSERT
  WITH CHECK (user_id = current_user::integer);

-- 현재 사용자 권한 확인
\dp  -- psql에서 테이블 권한 목록

-- 특정 테이블 권한 확인
SELECT grantee, privilege_type, is_grantable
FROM information_schema.role_table_grants
WHERE table_name = 'users';

-- 역할 멤버십 확인
SELECT r.rolname, m.rolname as member
FROM pg_roles r
JOIN pg_auth_members am ON r.oid = am.roleid
JOIN pg_roles m ON am.member = m.oid
ORDER BY r.rolname;

# 서비스 전용 계정 생성 (로그인 불가 계정)
sudo useradd -r -s /bin/false -d /var/lib/myapp myapp_service
# -r: 시스템 계정
# -s /bin/false: 쉘 로그인 불가
# -d: 홈 디렉토리 지정

# 개발자 계정 생성
sudo useradd -m -s /bin/bash developer1
sudo passwd developer1

# 개발자를 특정 그룹에 추가 (sudo 그룹 X, 필요한 그룹만)
sudo usermod -aG docker developer1
sudo usermod -aG www-data developer1

# SSH root 로그인 비활성화
sudo nano /etc/ssh/sshd_config
# PermitRootLogin no
# PasswordAuthentication no  (키 기반 인증만 허용)
sudo systemctl restart sshd

# /etc/sudoers.d/developer_rules 파일 생성
# (visudo 명령어로 편집하는 게 안전함)

# developer1은 nginx 재시작만 가능
developer1 ALL=(ALL) NOPASSWD: /bin/systemctl restart nginx
developer1 ALL=(ALL) NOPASSWD: /bin/systemctl reload nginx

# deploy_team 그룹은 배포 스크립트만 실행 가능
%deploy_team ALL=(ALL) NOPASSWD: /opt/scripts/deploy.sh

# 특정 사용자는 로그 파일만 볼 수 있음
logviewer ALL=(ALL) NOPASSWD: /bin/cat /var/log/nginx/*.log
logviewer ALL=(ALL) NOPASSWD: /usr/bin/tail -f /var/log/nginx/access.log

# 절대 안 되는 것들 명시적 거부
developer1 ALL=(ALL) !ALL  # 위에서 허용한 것 외엔 전부 거부

# 웹 서버 파일 권한 설정
# 소유자: root, 그룹: www-data
sudo chown -R root:www-data /var/www/myapp

# 디렉토리: 755 (소유자 rwx, 그룹 r-x, 기타 r-x)
sudo find /var/www/myapp -type d -exec chmod 755 {} \;

# 파일: 644 (소유자 rw-, 그룹 r--, 기타 r--)
sudo find /var/www/myapp -type f -exec chmod 644 {} \;

# 설정 파일 (DB 비밀번호 등): 600 (소유자만 읽기/쓰기)
sudo chmod 600 /var/www/myapp/.env
sudo chown myapp_service:myapp_service /var/www/myapp/.env

# 업로드 디렉토리: 775 (그룹 쓰기 허용)
sudo chmod 775 /var/www/myapp/uploads
sudo chown myapp_service:www-data /var/www/myapp/uploads

# SUID/SGID 비트 확인 (보안 취약점 가능성)
sudo find / -perm /4000 -type f 2>/dev/null  # SUID 파일 찾기
sudo find / -perm /2000 -type f 2>/dev/null  # SGID 파일 찾기

-- 역할 정의
CREATE ROLE viewer;      -- 조회만 가능
CREATE ROLE operator;    -- 주문 처리 가능
CREATE ROLE manager;     -- 상품 관리 가능
CREATE ROLE admin;       -- 전체 관리

-- viewer 권한
GRANT SELECT ON products, categories TO viewer;
GRANT SELECT ON orders TO viewer;

-- operator 권한 (viewer 상속)
GRANT viewer TO operator;
GRANT UPDATE (status, updated_at) ON orders TO operator;
GRANT INSERT ON order_logs TO operator;

-- manager 권한 (operator 상속)
GRANT operator TO manager;
GRANT SELECT, INSERT, UPDATE ON products TO manager;
GRANT SELECT, INSERT, UPDATE ON categories TO manager;
GRANT SELECT ON users TO manager;  -- 고객 정보 조회만

-- admin 권한 (manager 상속)
GRANT manager TO admin;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO admin;

-- 실제 사용자에게 역할 부여
CREATE USER customer_service_1 WITH PASSWORD '...';
GRANT operator TO customer_service_1;

CREATE USER product_manager_1 WITH PASSWORD '...';
GRANT manager TO product_manager_1;

# .env.production
DB_HOST=prod-db.internal
DB_PORT=3306
DB_NAME=myapp_prod
DB_USER=app_prod_writer    # 프로덕션 전용 계정
DB_PASSWORD=복잡한패스워드!@#$

# .env.development  
DB_HOST=localhost
DB_PORT=3306
DB_NAME=myapp_dev
DB_USER=app_dev_user       # 개발 전용 계정 (더 많은 권한 허용)
DB_PASSWORD=개발용패스워드

# .env.test
DB_HOST=localhost
DB_PORT=3306
DB_NAME=myapp_test
DB_USER=app_test_user      # 테스트 전용 계정
DB_PASSWORD=테스트패스워드

// Node.js 예시 - 읽기/쓰기 DB 분리
const mysql = require('mysql2/promise');

// 쓰기 전용 연결 (Master DB)
const writePool = mysql.createPool({
  host: process.env.DB_WRITE_HOST,
  user: process.env.DB_WRITE_USER,    // INSERT, UPDATE 권한만
  password: process.env.DB_WRITE_PASS,
  database: process.env.DB_NAME,
});

// 읽기 전용 연결 (Read Replica)
const readPool = mysql.createPool({
  host: process.env.DB_READ_HOST,
  user: process.env.DB_READ_USER,     // SELECT 권한만
  password: process.env.DB_READ_PASS,
  database: process.env.DB_NAME,
});

// 사용 예시
async function getUser(userId) {
  // 조회는 읽기 전용 DB 사용
  const [rows] = await readPool.execute(
    'SELECT id, username, email FROM users WHERE id = ?',
    [userId]
  );
  return rows[0];
}

async function updateUser(userId, data) {
  // 수정은 쓰기 DB 사용
  await writePool.execute(
    'UPDATE users SET email = ? WHERE id = ?',
    [data.email, userId]
  );
}

# AWS IAM 예시 - 임시 자격증명 발급
# 평소엔 읽기 권한만 있는 역할 사용
# 배포 시에만 임시로 쓰기 권한 역할 assume

# 임시 자격증명 발급 (1시간 유효)
aws sts assume-role \
  --role-arn "arn:aws:iam::123456789:role/DeployRole" \
  --role-session-name "deploy-session-$(date +%Y%m%d%H%M%S)" \
  --duration-seconds 3600

# 발급된 임시 자격증명으로 배포 작업 수행
export AWS_ACCESS_KEY_ID=임시키
export AWS_SECRET_ACCESS_KEY=임시시크릿
export AWS_SESSION_TOKEN=임시토큰

# 배포 완료 후 환경변수 제거
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN

// 서비스 간 통신 시 최소 권한 토큰 사용
// JWT 토큰에 권한 범위(scope) 명시

const jwt = require('jsonwebtoken');

// 서비스 A가 서비스 B에 요청할 때 사용하는 토큰
function generateServiceToken(serviceId, allowedScopes) {
  return jwt.sign(
    {
      sub: serviceId,
      scopes: allowedScopes,  // 허용된 작업만 명시
      iat: Math.floor(Date.now() / 1000),
      exp: Math.floor(Date.now() / 1000) + 300, // 5분만 유효
    },
    process.env.SERVICE_SECRET
  );
}

// 사용 예시
const token = generateServiceToken('order-service', [
  'users:read',        // 사용자 조회만
  'inventory:read',    // 재고 조회만
  // 'users:write' 는 포함 안 함!
]);

// 서비스 B에서 권한 검증
function checkScope(token, requiredScope) {
  const decoded = jwt.verify(token, process.env.SERVICE_SECRET);
  if (!decoded.scopes.includes(requiredScope)) {
    throw new Error(`권한 없음: ${requiredScope} 권한이 필요합니다`);
  }
  return decoded;
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowSpecificS3Actions",
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject"
      ],
      "Resource": "arn:aws:s3:::myapp-uploads/*",
      "Condition": {
        "StringEquals": {
          "s3:prefix": ["uploads/user-content/"]
        }
      }
    },
    {
      "Sid": "AllowRDSConnect",
      "Effect": "Allow",
      "Action": [
        "rds-db:connect"
      ],
      "Resource": "arn:aws:rds-db:ap-northeast-2:123456789:dbuser:db-ABCDEFG/app_writer"
    },
    {
      "Sid": "DenyDangerousActions",
      "Effect": "Deny",
      "Action": [
        "s3:DeleteBucket",
        "rds:DeleteDBInstance",
        "ec2:TerminateInstances"
      ],
      "Resource": "*"
    }
  ]
}

# Dockerfile - 최소 권한 원칙 적용
FROM node:18-alpine

# root로 실행하지 않음!
RUN addgroup -g 1001 -S appgroup && \
    adduser -u 1001 -S appuser -G appgroup

WORKDIR /app
COPY --chown=appuser:appgroup . .

RUN npm ci --only=production

# 비root 사용자로 전환
USER appuser

EXPOSE 3000
CMD ["node", "server.js"]

# Kubernetes - SecurityContext 설정
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      securityContext:
        runAsNonRoot: true      # root로 실행 금지
        runAsUser: 1001         # 특정 UID로 실행
        runAsGroup: 1001
        fsGroup: 1001
      containers:
      - name: myapp
        image: myapp:latest
        securityContext:
          allowPrivilegeEscalation: false  # 권한 상승 금지
          readOnlyRootFilesystem: true     # 루트 파일시스템 읽기 전용
          capabilities:
            drop:
            - ALL                          # 모든 Linux 기능 제거
            add:
            - NET_BIND_SERVICE             # 필요한 것만 추가
        resources:
          limits:
            cpu: "500m"
            memory: "256Mi"

# ❌ 절대 이렇게 하지 마
DB_PASSWORD=mypassword123  # .env 파일을 Git에 올리면 끝장

# ✅ 올바른 방법들

# 1. AWS Secrets Manager 사용
import boto3
import json

def get_db_credentials():
    client = boto3.client('secretsmanager', region_name='ap-northeast-2')
    response = client.get_secret_value(SecretId='myapp/prod/db')
    return json.loads(response['SecretString'])

creds = get_db_credentials()
db_password = creds['password']

# 2. HashiCorp Vault 사용
import hvac

client = hvac.Client(url='https://vault.internal:8200')
client.auth.aws.iam_login(role='myapp-role')

secret = client.secrets.kv.v2.read_secret_version(
    path='myapp/db',
    mount_point='secret'
)
db_password = secret['data']['data']['password']

# 3. Kubernetes Secrets (암호화 저장)
# kubectl create secret generic db-secret \
#   --from-literal=password=복잡한패스워드 \
#   --namespace=production

-- 현재 모든 DB 계정과 권한 파악
SELECT 
  u.user,
  u.host,
  u.password_expired,
  u.account_locked,
  GROUP_CONCAT(DISTINCT CONCAT(d.db, ':', 
    IF(d.Select_priv='Y','R',''),
    IF(d.Insert_priv='Y','I',''),
    IF(d.Update_priv='Y','U',''),
    IF(d.Delete_priv='Y','D','')
  ) SEPARATOR ' | ') as db_permissions
FROM mysql.user u
LEFT JOIN mysql.db d ON u.user = d.user AND u.host = d.host
GROUP BY u.user, u.host
ORDER BY u.user;

#!/bin/bash
# db_setup.sh - DB 계정 및 권한 자동 설정 스크립트

DB_HOST="localhost"
DB_ROOT_USER="root"
DB_ROOT_PASS="${DB_ROOT_PASSWORD}"  # 환경변수에서 읽기
APP_DB="myapp_prod"

echo "🔐 DB 권한 설정 시작..."

mysql -h "$DB_HOST" -u "$DB_ROOT_USER" -p"$DB_ROOT_PASS" << EOF

-- 기존 앱 계정 삭제 (재설정)
DROP USER IF EXISTS 'app_read'@'10.0.1.%';
DROP USER IF EXISTS 'app_write'@'10.0.1.%';

-- 읽기 전용 계정 생성
CREATE USER 'app_read'@'10.0.1.%' 
  IDENTIFIED BY '${APP_READ_PASSWORD}'
  PASSWORD EXPIRE INTERVAL 90 DAY
  FAILED_LOGIN_ATTEMPTS 5 
  PASSWORD_LOCK_TIME 1;

GRANT SELECT ON ${APP_DB}.* TO 'app_read'@'10.0.1.%';

-- 쓰기 계정 생성
CREATE USER 'app_write'@'10.0.1.%' 
  IDENTIFIED BY '${APP_WRITE_PASSWORD}'
  PASSWORD EXPIRE INTERVAL 90 DAY
  FAILED_LOGIN_ATTEMPTS 5 
  PASSWORD_LOCK_TIME 1;

GRANT SELECT, INSERT, UPDATE ON ${APP_DB}.* TO 'app_write'@'10.0.1.%';

FLUSH PRIVILEGES;

-- 설정 확인
SHOW GRANTS FOR 'app_read'@'10.0.1.%';
SHOW GRANTS FOR 'app_write'@'10.0.1.%';

EOF

echo "✅ DB 권한 설정 완료!"

# terraform/db_users.tf
# 권한 설정을 코드로 관리 → 버전 관리, 리뷰 가능

resource "mysql_user" "app_reader" {
  user               = "app_reader"
  host               = "10.0.1.%"
  plaintext_password = var.app_reader_password
}

resource "mysql_grant" "app_reader_grant" {
  user       = mysql_user.app_reader.user
  host       = mysql_user.app_reader.host
  database   = "myapp_prod"
  privileges = ["SELECT"]
}

resource "mysql_user" "app_writer" {
  user               = "app_writer"
  host               = "10.0.1.%"
  plaintext_password = var.app_writer_password
}

resource "mysql_grant" "app_writer_grant" {
  user       = mysql_user.app_writer.user
  host       = mysql_user.app_writer.host
  database   = "myapp_prod"
  privileges = ["SELECT", "INSERT", "UPDATE"]
}