Keychain과 Keystore: 장기 인증 정보는 왜 일반 저장소와 분리하는가

일반 영속 저장소   앱 설정·캐시·사용자 초안처럼 비밀이 아닌 값
iOS Keychain      작은 비밀값 자체를 암호화된 Keychain 항목으로 저장
Android Keystore  token을 보호할 암호화 키를 추출하기 어렵게 관리
앱 실행 중        허용된 조회 뒤 받은 token 원문을 다시 노출하지 않음

npm install @react-native-async-storage/[email protected] [email protected]
cd ios
bundle exec pod install
cd ..

npm run android
npm run ios

import React, { useState } from 'react'
import {
  Button,
  Platform,
  SafeAreaView,
  StyleSheet,
  Text,
  View,
} from 'react-native'
import AsyncStorage from '@react-native-async-storage/async-storage'
import * as Keychain from 'react-native-keychain'
 
const USE_SECURE_STORAGE = false
const DEMO_REFRESH_TOKEN = 'demo-refresh-token-not-a-secret'
const GENERAL_KEY = '@auth/refresh-token'
const SECURE_SERVICE = 'com.example.rnwebboundary.refresh-token'
 
const SECURE_SET_OPTIONS =
  Platform.OS === 'ios'
    ? {
        service: SECURE_SERVICE,
        accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
      }
    : {
        service: SECURE_SERVICE,
        securityLevel: Keychain.SECURITY_LEVEL.SECURE_SOFTWARE,
      }
 
type Evidence = {
  generalHasPlaintext: boolean
  secureHasCredential: boolean
}
 
async function inspectStorage(): Promise<Evidence> {
  const [generalValue, secureValue] = await Promise.all([
    AsyncStorage.getItem(GENERAL_KEY),
    Keychain.getGenericPassword({ service: SECURE_SERVICE }),
  ])
 
  return {
    generalHasPlaintext: generalValue === DEMO_REFRESH_TOKEN,
    secureHasCredential:
      secureValue !== false &&
      secureValue.username === 'refresh-token' &&
      secureValue.password === DEMO_REFRESH_TOKEN,
  }
}
 
export default function App() {
  const [status, setStatus] = useState('아직 실행하지 않음')
  const [evidence, setEvidence] = useState<Evidence | null>(null)
  const [busy, setBusy] = useState(false)
 
  async function run(action: () => Promise<void>) {
    setBusy(true)
    setStatus('실행 중')
 
    try {
      await action()
    } catch {
      setStatus('저장소 작업 오류')
    } finally {
      setBusy(false)
    }
  }
 
  async function resetFixture() {
    await run(async () => {
      await AsyncStorage.removeItem(GENERAL_KEY)
      await Keychain.resetGenericPassword({ service: SECURE_SERVICE })
      setEvidence(await inspectStorage())
      setStatus('두 저장소 초기화 완료')
    })
  }
 
  async function saveFixture() {
    await run(async () => {
      if (USE_SECURE_STORAGE) {
        const saved = await Keychain.setGenericPassword(
          'refresh-token',
          DEMO_REFRESH_TOKEN,
          SECURE_SET_OPTIONS,
        )
 
        if (saved === false) {
          throw new Error('secure storage write failed')
        }
 
        const verified = await Keychain.getGenericPassword({
          service: SECURE_SERVICE,
        })
 
        if (
          verified === false ||
          verified.username !== 'refresh-token' ||
          verified.password !== DEMO_REFRESH_TOKEN
        ) {
          throw new Error('secure storage verification failed')
        }
 
        await AsyncStorage.removeItem(GENERAL_KEY)
      } else {
        await AsyncStorage.setItem(GENERAL_KEY, DEMO_REFRESH_TOKEN)
      }
 
      setEvidence(await inspectStorage())
      setStatus('fixture 저장 완료')
    })
  }
 
  async function readFixture() {
    await run(async () => {
      setEvidence(await inspectStorage())
      setStatus('저장소 다시 읽기 완료')
    })
  }
 
  return (
    <SafeAreaView style={styles.screen}>
      <Text style={styles.title}>장기 인증 정보 저장 경계</Text>
      <Text>mode: {USE_SECURE_STORAGE ? 'secure' : 'general'}</Text>
      <Text>상태: {status}</Text>
      <Text>
        일반 저장소에 원문 있음:{' '}
        {evidence === null
          ? '확인 전'
          : evidence.generalHasPlaintext
            ? '예'
            : '아니오'}
      </Text>
      <Text>
        보안 저장소 재조회:{' '}
        {evidence?.secureHasCredential ? '성공' : '없음'}
      </Text>
      <View style={styles.actions}>
        <Button
          title="두 저장소 초기화"
          disabled={busy}
          onPress={() => void resetFixture()}
        />
        <Button
          title="고정 fixture 저장"
          disabled={busy}
          onPress={() => void saveFixture()}
        />
        <Button
          title="저장소 다시 읽기"
          disabled={busy}
          onPress={() => void readFixture()}
        />
      </View>
    </SafeAreaView>
  )
}
 
