timsquad 3.3.0 → 3.4.0

package/templates/base/skills/mobile/flutter/security/rules/data-protection.md

@@ -0,0 +1,271 @@
+---
+title: Data Protection
+impact: MEDIUM
+impactDescription: "미적용 → 로컬 DB 평문 노출, 스크린샷 유출, 클립보드 탈취"
+tags: encryption, sqlcipher, screenshot, clipboard, flag-secure, screen-blur
+---
+
+## Data Protection
+
+**Impact: MEDIUM (미적용 → 로컬 DB 평문 노출, 스크린샷 유출, 클립보드 탈취)**
+
+로컬 데이터 암호화, 클립보드 보호, 스크린샷 방지, 백그라운드 스크린 블러.
+저장 데이터와 화면 노출 보호.
+
+### 의존성
+
+```yaml
+# pubspec.yaml
+dependencies:
+  encrypt: ^5.0.3           # AES/RSA 암호화
+  sqflite_sqlcipher: ^3.1.0  # SQLCipher (암호화된 SQLite)
+  # 또는 sqflite + 수동 암호화
+```
+
+### 로컬 DB 암호화 (SQLCipher)
+
+**Incorrect (평문 SQLite):**
+```dart
+// 기본 sqflite → 평문 저장
+// 루팅 기기에서 DB 파일 복사 → SQLite 브라우저로 열람
+final db = await openDatabase('app.db');
+await db.insert('users', {'name': '홍길동', 'phone': '010-1234-5678'});
+// → /data/data/com.app/databases/app.db 평문
+```
+
+**Correct (SQLCipher 암호화):**
+```dart
+import 'package:sqflite_sqlcipher/sqflite.dart';
+
+class EncryptedDatabase {
+  static Database? _db;
+
+  /// 암호화된 DB 열기
+  static Future<Database> getInstance() async {
+    if (_db != null) return _db!;
+
+    // DB 암호화 키 — flutter_secure_storage에서 가져오기
+    final storage = const FlutterSecureStorage();
+    var dbKey = await storage.read(key: 'db_encryption_key');
+
+    if (dbKey == null) {
+      // 최초 실행: 랜덤 키 생성 후 안전 저장
+      dbKey = _generateRandomKey();
+      await storage.write(key: 'db_encryption_key', value: dbKey);
+    }
+
+    _db = await openDatabase(
+      'app_encrypted.db',
+      password: dbKey, // SQLCipher 암호화 키
+      version: 1,
+      onCreate: (db, version) async {
+        await db.execute('''
+          CREATE TABLE users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            phone TEXT,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+          )
+        ''');
+      },
+    );
+
+    return _db!;
+  }
+
+  static String _generateRandomKey() {
+    final random = Random.secure();
+    final bytes = List<int>.generate(32, (_) => random.nextInt(256));
+    return base64Encode(bytes);
+  }
+}
+```
+
+### 필드 레벨 암호화 (encrypt 패키지)
+
+```dart
+import 'package:encrypt/encrypt.dart' as encrypt;
+
+class FieldEncryption {
+  late final encrypt.Encrypter _encrypter;
+  late final encrypt.IV _iv;
+
+  FieldEncryption({required String key}) {
+    // AES-256 키 (32바이트)
+    final aesKey = encrypt.Key.fromUtf8(key.padRight(32).substring(0, 32));
+    _iv = encrypt.IV.fromLength(16);
+    _encrypter = encrypt.Encrypter(encrypt.AES(aesKey));
+  }
+
+  /// 민감 필드 암호화
+  String encryptField(String plaintext) {
+    return _encrypter.encrypt(plaintext, iv: _iv).base64;
+  }
+
+  /// 복호화
+  String decryptField(String encrypted) {
+    return _encrypter.decrypt64(encrypted, iv: _iv);
+  }
+}
+
+// 사용 예시
+final encryption = FieldEncryption(key: await getEncryptionKey());
+final encryptedPhone = encryption.encryptField('010-1234-5678');
+// DB에 암호화된 값 저장
+await db.insert('users', {'phone': encryptedPhone});
+```
+
+### 스크린샷 방지
+
+```dart
+/// Android: FLAG_SECURE 설정
+/// iOS: 화면 캡처 감지 + 오버레이
+class ScreenshotProtection {
+
+  /// Android: FLAG_SECURE (스크린샷 + 화면 녹화 차단)
+  static Future<void> enableAndroid() async {
+    if (Platform.isAndroid) {
+      // MethodChannel로 네이티브 호출
+      const channel = MethodChannel('com.app/security');
+      await channel.invokeMethod('enableSecureFlag');
+    }
+  }
+
+  static Future<void> disableAndroid() async {
+    if (Platform.isAndroid) {
+      const channel = MethodChannel('com.app/security');
+      await channel.invokeMethod('disableSecureFlag');
+    }
+  }
+}
+
+// Android 네이티브 (MainActivity.kt)
+// class MainActivity: FlutterActivity() {
+//   override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+//     super.configureFlutterEngine(flutterEngine)
+//     MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.app/security")
+//       .setMethodCallHandler { call, result ->
+//         when (call.method) {
+//           "enableSecureFlag" -> {
+//             window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+//             result.success(null)
+//           }
+//           "disableSecureFlag" -> {
+//             window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+//             result.success(null)
+//           }
+//         }
+//       }
+//   }
+// }
+```
+
+### 백그라운드 스크린 블러
+
+```dart
+/// 앱 백그라운드 진입 시 민감 화면 가리기 (앱 스위처에서 노출 방지)
+class AppLifecycleObserver extends WidgetsBindingObserver {
+  final GlobalKey<NavigatorState> navigatorKey;
+  OverlayEntry? _overlayEntry;
+
+  AppLifecycleObserver({required this.navigatorKey});
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    switch (state) {
+      case AppLifecycleState.inactive:
+      case AppLifecycleState.paused:
+        // 앱 스위처에 표시될 때 오버레이
+        _showSecurityOverlay();
+      case AppLifecycleState.resumed:
+        _removeSecurityOverlay();
+      default:
+        break;
+    }
+  }
+
+  void _showSecurityOverlay() {
+    _overlayEntry = OverlayEntry(
+      builder: (_) => Container(
+        color: Colors.white, // 또는 앱 로고가 있는 스플래시
+        child: const Center(child: FlutterLogo(size: 100)),
+      ),
+    );
+    navigatorKey.currentState?.overlay?.insert(_overlayEntry!);
+  }
+
+  void _removeSecurityOverlay() {
+    _overlayEntry?.remove();
+    _overlayEntry = null;
+  }
+}
+```
+
+### 클립보드 보호
+
+```dart
+/// 민감 데이터 복사 후 자동 클리어
+class ClipboardProtection {
+  static Timer? _clearTimer;
+
+  /// 민감 데이터를 클립보드에 복사 + 자동 클리어
+  static Future<void> copyWithAutoClean(
+    String data, {
+    Duration clearAfter = const Duration(seconds: 30),
+  }) async {
+    await Clipboard.setData(ClipboardData(text: data));
+
+    _clearTimer?.cancel();
+    _clearTimer = Timer(clearAfter, () async {
+      // 클립보드 비우기
+      await Clipboard.setData(const ClipboardData(text: ''));
+    });
+  }
+
+  /// 즉시 클립보드 클리어
+  static Future<void> clearNow() async {
+    _clearTimer?.cancel();
+    await Clipboard.setData(const ClipboardData(text: ''));
+  }
+}
+```
+
+### 안전한 텍스트 입력
+
+```dart
+/// 민감 입력 필드 (비밀번호, PIN)
+class SecureTextField extends StatelessWidget {
+  final TextEditingController controller;
+  final String label;
+
+  const SecureTextField({
+    super.key,
+    required this.controller,
+    required this.label,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return TextField(
+      controller: controller,
+      obscureText: true,
+      enableSuggestions: false,     // 자동 완성 비활성화
+      autocorrect: false,           // 자동 수정 비활성화
+      enableIMEPersonalizedLearning: false, // 키보드 학습 비활성화
+      decoration: InputDecoration(labelText: label),
+    );
+  }
+}
+```
+
+### 규칙
+
+- 로컬 DB 민감 데이터 → SQLCipher 또는 필드 레벨 암호화
+- DB 암호화 키 → `flutter_secure_storage`에 저장 (코드 하드코딩 금지)
+- 최초 실행 → 랜덤 키 생성 후 안전 저장소에 보관
+- 스크린샷 방지 → Android `FLAG_SECURE`, iOS 오버레이 방식
+- 민감 화면만 선별 적용 (전체 앱 적용 시 UX 저하)
+- 앱 백그라운드 → 스크린 블러/오버레이 (앱 스위처 노출 방지)
+- 클립보드 → 민감 데이터 복사 후 30초 내 자동 클리어
+- 비밀번호/PIN 입력 → `enableSuggestions: false` + `autocorrect: false`
+- `enableIMEPersonalizedLearning: false` → 키보드 학습에 민감 입력 미포함

