Datenschutz und Sicherheit: Ein Leitfaden für Entwickler zur Verarbeitung sensibler Daten mit DuckDB

Tutorials

SQL

Verstehen von DuckDB für Datenschutz und Sicherheit

Datenschutz und Sicherheit sind für alle Organisationen weltweit von entscheidender Bedeutung. Organisationen müssen oft sensible Informationen aus ihren Datensätzen identifizieren, maskieren oder entfernen, während sie die Nützlichkeit der Daten aufrechterhalten. Dieser Artikel untersucht, wie man DuckDB, eine in-prozess analytische Datenbank, für eine effiziente Behebung sensibler Daten nutzen kann.

Warum DuckDB? (Und warum sollte es Ihnen wichtig sein?)

Betrachten Sie DuckDB als SQLite’s analytisch begabten Cousin. Es ist eine eingebettete Datenbank, die direkt in Ihrem Prozess läuft, und ist speziell für die Verarbeitung analytischer Arbeitslasten konzipiert. Was macht es perfekt für die Datenbehebung? Nun, stellen Sie sich vor, große Datensätze mit blitzschneller Geschwindigkeit verarbeiten zu können, ohne einen komplizierten Datenbankserver einrichten zu müssen. Klingt gut, oder?

Hier sind die Gründe, warum DuckDB besonders großartig für unseren Anwendungsfall ist:

Es ist dank seiner spaltenorientierten Speicherung blitzschnell.
Sie können es direkt in Ihrer bestehenden Python-Umgebung ausführen.
Es verarbeitet mehrere Dateiformate, als wäre es kein großes Ding.
Es funktioniert gut mit Cloud-Speicher (mehr dazu später).

In diesem Handbuch werde ich Python zusammen mit DuckDB verwenden. DuckDB unterstützt auch andere Sprachen, wie in ihrer Dokumentation erwähnt.

Einführung in DuckDB für Datenschutz

Voraussetzungen

Python 3.9 oder höher installiert
Vorwissen über die Einrichtung von Python-Projekten und virtuellen Umgebungen oder Conda-Umgebungen

Installieren Sie DuckDB in einer virtuellen Umgebung, indem Sie den folgenden Befehl ausführen:

Shell

pip install duckdb --upgrade

Jetzt, da Sie DuckDB installiert haben, lassen Sie uns eine DuckDB-Verbindung erstellen:

Python

import duckdb

import pandas as pd

​

# Create a DuckDB connection - it's this simple!

conn = duckdb.connect(database=':memory:')

Erweiterte Techniken zur Maskierung von PII-Daten

So implementieren Sie eine robuste PII (personenbezogene Daten) Maskierung:

Angenommen, Sie haben einen Datensatz voller Kundeninformationen, der bereinigt werden muss. So können Sie gängige Szenarien behandeln.

Lassen Sie uns Beispiel-Daten erstellen:

SQL

CREATE TABLE customer_data AS 

SELECT 

    'John Doe' as name,

    '123-45-6789' as ssn,

    '[email protected]' as email,

    '123-456-7890' as phone;

Dies erstellt eine Tabelle mit dem Namen customer_data mit einer Zeile Beispielfeldinformationen.
Die Daten umfassen einen Namen, eine SSN, eine E-Mail-Adresse und eine Telefonnummer.

Der zweite Teil beinhaltet das Maskieren von Mustern mittels regexp_replace:

SQL

-- Implement PII masking patterns

CREATE TABLE masked_data AS

SELECT 

    regexp_replace(name, '[a-zA-Z]', 'X') as masked_name,

    regexp_replace(ssn, '[0-9]', '*') as masked_ssn,

    regexp_replace(email, '(^[^@]+)(@.*$)', '****$2') as masked_email,

    regexp_replace(phone, '[0-9]', '#') as masked_phone

FROM customer_data;

Ich erkläre Ihnen, was der obige SQL-Code macht.