const styles = StyleSheet.create({
  screen: { flex: 1, padding: 16, gap: 12 },
  title: { fontSize: 22, fontWeight: '700' },
  actions: { gap: 8 },
})

mode: general
상태: 저장소 다시 읽기 완료
일반 저장소에 원문 있음: 예
보안 저장소 재조회: 없음

React state          현재 JavaScript 실행의 메모리 값
일반 영속 저장소      다음 실행에도 필요한 비밀이 아닌 데이터
인증 정보 보안 저장소  다음 실행에도 필요한 작은 비밀값
backend              token 만료·폐기와 실제 권한 판단

const USE_SECURE_STORAGE = true

mode: secure
상태: 저장소 다시 읽기 완료
일반 저장소에 원문 있음: 아니오
보안 저장소 재조회: 성공

mode: secure
상태: 두 저장소 초기화 완료
일반 저장소에 원문 있음: 아니오
보안 저장소 재조회: 없음

좋은 사용    API 요청 직전에 읽고 Authorization header에만 사용
나쁜 복사    React state·전역 변수·분석 event·오류 log에 장기 보관
나쁜 전송    URL query·WebView 주입·page message에 원문 전달
삭제 경계    logout에서 로컬 항목 삭제와 backend token 폐기를 각각 확인

logout       지정 service의 로컬 항목 삭제 + backend refresh token 폐기
앱 재설치    플랫폼 정책에 따른 잔존 여부 관찰, logout 대용으로 사용하지 않음
기기 이전    iOS accessible·동기화 정책과 Android 백업·키 가용성 확인
token 만료   저장값이 있어도 서버 거절 시 삭제하고 다시 인증

값                 access token / refresh token / 비밀이 아닌 사용자 상태
필요 수명           메모리만 / 앱 재실행까지 / 서버에서 재발급 가능
일반 저장소 복사본   key·저장 위치 이전 코드·개발용 데이터 내보내기(debug export)·backup에 남는가
iOS                Keychain service, accessible, 항목을 공유할 앱 범위인 access group, 동기화 정책
Android            암호문 위치, Keystore key, 요구한 키 보호 단계, 기기가 지원하는 보안 능력
실행 중             state·log·URL·WebView에 원문 복사본이 생기는가
삭제                logout, 계정 전환, 서버 폐기, 재설치·기기 이전
검증                set/get/reset, 재실행, 오류, 실제 기기 보안 능력

문제       장기 refresh token 원문이 암호화되지 않은 일반 저장소에 남음
오판       영속 저장이면 민감한 값도 자동으로 보호됨
관찰       Reload 뒤 Async Storage에서 같은 고정 문자열을 다시 읽음
원인       데이터 수명과 비밀값 보호 요구를 한 저장 경계로 합침
행동       일반 저장소 복사본 제거 + 플랫폼 보안 저장 API로 이동
검증       일반 저장소 없음 + secure service 재조회 + 로컬 삭제, 서버 폐기는 별도 확인
플랫폼     iOS는 Keychain 항목, Android는 Keystore 키로 암호문 보호
경계       저장 중 보호는 실행 중 원문·서버 권한·하드웨어 수준을 대신하지 않음