Unsachgemäße Entfernung sensibler Informationen vor Speicherung oder Übertragung
Beschreibung
Unsachgemäße Entfernung sensibler Informationen vor Speicherung oder Übertragung ist eine Schwachstelle, die auftritt, wenn ein Produkt eine Ressource speichert, überträgt oder teilt, die sensible Informationen enthält, ohne diese Daten ordnungsgemäß zu entfernen, bevor sie unbefugten Parteien zugänglich gemacht wird. Dieser Prozess der Entfernung wird üblicherweise "Bereinigung" oder "Säuberung" genannt. Die Schwachstelle manifestiert sich in verschiedenen Szenarien, einschließlich Dokumenteneditoren, die versteckte Metadaten, Revisionsverläufe oder Kommentare beibehalten; Bilddateien, die GPS-Koordinaten und Kamerainformationen in EXIF-Daten bewahren; Proxys, die interne IP-Adressen in HTTP-Headern weiterleiten; und Anwendungen, die sensible Daten nicht aus dem Speicher löschen, bevor sie Puffer freigeben. Die sensiblen Informationen sind möglicherweise nicht sofort sichtbar, bleiben aber für diejenigen zugänglich, die wissen, wie sie extrahiert werden.
Risiko
Unsachgemäße Entfernung sensibler Informationen erzeugt erhebliche Datenschutz- und Sicherheitsrisiken über mehrere Domänen hinweg. Extern geteilte Dokumente können versteckte Revisionsverläufe, Autorennamen, interne Dateipfade oder vertrauliche Kommentare enthalten, die Geschäftsstrategien oder persönliche Informationen offenlegen. Bild-EXIF-Metadaten können GPS-Standorte von Fotografen, Tagesabläufe und Geräteinformationen offenlegen, die für Stalking oder Social Engineering nützlich sind. Anwendungen, die Speicherpuffer ohne ordnungsgemäße Bereinigung wiederverwenden, können Daten früherer Benutzer an nachfolgende Anfragen weitergeben. Durch HTTP-Header offengelegte interne Netzwerktopologie hilft Angreifern bei der Infrastrukturkartierung für Lateral Movement. Diese Lecks bleiben oft unbemerkt, weil die sensiblen Daten bei normaler Nutzung nicht sichtbar sind, was die Offenlegung still und persistent macht, bis sie von einem Angreifer oder Forscher entdeckt wird.
Lösung
Implementieren Sie automatisierte Datenbereinigung an allen Grenzen, an denen Daten zwischen Vertrauenszonen wechseln. Für Dokumente verwenden Sie Metadaten-Entfernungstools vor dem externen Teilen und integrieren Sie Bereinigung in Dokumentenmanagement-Workflows. Für Bilder entfernen Sie EXIF-Daten zum Upload-Zeitpunkt mit Bibliotheken wie ExifTool oder eingebauten Sprachfunktionen. Konfigurieren Sie Proxys und Load Balancer, um interne Header vor der externen Weiterleitung von Anfragen zu entfernen. Für Speicherbehandlung nullen Sie sensible Puffer explizit vor der Deallokation und verwenden Sie sichere Speicherallokationsbibliotheken. Implementieren Sie Data-Loss-Prevention (DLP)-Tools, die ausgehende Inhalte auf sensible Muster scannen. Erstellen Sie Richtlinien, die Datensanitierung vor dem Teilen erfordern, und automatisieren Sie die Durchsetzung. Testen Sie die Bereinigungseffektivität, indem Sie versuchen, Metadaten aus verarbeiteten Ausgaben zu extrahieren.
Häufige Auswirkungen
| Auswirkung | Details |
|---|---|
| Vertraulichkeit | Bereich: Vertraulichkeit Sensible Daten können unbefugten Akteuren offengelegt werden, wenn Ressourcen zwischen verschiedenen Kontrollsphären übertragen werden. Dies umfasst Systeminformationen wie Dateistandorte und Softwareversionen, die gezielte Angriffe ermöglichen. |
| Datenschutz | Bereich: Vertraulichkeit Personenbezogene Daten (PII), private persönliche Informationen (PPI) und andere private Daten können offengelegt werden, was die Datenschutzerwartungen der Benutzer verletzt und potenziell Identitätsdiebstahl oder Stalking ermöglicht. |
Beispielcode
Anfälliger Code (Python)
Der folgende Code demonstriert anfällige Dateibehandlung, die sensible Metadaten bewahrt:
from PIL import Image
import shutil
import os
class VulnerableImageProcessor:
"""Verarbeitet Bilder ohne Entfernung sensibler Metadaten"""
def process_and_share(self, input_path, output_path):
# Anfällig: Kopiert Datei einfach, bewahrt alle EXIF-Daten
# EXIF kann enthalten: GPS-Koordinaten, Kamera-Seriennummer, Zeitstempel,
# Thumbnail-Bilder, Softwareversion, Autorenname
shutil.copy(input_path, output_path)
def resize_image(self, input_path, output_path, size):
# Anfällig: PIL bewahrt EXIF standardmäßig bei einigen Operationen
img = Image.open(input_path)
img_resized = img.resize(size)
# EXIF-Daten können noch vorhanden sein
img_resized.save(output_path)
class VulnerableDocumentHandler:
"""Dokumentenbehandlung mit Metadaten-Offenlegung"""
def prepare_for_sharing(self, doc_path):
# Anfällig: Keine Metadaten-Entfernung
# Word-Dokumente können enthalten:
# - Autorennamen und Firma
# - Revisionsverläufe mit gelöschtem Text
# - Versteckte Kommentare
# - Dateipfade, die interne Struktur enthüllen
# - Eingebettete Objekte mit Metadaten
return doc_path # Gibt nur Pfad zurück, keine Bereinigung
class VulnerableProxy:
"""Proxy, der interne Informationen preisgibt"""
def forward_request(self, request):
headers = dict(request.headers)
# Anfällig: Leitet interne Header extern weiter
# Diese enthüllen interne Netzwerktopologie
headers['X-Forwarded-For'] = request.remote_addr
headers['X-Real-IP'] = request.remote_addr
headers['X-Internal-Server'] = 'app-server-03.internal.corp'
headers['X-Backend-Server'] = '10.0.0.45:8080'
return self.send_external(headers, request.data)
class VulnerableBufferHandler:
"""Speicherbehandlung, die vorherige Daten preisgibt"""
def __init__(self, buffer_size=4096):
# Wiederverwendeter Puffer - kann vorherige sensible Daten enthalten
self.buffer = bytearray(buffer_size)
def process_request(self, data):
# Anfällig: Löscht Puffer nicht vor Verwendung
# Daten der vorherigen Anfrage können durchsickern, wenn neue Daten kürzer sind
for i, byte in enumerate(data):
self.buffer[i] = byte
# Rest des Puffers enthält noch vorherige Daten!
return self.buffer
Der Code bewahrt EXIF-Metadaten in Bildern, bereinigt Dokumente nicht vor dem Teilen, leitet interne Netzwerkinformationen weiter und verwendet Speicherpuffer ohne Löschung wieder.
Korrigierter Code (Python)
from PIL import Image
import piexif
import io
import os
class SecureImageProcessor:
"""Verarbeitet Bilder mit ordnungsgemäßer Metadaten-Entfernung"""
def strip_exif(self, image_path):
"""Entfernt alle EXIF-Daten aus Bild"""
img = Image.open(image_path)
# EXIF durch Laden und Speichern ohne sie entfernen
data = list(img.getdata())
img_no_exif = Image.new(img.mode, img.size)
img_no_exif.putdata(data)
return img_no_exif
def process_and_share(self, input_path, output_path):
"""Verarbeitet Bild mit vollständiger Metadaten-Entfernung"""
# Alle EXIF/Metadaten entfernen
img = self.strip_exif(input_path)
# Ohne Metadaten speichern
img.save(output_path, exif=b'')
# Verifizieren, dass keine EXIF verbleibt
self.verify_clean(output_path)
def resize_image(self, input_path, output_path, size):
"""Bildgröße ändern und sicherstellen, dass Metadaten entfernt werden"""
img = Image.open(input_path)
img_resized = img.resize(size)
# Neues Bild ohne Metadaten erstellen
img_clean = Image.new(img_resized.mode, img_resized.size)
img_clean.putdata(list(img_resized.getdata()))
# Ohne EXIF speichern
img_clean.save(output_path)
def verify_clean(self, image_path):
"""Verifizieren, dass Bild frei von sensiblen Metadaten ist"""
try:
exif_dict = piexif.load(image_path)
if any(exif_dict.values()):
raise ValueError("EXIF-Daten noch vorhanden")
except:
pass # Keine EXIF gefunden - gut
class SecureDocumentHandler:
"""Dokumentenbehandlung mit ordnungsgemäßer Bereinigung"""
SENSITIVE_PROPERTIES = [
'author', 'last_modified_by', 'company',
'comments', 'revision', 'manager'
]
def prepare_for_sharing(self, doc_path):
"""Metadaten vor dem Teilen von Dokumenten entfernen"""
from docx import Document
doc = Document(doc_path)
# Kerneigenschaften löschen
core_props = doc.core_properties
core_props.author = ''
core_props.last_modified_by = ''
core_props.comments = ''
core_props.revision = 1
# Kommentare aus Dokument entfernen
self.remove_comments(doc)
# Revisionsverfolgung entfernen
self.accept_all_changes(doc)
# Bereinigtes Dokument speichern
clean_path = doc_path.replace('.docx', '_clean.docx')
doc.save(clean_path)
return clean_path
class SecureProxy:
"""Proxy, der Header vor externer Weiterleitung sanitisiert"""
# Header, die niemals extern weitergeleitet werden sollten
INTERNAL_HEADERS = [
'X-Internal-Server',
'X-Backend-Server',
'X-Debug-Token',
'X-Request-Id-Internal'
]
def forward_request(self, request):
headers = {}
for key, value in request.headers:
# Interne Header überspringen
if key in self.INTERNAL_HEADERS:
continue
# Weitergeleitete IPs sanitisieren, um nur externe einzuschließen
if key == 'X-Forwarded-For':
value = self.sanitize_ip_chain(value)
headers[key] = value
return self.send_external(headers, request.data)
def sanitize_ip_chain(self, ip_chain):
"""Interne IPs aus X-Forwarded-For entfernen"""
ips = [ip.strip() for ip in ip_chain.split(',')]
external_ips = [ip for ip in ips if not self.is_internal(ip)]
return ', '.join(external_ips) if external_ips else ''
class SecureBufferHandler:
"""Speicherbehandlung mit ordnungsgemäßer Bereinigung"""
def __init__(self, buffer_size=4096):
self.buffer_size = buffer_size
def process_request(self, data):
# Frischen Puffer für jede Anfrage erstellen
buffer = bytearray(self.buffer_size)
# Daten verarbeiten
for i, byte in enumerate(data):
buffer[i] = byte
# Mit Daten arbeiten...
result = self.process(buffer[:len(data)])
# Puffer sicher löschen wenn fertig
self.secure_zero(buffer)
return result
def secure_zero(self, buffer):
"""Speicher sicher nullen, um Datenleck zu verhindern"""
for i in range(len(buffer)):
buffer[i] = 0
Die Korrektur entfernt EXIF-Daten aus Bildern, entfernt Dokumentmetadaten vor dem Teilen, sanitisiert Header in Proxys und löscht Speicherpuffer sicher.
Ausgenutzt in der Praxis
NSA-Dokument-Metadaten-Offenlegung (NSA/Reality Winner, 2017)
Ein geleaktes NSA-Dokument enthielt versteckte Metadaten einschließlich Drucker-Tracking-Punkte und Dokumenteigenschaften, die halfen, die Leakerin Reality Winner zu identifizieren. Die Metadaten des Dokuments enthüllten den spezifisch verwendeten Drucker und Zeitstempel, die mögliche Quellen eingrenzen. Dieser Fall demonstrierte, wie Dokumentmetadaten forensisch wertvoll sein können und wie das Versäumnis, Dokumente vor dem Teilen zu sanitisieren, schwerwiegende Konsequenzen haben kann.
Imgur EXIF-Daten-Offenlegung (Imgur, 2019)
Sicherheitsforscher entdeckten, dass Imgur, ein beliebter Bildhosting-Dienst, EXIF-Daten nicht konsistent von hochgeladenen Bildern entfernte. Dies legte GPS-Koordinaten von Benutzern aus Smartphone-Fotos offen und enthüllte potenziell Wohnadressen, Arbeitsplätze und Reisemuster. Die Offenlegung betraf Millionen von Bildern, bevor das Problem behoben wurde.
Microsoft Office Dokument-Metadaten-Lecks (Mehrere Organisationen, Fortlaufend)
Organisationen geben routinemäßig sensible Informationen durch Microsoft-Office-Dokumentmetadaten preis. Fallstudien haben Unternehmensfusionen und -übernahmen durch Autoreneigenschaften, interne Netzwerkpfade durch eingebettete Objektlinks und vertrauliche Löschungen durch Revisionsverläufe enthüllt. Sicherheitsforscher demonstrieren regelmäßig das Extrahieren angeblich gelöschter Inhalte aus geteilten Dokumenten.
Tools zum Testen/Ausnutzen
-
ExifTool — Umfassendes Tool zum Lesen, Schreiben und Entfernen von Metadaten aus Bildern, Dokumenten und vielen anderen Dateitypen.
-
FOCA — Dokument-Metadaten-Extraktions- und Analysetool zum Finden versteckter Informationen in öffentlich verfügbaren Dokumenten.
-
Metadata Anonymisation Toolkit (MAT2) — Tool zum Entfernen von Metadaten aus Dateien zum Schutz der Privatsphäre.
CVE-Beispiele
-
CVE-2020-26220 — CRM-Produkt versäumte, EXIF-Metadaten von hochgeladenen Bildern zu entfernen und legte Benutzerstandortdaten offen.
-
CVE-2019-3733 — Kryptografiebibliothek löschte Heap-Speicher nicht vor der Freigabe und gab potenziell sensible Daten preis.
-
CVE-2005-0406 — JPEG-Bildbearbeitungstools ließen Original-EXIF-Thumbnails intakt, wenn Bilder modifiziert oder beschnitten wurden.
-
CVE-2002-0704 — Firewall-NAT-Funktion gab interne IP-Adressen in ICMP-Fehlermeldungen preis, die extern weitergeleitet wurden.
Referenzen
-
MITRE Corporation. "CWE-212: Improper Removal of Sensitive Information Before Storage or Transfer." Common Weakness Enumeration. https://cwe.mitre.org/data/definitions/212.html
-
OWASP Foundation. "Information Exposure Through Metadata." OWASP. https://owasp.org/www-community/vulnerabilities/Information_exposure_through_metadata
-
Electronic Frontier Foundation. "Printer Tracking Dots." EFF. https://www.eff.org/issues/printers
-
ExifTool Documentation. https://exiftool.org/