regexp_replace(name, '[a-zA-Z]', 'X')
- Ersetzt alle Buchstaben (sowohl Groß- als auch Kleinbuchstaben) durch 'X'
- Beispiel: "John Doe" wird zu "XXXX XXX"
regexp_replace(ssn, '[0-9]', '*') as masked_ssn
- Ersetzt alle Ziffern durch '*'
- Beispiel: "123-45-6789" wird zu "--***"
regexp_replace(email, '(^[^@]+)(@.*$)', '****$2') as masked_email:
- (^[^@]+) erfasst alles vor dem @-Symbol
- (@.*$) erfasst das @ und alles, was danach kommt
- Ersetzt den ersten Teil durch '****' und behält den Domain-Teil bei
- Beispiel: "" wird zu "****@email.com"
regexp_replace(phone, '[0-9]', '#') as masked_phone:
- Ersetzt alle Ziffern durch '#'
- Beispiel: "123-456-7890" wird zu "###-###-####"

So wird Ihre Daten wie folgt transformiert:

Ursprüngliche Daten:

name: John Doe
ssn: 123-45-6789
email: [email protected]
phone: 123-456-7890

Maskierte Daten:

masked_name: XXXX XXX
masked_ssn: ***-**-****
masked_email: ****@email.com
masked_phone: ###-###-####

Python-Implementierung

Python

import duckdb

import pandas as pd

​

def mask_pii_data():

    # Create a DuckDB connection in memory

    conn = duckdb.connect(database=':memory:')

    try:

        # Create and populate sample data

        conn.execute("""

            CREATE TABLE customer_data AS 

            SELECT 

                'John Doe' as name,

                '123-45-6789' as ssn,

                '[email protected]' as email,

                '123-456-7890' as phone

        """)

        # Implement PII masking

        conn.execute("""

            CREATE TABLE masked_data AS

            SELECT 

                regexp_replace(name, '[a-zA-Z]', 'X') as masked_name,

                regexp_replace(ssn, '[0-9]', '*') as masked_ssn,

                regexp_replace(email, '(^[^@]+)(@.*$)', '****$2') as masked_email,

                regexp_replace(phone, '[0-9]', '#') as masked_phone

            FROM customer_data

        """)

        # Fetch and display original data

        print("Original Data:")

        original_data = conn.execute("SELECT * FROM customer_data").fetchdf()

        print(original_data)

        print("\n")

        # Fetch and display masked data

        print("Masked Data:")

        masked_data = conn.execute("SELECT * FROM masked_data").fetchdf()

        print(masked_data)

        return original_data, masked_data

    except Exception as e:

        print(f"An error occurred: {str(e)}")

        return None, None

    finally:

        # Close the connection

        conn.close()

Datenredaktion basierend auf Regeln

Lassen Sie mich die Datenredaktion in einfachen Worten erklären, bevor wir in die technischen Aspekte eintauchen.

Datenredaktion ist der Prozess, sensible Informationen aus Dokumenten oder Datenbanken zu verbergen oder zu entfernen, während die gesamte Struktur und der nicht sensible Inhalt erhalten bleiben. Stellen Sie sich vor, Sie verwenden einen schwarzen Marker, um vertrauliche Informationen auf einem gedruckten Dokument zu verbergen, aber in digitaler Form.

Lassen Sie uns nun die Datenredaktion mit DuckDB und Python implementieren. Ich habe diesen Code-Schnipsel mit Kommentaren hinzugefügt, damit Sie leicht folgen können.

Python

import duckdb

import pandas as pd

​

def demonstrate_data_redaction():

    # Create a connection

    conn = duckdb.connect(':memory:')

    # Create sample data with various sensitive information

    conn.execute("""

        CREATE TABLE sensitive_info AS SELECT * FROM (

            VALUES

                ('John Doe', '[email protected]', 'CC: 4532-1234-5678-9012', 'Normal text'),

                ('Jane Smith', '[email protected]', 'SSN: 123-45-6789', 'Some notes'),

                ('Bob Wilson', '[email protected]', 'Password: SecretPass123!', 'Regular info'),

                ('Alice Brown', '[email protected]', 'API_KEY=abc123xyz', 'Basic text')

            ) AS t(name, email, sensitive_field, normal_text);

    """)

    # Define redaction rules

    redaction_rules = {

        'email': r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',  # Email pattern

        'sensitive_field': r'(CC:\s*\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}|SSN:\s*\d{3}-\d{2}-\d{4}|Password:\s*\S+|API_KEY=\S+)',  # Various sensitive patterns

        'name': r'[A-Z][a-z]+ [A-Z][a-z]+'  # Full name pattern

    }

    # Show original data

    print("Original Data:")

    print(conn.execute("SELECT * FROM sensitive_info").fetchdf())

    # Apply redaction

    redact_sensitive_data(conn, 'sensitive_info', redaction_rules)

    # Show redacted data

    print("\nRedacted Data:")

    print(conn.execute("SELECT * FROM redacted_data").fetchdf())

    return conn