package/templates/base/skills/mobile/flutter/security/rules/obfuscation.md

@@ -0,0 +1,213 @@
+---
+title: Code Obfuscation
+impact: HIGH
+impactDescription: "미적용 → 앱 디컴파일 시 비즈니스 로직/API 엔드포인트 노출"
+tags: obfuscation, proguard, r8, dsym, split-debug-info, crashlytics
+---
+
+## Code Obfuscation
+
+**Impact: HIGH (미적용 → 앱 디컴파일 시 비즈니스 로직/API 엔드포인트 노출)**
+
+Dart 난독화, Android ProGuard/R8 shrinking, iOS dSYM 관리,
+Crashlytics 디버그 심볼 업로드. 릴리즈 빌드 보호.
+
+### Dart 난독화
+
+**Incorrect (난독화 없이 릴리즈 빌드):**
+```bash
+flutter build apk --release
+# → Dart 코드 디컴파일 시 함수명/클래스명 그대로 노출
+# → 비즈니스 로직, API 엔드포인트, 검증 로직 분석 가능
+```
+
+**Correct (난독화 + 디버그 심볼 분리):**
+```bash
+# APK (Android)
+flutter build apk --release \
+  --obfuscate \
+  --split-debug-info=build/debug-info/android
+
+# App Bundle (Android — Play Store 권장)
+flutter build appbundle --release \
+  --obfuscate \
+  --split-debug-info=build/debug-info/android
+
+# iOS
+flutter build ipa --release \
+  --obfuscate \
+  --split-debug-info=build/debug-info/ios
+
+# --obfuscate: Dart 심볼 이름 난독화 (클래스, 함수, 변수명)
+# --split-debug-info: 디버그 심볼을 별도 디렉토리에 분리 (크래시 분석용)
+```
+
+### 디버그 심볼 보관
+
+```bash
+# 디버그 심볼 구조
+build/debug-info/
+├── android/
+│   ├── app.android-arm.symbols    # ARM32
+│   ├── app.android-arm64.symbols  # ARM64
+│   └── app.android-x64.symbols    # x86_64
+└── ios/
+    └── app.ios-arm64.symbols      # iOS ARM64
+
+# 버전별 보관 (크래시 리포트 해석에 필수)
+# CI/CD에서 자동 아카이브 권장
+mkdir -p symbols/v1.2.3
+cp -r build/debug-info/* symbols/v1.2.3/
+```
+
+### Android ProGuard/R8
+
+```groovy
+// android/app/build.gradle
+android {
+    buildTypes {
+        release {
+            // R8 (ProGuard 후속) — 코드 축소 + 난독화
+            minifyEnabled true
+            shrinkResources true
+
+            proguardFiles(
+                getDefaultProguardFile('proguard-android-optimize.txt'),
+                'proguard-rules.pro'
+            )
+        }
+    }
+}
+```
+
+```
+# android/app/proguard-rules.pro
+
+# Flutter 관련 유지
+-keep class io.flutter.** { *; }
+-keep class io.flutter.plugins.** { *; }
+
+# firebase_messaging 관련
+-keep class com.google.firebase.messaging.** { *; }
+
+# flutter_secure_storage 관련
+-keep class com.it_nomads.fluttersecurestorage.** { *; }
+
+# Gson / JSON 직렬화 (사용 시)
+-keep class * implements com.google.gson.TypeAdapterFactory
+-keep class * implements com.google.gson.JsonSerializer
+-keep class * implements com.google.gson.JsonDeserializer
+
+# Crashlytics
+-keepattributes SourceFile,LineNumberTable
+-keep public class * extends java.lang.Exception
+```
+
+### iOS dSYM
+
+```bash
+# Xcode → Build Settings
+# DEBUG_INFORMATION_FORMAT = dwarf-with-dsym (Release)
+# STRIP_SWIFT_SYMBOLS = YES
+
+# dSYM 위치 (Xcode 빌드 후)
+# ~/Library/Developer/Xcode/DerivedData/Runner-xxx/Build/Products/Release-iphoneos/Runner.app.dSYM
+
+# Archive 빌드 시 자동 포함
+# Xcode → Product → Archive → dSYM 포함
+```
+
+### Crashlytics 심볼 업로드
+
+```yaml
+# pubspec.yaml
+dependencies:
+  firebase_crashlytics: ^4.1.0
+```
+
+```bash
+# Dart 난독화 심볼 업로드
+firebase crashlytics:symbols:upload \
+  --app=1:123456:android:abcdef \
+  build/debug-info/android/
+
+# iOS dSYM 업로드 (Fastlane 사용 시)
+# fastlane에서 자동 업로드 설정 또는:
+firebase crashlytics:symbols:upload \
+  --app=1:123456:ios:abcdef \
+  build/debug-info/ios/
+```
+
+```dart
+// Crashlytics 초기화 (main.dart)
+Future<void> main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await Firebase.initializeApp();
+
+  // Crashlytics 에러 핸들링
+  FlutterError.onError = FirebaseCrashlytics.instance.recordFlutterFatalError;
+
+  // 비동기 에러
+  PlatformDispatcher.instance.onError = (error, stack) {
+    FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
+    return true;
+  };
+
+  runApp(const ProviderScope(child: MyApp()));
+}
+```
+
+### CI/CD 통합
+
+```yaml
+# GitHub Actions 예시
+- name: Build Release APK
+  run: |
+    flutter build apk --release \
+      --obfuscate \
+      --split-debug-info=build/debug-info/android \
+      --dart-define=API_KEY=${{ secrets.API_KEY }}
+
+- name: Upload debug symbols to Crashlytics
+  run: |
+    firebase crashlytics:symbols:upload \
+      --app=${{ secrets.FIREBASE_APP_ID_ANDROID }} \
+      build/debug-info/android/
+
+- name: Archive debug symbols
+  uses: actions/upload-artifact@v4
+  with:
+    name: debug-symbols-${{ github.sha }}
+    path: build/debug-info/
+    retention-days: 90
+```
+
+### 난독화 효과 확인
+
+```bash
+# 난독화 전 (디컴파일 시)
+class UserRepository {
+  Future<User> fetchUserProfile(String userId) async { ... }
+  Future<void> updatePaymentMethod(PaymentCard card) async { ... }
+}
+
+# 난독화 후 (디컴파일 시)
+class a {
+  Future<b> c(String d) async { ... }
+  Future<void> e(f g) async { ... }
+}
+# → 함수명/클래스명만 난독화, 문자열 리터럴은 그대로
+# → API 키/URL은 별도 보호 필요 (envied obfuscate 등)
+```
+
+### 규칙
+
+- 릴리즈 빌드 → `--obfuscate --split-debug-info=<path>` 필수
+- `--split-debug-info` → 버전별 보관 (크래시 리포트 해석에 필수)
+- Android → `minifyEnabled true` + `shrinkResources true` (R8)
+- `proguard-rules.pro` → Flutter/Firebase/보안 라이브러리 keep 규칙
+- iOS → `DEBUG_INFORMATION_FORMAT = dwarf-with-dsym` (Release)
+- Crashlytics → 난독화 심볼 업로드 필수 (미업로드 시 크래시 로그 해석 불가)
+- CI/CD → 심볼 아카이브 (최소 90일 보관)
+- 문자열 리터럴 → 난독화 대상 아님 → API 키는 `envied obfuscate` 별도 처리
+- 디버그 빌드 → 난독화 적용하지 않음 (개발 생산성)

