메뉴
Use when storing sensitive data at rest — PII, health records, financial data, cryptographic keys, or any data that must remain confidential if storage media is compromised.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/jeffreytse/grimoire-core --skill apply-cryptographic-storage명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | apply-cryptographic-storage |
| description | Use when storing sensitive data at rest — PII, health records, financial data, cryptographic keys, or any data that must remain confidential if storage media is compromised. |
| source | OWASP Cryptographic Storage Cheat Sheet (owasp.org/www-project-cheat-sheets); NIST SP 800-175B (Cryptographic Standards); OWASP Top 10 2021 A02; CWE-312 |
| tags | ["security","owasp","encryption","cryptography","key-management","data-at-rest","developer"] |
Encrypt sensitive data at rest using AES-256-GCM with authenticated encryption, manage keys in a dedicated key management service, and separate key storage from encrypted data.
Adopted by: NIST SP 800-175B mandates AES-256 and approved modes for federal systems. PCI DSS v4.0 Requirement 3 mandates encryption of stored cardholder data with strong cryptography. HIPAA Security Rule (45 CFR 164.312) requires encryption for PHI. AWS KMS, Google Cloud KMS, Azure Key Vault, and HashiCorp Vault are all built on these standards. Every major cloud database (AWS RDS, Google Cloud SQL, Azure SQL) offers encryption at rest as a default. Impact: The 2013 Adobe breach (153M records) exposed passwords stored with 3DES-ECB — a reversible, unauthenticated cipher — enabling mass decryption. LinkedIn (2012, SHA-1 passwords), LastPass (2022, encrypted vaults with weak key derivation), and Equifax (2017) all demonstrate the cost of weak or missing encryption. AES-256-GCM with authenticated encryption makes stored data computationally infeasible to decrypt or tamper with. Why best: AES-128-CBC (without authentication) is the common alternative — it's vulnerable to padding oracle attacks (POODLE, BEAST) and bit-flipping ciphertext tampering because CBC has no integrity check. AES-256-GCM is an AEAD cipher: it encrypts AND authenticates in one operation, detecting any tampering. The 256-bit key provides post-quantum margin.
Sources: OWASP Cryptographic Storage Cheat Sheet; NIST SP 800-175B; PCI DSS v4.0 Req 3; CWE-312
Use AES-256-GCM (authenticated encryption) for all sensitive data:
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
def encrypt(plaintext: bytes, key: bytes) -> bytes:
# key must be 32 bytes (256 bits)
aesgcm = AESGCM(key)
nonce = os.urandom(12) # 96-bit nonce — unique per encryption
ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data=None)
return nonce + ciphertext # prepend nonce for storage
def decrypt(stored: bytes, key: bytes) -> bytes:
nonce, ciphertext = stored[:12], stored[12:]
aesgcm = AESGCM(key)
return aesgcm.decrypt(nonce, ciphertext, associated_data=None)
# Raises InvalidTag if ciphertext was tampered
// Node.js
const { createCipheriv, createDecipheriv, randomBytes } = require('crypto');
function encrypt(plaintext, key) {
const iv = randomBytes(12);
const cipher = createCipheriv('aes-256-gcm', key, iv);
const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
const tag = cipher.getAuthTag();
return Buffer.concat([iv, tag, encrypted]);
}
Store encryption keys separately from the data they protect — use a Key Management Service:
# AWS KMS example — data key per record or per tenant
import boto3
kms = boto3.client('kms')
def get_data_key(key_id):
response = kms.generate_data_key(KeyId=key_id, KeySpec='AES_256')
plaintext_key = response['Plaintext'] # use for encryption, then discard
encrypted_key = response['CiphertextBlob'] # store alongside ciphertext
return plaintext_key, encrypted_key
def decrypt_data_key(encrypted_key):
response = kms.decrypt(CiphertextBlob=encrypted_key)
return response['Plaintext']
Alternatives: HashiCorp Vault, Google Cloud KMS, Azure Key Vault.
For field-level encryption in databases — encrypt before storing, decrypt after reading:
class EncryptedField:
def __set_name__(self, owner, name):
self.name = name
def __set__(self, obj, value):
if value is not None:
obj.__dict__[self.name] = encrypt(value.encode(), get_key())
else:
obj.__dict__[self.name] = None
def __get__(self, obj, objtype=None):
raw = obj.__dict__.get(self.name)
if raw is not None:
return decrypt(raw, get_key()).decode()
return None
class Patient(Model):
ssn = EncryptedField() # transparently encrypted in DB
dob = EncryptedField()
Use envelope encryption for scale — one master key in KMS, unique data keys per record:
Master Key (KMS — never leaves KMS)
└─ Data Key (unique per user/record, generated by KMS)
└─ Encrypted Data (stored in DB alongside encrypted data key)
This limits blast radius: compromising one data key affects only one record.
Derive keys from passwords using a KDF — when the encryption key comes from a user secret:
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
import os
def derive_key(password: bytes, salt: bytes = None):
if salt is None:
salt = os.urandom(16)
kdf = Scrypt(salt=salt, length=32, n=2**17, r=8, p=1)
key = kdf.derive(password)
return key, salt
Use Argon2id (preferred), scrypt, or PBKDF2-HMAC-SHA256 (FIPS only). Store the salt alongside the encrypted data.
Rotate keys without re-encrypting all data — use key versioning:
# Store key version alongside ciphertext
# On read: decrypt with key version stored in record
# On next write: re-encrypt with current key version
# Old key version stays valid until all records are migrated
os.urandom(12).