​

def redact_sensitive_data(conn, table_name, rules):

    """

    Redact sensitive data based on specified patterns.

    Parameters:

    - conn: DuckDB connection

    - table_name: Name of the table containing sensitive data

    - rules: Dictionary of column names and their corresponding regex patterns to match sensitive data

    """

    redaction_cases = []

    # This creates a CASE statement for each column

    # If the pattern matches, the value is redacted

    # If not, the original value is kept

    for column, pattern in rules.items():

        redaction_cases.append(f"""

            CASE 

                WHEN regexp_matches({column}, '{pattern}') 

                THEN '(REDACTED)' 

                ELSE {column} 

            END as {column}

        """)

    query = f"""

    CREATE TABLE redacted_data AS

    SELECT 

        {', '.join(redaction_cases)}

    FROM {table_name};

    """

    conn.execute(query)

​

# Example with custom redaction patterns

def demonstrate_custom_redaction():

    conn = duckdb.connect(':memory:')

    # Create sample data

    conn.execute("""

        CREATE TABLE customer_data AS SELECT * FROM (

            VALUES

                ('John Doe', '123-45-6789', 'ACC#12345', '$5000'),

                ('Jane Smith', '987-65-4321', 'ACC#67890', '$3000'),

                ('Bob Wilson', '456-78-9012', 'ACC#11111', '$7500')

            ) AS t(name, ssn, account, balance);

    """)

    # Define custom redaction rules with different patterns

    custom_rules = {

        'name': {

            'pattern': r'[A-Z][a-z]+ [A-Z][a-z]+',

            'replacement': lambda match: f"{match[0][0]}*** {match[0].split()[1][0]}***"

        },

        'ssn': {

            'pattern': r'\d{3}-\d{2}-\d{4}',

            'replacement': 'XXX-XX-XXXX'

        },

        'account': {

            'pattern': r'ACC#\d{5}',

            'replacement': 'ACC#*****'

        }

    }

    def apply_custom_redaction(conn, table_name, rules):

        redaction_cases = []

        for column, rule in rules.items():

            redaction_cases.append(f"""

                CASE 

                    WHEN regexp_matches({column}, '{rule['pattern']}') 

                    THEN '{rule['replacement']}'

                    ELSE {column} 

                END as {column}

            """)

        query = f"""

        CREATE TABLE custom_redacted AS

        SELECT 

            {', '.join(redaction_cases)},

            balance  -- Keep this column unchanged

        FROM {table_name};

        """

        conn.execute(query)

    # Show original data

    print("\nOriginal Customer Data:")

    print(conn.execute("SELECT * FROM customer_data").fetchdf())

    # Apply custom redaction

    apply_custom_redaction(conn, 'customer_data', custom_rules)

    # Show results

    print("\nCustom Redacted Data:")

    print(conn.execute("SELECT * FROM custom_redacted").fetchdf())

​

# Run demonstrations

print("=== Basic Redaction Demo ===")

demonstrate_data_redaction()

print("\n=== Custom Redaction Demo ===")

demonstrate_custom_redaction()

Beispielergebnisse

Vor der Redaktion:

name       email              sensitive_field
John Doe   [email protected] CC: 4532-1234-5678-9012

Nach der Redaktion:

name       email      sensitive_field
(REDACTED) (REDACTED) (REDACTEd)

Fazit

DuckDB ist eine einfache, aber leistungsstarke In-Memory-Datenbank, die bei der Behebung sensibler Daten helfen kann.

Denken Sie daran, immer:

Ihre maskierten Daten zu validieren.
Parallele Verarbeitung für große Datensätze zu verwenden.
Die S3-Integration von DuckDB für Cloud-Daten zu nutzen.
Beobachten Sie Ihren Speicherverbrauch bei der Verarbeitung großer Dateien.

Source:
https://dzone.com/articles/developers-guide-handling-sensitive-data-with-duckdb