package/templates/base/skills/mobile/flutter/security/rules/secure-storage.md

@@ -0,0 +1,171 @@
+---
+title: Secure Storage
+impact: CRITICAL
+impactDescription: "평문 저장 → 루팅/탈옥 시 토큰/시크릿 탈취, 계정 도용"
+tags: flutter_secure_storage, keychain, encrypted-shared-preferences, token
+---
+
+## Secure Storage
+
+**Impact: CRITICAL (평문 저장 → 루팅/탈옥 시 토큰/시크릿 탈취, 계정 도용)**
+
+flutter_secure_storage를 사용한 민감 데이터 안전 저장.
+iOS Keychain / Android EncryptedSharedPreferences 기반.
+
+### 의존성
+
+```yaml
+# pubspec.yaml
+dependencies:
+  flutter_secure_storage: ^9.2.0
+```
+
+### 기본 사용
+
+**Incorrect (SharedPreferences에 토큰 저장):**
+```dart
+// SharedPreferences → 평문 XML/plist 파일
+// 루팅된 기기에서 파일 탐색기로 즉시 열람 가능
+final prefs = await SharedPreferences.getInstance();
+await prefs.setString('access_token', token);
+await prefs.setString('refresh_token', refreshToken);
+// → /data/data/com.app/shared_prefs/ 에 평문 저장
+```
+
+**Correct (flutter_secure_storage 사용):**
+```dart
+class SecureStorageService {
+  final FlutterSecureStorage _storage;
+
+  SecureStorageService()
+      : _storage = const FlutterSecureStorage(
+          aOptions: AndroidOptions(
+            encryptedSharedPreferences: true, // EncryptedSharedPreferences 사용
+          ),
+          iOptions: IOSOptions(
+            accessibility: KeychainAccessibility.first_unlock_this_device,
+          ),
+        );
+
+  // === 토큰 관리 ===
+
+  Future<void> saveTokens({
+    required String accessToken,
+    required String refreshToken,
+  }) async {
+    await Future.wait([
+      _storage.write(key: _Keys.accessToken, value: accessToken),
+      _storage.write(key: _Keys.refreshToken, value: refreshToken),
+    ]);
+  }
+
+  Future<String?> getAccessToken() async {
+    return _storage.read(key: _Keys.accessToken);
+  }
+
+  Future<String?> getRefreshToken() async {
+    return _storage.read(key: _Keys.refreshToken);
+  }
+
+  Future<void> deleteTokens() async {
+    await Future.wait([
+      _storage.delete(key: _Keys.accessToken),
+      _storage.delete(key: _Keys.refreshToken),
+    ]);
+  }
+
+  /// 로그아웃 시 모든 민감 데이터 삭제
+  Future<void> clearAll() async {
+    await _storage.deleteAll();
+  }
+}
+
+abstract class _Keys {
+  static const accessToken = 'access_token';
+  static const refreshToken = 'refresh_token';
+  static const userPin = 'user_pin_hash';
+  static const biometricEnabled = 'biometric_enabled';
+}
+```
+
+### Android 설정
+
+```kotlin
+// android/app/build.gradle
+android {
+    defaultConfig {
+        minSdk 23  // EncryptedSharedPreferences 최소 요구
+    }
+}
+```
+
+```xml
+<!-- AndroidManifest.xml (선택: 백업에서 Keystore 제외) -->
+<application
+  android:fullBackupContent="@xml/backup_rules"
+  android:dataExtractionRules="@xml/data_extraction_rules">
+</application>
+
+<!-- res/xml/backup_rules.xml -->
+<!-- <exclude domain="sharedpref" path="FlutterSecureStorage"/> -->
+```
+
+### iOS 설정
+
+```dart
+// Keychain Accessibility 옵션
+const iOptions = IOSOptions(
+  // 기기 잠금 해제 후 접근 가능 (기기 바인딩)
+  accessibility: KeychainAccessibility.first_unlock_this_device,
+  // iCloud Keychain 동기화 비활성화 (기기 전용)
+  synchronizable: false,
+);
+
+// Keychain Accessibility 레벨:
+// - first_unlock_this_device: 기기 첫 잠금 해제 후 접근 (권장)
+// - unlocked_this_device: 잠금 해제 상태에서만 접근 (더 엄격)
+// - first_unlock: iCloud 동기화 가능 (덜 안전)
+// - passcode: 패스코드 설정된 기기에서만
+```
+
+### Riverpod Provider 구성
+
+```dart
+final secureStorageServiceProvider = Provider<SecureStorageService>((ref) {
+  return SecureStorageService();
+});
+
+/// 토큰 존재 여부 (인증 상태 판단)
+final hasValidTokenProvider = FutureProvider<bool>((ref) async {
+  final storage = ref.watch(secureStorageServiceProvider);
+  final token = await storage.getAccessToken();
+  return token != null;
+});
+```
+
+### 저장해야 할 것 vs 하지 말아야 할 것
+
+```
+✅ flutter_secure_storage 저장 대상:
+  - Access Token / Refresh Token
+  - API 시크릿 (런타임 주입된)
+  - 사용자 PIN 해시
+  - 생체 인증 활성화 플래그
+  - 암호화 키 (DB 암호화용)
+
+❌ flutter_secure_storage에 저장하지 말 것:
+  - 대량 데이터 (성능 저하) → 암호화된 DB 사용
+  - 사용자 설정 (테마, 언어) → SharedPreferences OK
+  - 캐시 데이터 → 일반 파일 시스템
+  - 검색이 필요한 데이터 → DB 사용
+```
+
+### 규칙
+
+- 토큰/시크릿 → `flutter_secure_storage` 필수 (SharedPreferences 금지)
+- Android → `encryptedSharedPreferences: true` 설정 (AES-256 암호화)
+- iOS → `KeychainAccessibility.first_unlock_this_device` (기기 바인딩)
+- iOS → `synchronizable: false` (iCloud 동기화 비활성화)
+- 로그아웃 시 → `deleteAll()` 로 모든 민감 데이터 삭제
+- 대량 데이터 → secure_storage 대신 암호화된 DB (SQLCipher) 사용
+- 앱 재설치 시 → Android Keystore 자동 초기화, iOS Keychain 잔존 가능 → 첫 실행 시 정리 로직