🛡️ Sentinel: [CRITICAL] ERD DDL 생성 시 SQL 인젝션 방지

.jules/sentinel.md

@@ -16,3 +16,13 @@
 **Vulnerability:** A custom buffer length check (`if (signatureBytes.length !== expectedSignatureBytes.length) return false`) before calling `crypto.timingSafeEqual()` leaked the length of the expected signature, enabling timing attacks.
 **Learning:** Never use custom 'homebrew' buffer-padding logic to match lengths for `crypto.timingSafeEqual()`, as early returns leak the length of the secret.
 **Prevention:** Ensure inputs are hashed to a uniform length (e.g., using `crypto.createHash('sha256')`) before comparison.
+
+## 2025-08-04 - [DDL 생성 시 SQL 인젝션 방지]
+**Vulnerability:** ERD 도구에서 DDL을 생성할 때, 컬럼 타입 문자열에 세미콜론(;)을 포함시켜 기존 문장을 종료하고 악의적인 SQL 문(예: `DROP TABLE`)을 삽입할 수 있는 SQL 인젝션 취약점이 존재했습니다.
+**Learning:** 사용자 입력(이 경우 컬럼 타입)을 직접 연결하여 SQL 쿼리나 DDL을 생성하는 경우, 구문 종결자(Statement Terminator)를 필터링하지 않으면 데이터베이스 조작으로 이어질 수 있습니다.
+**Prevention:** DDL과 같은 동적 쿼리를 생성할 때 구문 종결자가 입력에 포함되어 있는지 확인(`assertNoStatementTerminator`)하여 악의적인 SQL 문 실행을 사전에 차단해야 합니다.
+
+## 2025-08-04 - [ERD 모델의 심화 SQL 인젝션 및 상태 조작 방지]
+**Vulnerability:** 기존의 세미콜론 검사만으로는 SQL 주석(`--`, `/*`)이나 `UNION` 공격을 통한 SQL 인젝션을 막을 수 없었으며, `getTable()` 등을 통해 내부 상태 객체가 참조로 반환되어 유효성 검사 이후에 임의로 악성 SQL을 주입(Prototype Pollution/State Manipulation)할 수 있는 취약점이 있었습니다.
+**Learning:** 내부 상태를 외부로 노출할 때 참조형 객체를 그대로 반환하면 외부에서 상태를 조작하여 모든 내부 보안 검증을 우회할 수 있습니다. 또한 SQL 인젝션은 세미콜론 외에도 주석 및 예약어(UNION 등)를 이용한 공격 경로가 존재합니다.
+**Prevention:** 컬럼 타입과 같은 사용자 입력은 엄격한 화이트리스트나 상세한 차단 목록(주석, UNION 등)으로 검증해야 하며, 객체 상태를 반환할 때는 복사본(예: 깊은 복사 `JSON.parse(JSON.stringify(obj))`)을 반환하여 내부 맵이나 속성을 직접 조작할 수 없도록 격리해야 합니다.

package.json

@@ -21,15 +21,17 @@
       "@babel/core": "7.29.7",
       "esbuild": "0.28.1",
       "js-yaml": "^4.3.0",
-      "fast-uri": "^3.1.4",
+      "fast-uri": "3.1.5",
       "@auth/core": "^0.41.3",
       "sharp": "^0.35.0",
       "postcss": "^8.5.18",
-      "hono": "^4.12.27",
-      "brace-expansion": "5.0.8",
+      "hono": "4.13.0",
+      "brace-expansion": "5.0.9",
       "minimatch": "^10.0.0",
       "@hono/node-server": "^2.0.5",
-      "body-parser": "^2.3.0"
+      "body-parser": "^2.3.0",
+      "ip-address": "10.4.0",
+      "undici": "7.29.0"
     }
   }
 }

packages/web/src/lib/erd.test.ts

@@ -13,7 +13,7 @@ describe('ERDModel', () => {
       const table = model.addTable('users')
       expect(table.name).toBe('users')
       expect(model.getTables().length).toBe(1)
-      expect(model.getTable('users')).toBe(table)
+      expect(model.getTable('users')).toStrictEqual(table)
     })
 
     it('should throw when adding duplicate table', () => {
@@ -33,6 +33,17 @@ describe('ERDModel', () => {
     it('should return undefined for non-existent table', () => {
       expect(model.getTable('non_existent')).toBeUndefined()
     })
+
+    it('should return deeply copied objects from getTable to prevent prototype pollution', () => {
+      model.addTable('users')
+      model.addColumn('users', { name: 'id', type: 'integer' })
+      const table = model.getTable('users')
+      if (table) {
+        table.columns[0].type = 'integer PRIMARY KEY; DROP TABLE users; --'
+      }
+      const unchangedTable = model.getTable('users')
+      expect(unchangedTable?.columns[0].type).toBe('integer')
+    })
   })
 
   describe('Column Management', () => {
@@ -67,6 +78,30 @@ describe('ERDModel', () => {
         model.addColumn('users', { name: 'created__at', type: 'timestamp' })
       ).toThrowError("Column 'created__at' must be snake_case.")
     })
+
+    it('should reject column types containing statement terminators', () => {
+      model.addTable('users')
+      expect(() =>
+        model.addColumn('users', { name: 'id', type: 'integer PRIMARY KEY); DROP TABLE users; --' })
+      ).toThrowError('Statement terminators are not allowed to prevent SQL injection.')
+    })
+
+    it('should reject column types containing SQL comments', () => {
+      model.addTable('users')
+      expect(() =>
+        model.addColumn('users', { name: 'id', type: 'integer PRIMARY KEY -- injected comment' })
+      ).toThrowError('SQL comments are not allowed in column types.')
+      expect(() =>
+        model.addColumn('users', { name: 'id', type: 'integer /* comment */ PRIMARY KEY' })
+      ).toThrowError('SQL comments are not allowed in column types.')
+    })
+
+    it('should reject column types containing UNION attacks', () => {
+      model.addTable('users')
+      expect(() =>
+        model.addColumn('users', { name: 'id', type: 'integer UNION SELECT password FROM users' })
+      ).toThrowError('UNION statements are not allowed in column types.')
+    })
   })
 
   describe('Foreign Key Management', () => {

packages/web/src/lib/erd.ts

@@ -25,6 +25,18 @@ function assertSnakeCaseIdentifier(kind: string, name: string): void {
   }
 }
 
+function assertValidSqlType(value: string): void {
+  if (value.includes(';')) {
+    throw new Error('Statement terminators are not allowed to prevent SQL injection.')
+  }
+  if (value.includes('--') || value.includes('/*')) {
+    throw new Error('SQL comments are not allowed in column types.')
+  }
+  if (/UNION/i.test(value)) {
+    throw new Error('UNION statements are not allowed in column types.')
+  }
+}
+
 export class ERDModel {
   private tables: Map<string, Table> = new Map()
 
@@ -39,16 +51,18 @@ export class ERDModel {
   }
 
   getTable(name: string): Table | undefined {
-    return this.tables.get(name)
+    const table = this.tables.get(name)
+    return table ? JSON.parse(JSON.stringify(table)) : undefined
   }
 
   getTables(): Table[] {
-    return Array.from(this.tables.values())
+    return Array.from(this.tables.values()).map(table => JSON.parse(JSON.stringify(table)))
   }
 
   addColumn(tableName: string, column: Column): void {
     assertSnakeCaseIdentifier('Table', tableName)
     assertSnakeCaseIdentifier('Column', column.name)
+    assertValidSqlType(column.type)
     const table = this.tables.get(tableName)
     if (!table) {
       throw new Error(`Table '${tableName}' does not exist.`)