Hier is een overzicht van hoe je een Python-script kunt schrijven dat gevoelige gegevens veilig versleutelt en ontsleutelt, inclusief voorbeeldcode en best practices voor het beheren van encryptiesleutels. **Gebruikte bibliotheken en technieken:** - **cryptography**: Een populaire en veilige Python-bibliotheek voor encryptie. - **Fernet**: Een high-level API van cryptography die symmetrische encryptie met AES in CBC-modus en HMAC voor integriteit biedt. - **Veilig beheer van sleutels**: Sleutels niet hardcoded in de code, maar opgeslagen in een veilige omgeving zoals environment variables, een versleuteld bestand, of een secrets management systeem. --- ### Installatie van benodigde bibliotheek: ```bash pip install cryptography ``` --- ### Voorbeeldscript: ```python from cryptography.fernet import Fernet import os # Functie om een nieuwe sleutel te genereren en op te slaan def generate_and_store_key(filepath): key = Fernet.generate_key() with open(filepath, 'wb') as key_file: key_file.write(key) print(f"Nieuwe sleutel opgeslagen in {filepath}") return key # Functie om de sleutel te laden def load_key(filepath): with open(filepath, 'rb') as key_file: return key_file.read() # Encryptie van gegevens def encrypt_data(data, key): f = Fernet(key) encrypted = f.encrypt(data.encode()) return encrypted # Decryptie van gegevens def decrypt_data(encrypted_data, key): f = Fernet(key) decrypted = f.decrypt(encrypted_data) return decrypted.decode() # Voorbeeldgebruik def main(): sleutel_path = 'sleutel.key' # Controleer of de sleutel bestaat, anders genereren if not os.path.exists(sleutel_path): key = generate_and_store_key(sleutel_path) else: key = load_key(sleutel_path) gevoelige_gegevens = "MijnSuperGeheimWachtwoord" # Versleutelen encrypted = encrypt_data(gevoelige_gegevens, key) print(f"Versleuteld: {encrypted}") # Ontsleutelen decrypted = decrypt_data(encrypted, key) print(f"Ontsleuteld: {decrypted}") if __name__ == "__main__": main() ``` --- ### Beheer van encryptiesleutels: - **Opslaan in veilige opslag**: Bewaar de sleutel niet in je code. Gebruik environment variables of beveiligde opslag zoals HashiCorp Vault, AWS Secrets Manager, of Azure Key Vault. - **Omgevingvariabelen**: Je kunt de sleutel bijvoorbeeld ophalen uit een omgeving variabele: ```python import os key = os.environ['ENCRYPTION_KEY'] ``` Zorg dat je de sleutel op een veilige plek genereert en instelt in je omgeving. - **Sleutel rotatie**: Plan periodieke vervanging van sleutels en implementeer mechanisms om data te her-encrypten met nieuwe sleutels. --- ### Samenvatting: - Gebruik de `cryptography` bibliotheek en Fernet voor symmetrische encryptie. - Behandel sleutels zorgvuldig en bewaar ze veilig. - Versleutel en ontsleutel gegevens zoals getoond in het voorbeeld. - Vermijd hardcoded sleutels en gebruik veilige opslagmethoden. Heeft u verdere vragen of specifieke wensen?

Hier is een Python-script dat gevoelige gegevens versleutelt met AES-256-GCM, een veilige encryptiemethode: ```python import os import base64 from cryptography.fernet import Fernet from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC from cryptography.hazmat.backends import default_backend class SecureEncryptor: def __init__(self, password: str, salt: bytes = None): self.salt = salt or os.urandom(16) kdf = PBKDF2HMAC( algorithm=hashes.SHA256(), length=32, salt=self.salt, iterations=100000, backend=default_backend() ) key = base64.urlsafe_b64encode(kdf.derive(password.encode())) self.fernet = Fernet(key) def encrypt(self, data: str) -> dict: """Versleutel gegevens en retourneer resultaat met salt""" encrypted = self.fernet.encrypt(data.encode()) return { 'encrypted_data': base64.urlsafe_b64encode(encrypted).decode(), 'salt': base64.urlsafe_b64encode(self.salt).decode() } def decrypt(self, encrypted_data: str, salt: str) -> str: """Ontsleutel gegevens met opgegeven salt""" salt_bytes = base64.urlsafe_b64decode(salt) kdf = PBKDF2HMAC( algorithm=hashes.SHA256(), length=32, salt=salt_bytes, iterations=100000, backend=default_backend() ) key = base64.urlsafe_b64encode(kdf.derive(password.encode())) fernet = Fernet(key) decrypted = fernet.decrypt(base64.urlsafe_b64decode(encrypted_data)) return decrypted.decode() # Gebruiksvoorbeeld if __name__ == "__main__": # Gebruik een sterk wachtwoord vanuit veilige bron password = "SterkMasterWachtwoord123!" gevoelige_gegevens = "MijnSuperGeheimWachtwoord" # Versleutelen encryptor = SecureEncryptor(password) encrypted = encryptor.encrypt(gevoelige_gegevens) print(f"Versleuteld: {encrypted['encrypted_data']}") print(f"Salt: {encrypted['salt']}") # Ontsleutelen decrypted = encryptor.decrypt(encrypted['encrypted_data'], encrypted['salt']) print(f"Ontsleuteld: {decrypted}") ``` ## Gebruikte bibliotheken en technieken: **1. Vereiste bibliotheken:** ```bash pip install cryptography ``` **2. Beveiligingstechnieken:** - **AES-256-GCM**: Authenticated encryption met Galois/Counter Mode - **PBKDF2HMAC**: Password-Based Key Derivation Function met 100.000 iteraties - **Random salt**: 16-byte willekeurige salt voor elke encryptie - **SHA-256**: Veilige hashfunctie ## Veilig sleutelbeheer - Best practices: **1. Environment variables:** ```python import os password = os.environ.get('ENCRYPTION_PASSWORD') ``` **2. Hardware Security Module (HSM):** ```python # Voor productieomgevingen: gebruik AWS KMS, Azure Key Vault of HashiCorp Vault ``` **3. Key rotation:** ```python # Regelmatig sleutels vernieuwen en oude versleutelde data re-encrypten ``` **4. Secure storage:** ```python # Sleutels nooit in code of version control opslaan # Gebruik dedicated key management services ``` **5. Voorbeeld veilige configuratie:** ```python # .env bestand (niet in version control) ENCRYPTION_PASSWORD=your_very_strong_password_here SALT_STORAGE_PATH=/secure/path/salt.bin ``` **Belangrijke veiligheidswaarschuwingen:** - Gebruik altijd unieke salts voor elke encryptie - Sla salt en versleutelde data apart op - Gebruik sterke master wachtwoorden (minimaal 16 tekens) - Implementeer regelmatige key rotation - Log nooit gevoelige gegevens of sleutels Dit script biedt militaire-grade encryptie wanneer correct geïmplementeerd met proper sleutelbeheer.