[Projektvorstellung] RAMpartExtractor Pro – In-Memory-Entpacker gegen SSD-Verschleiß und ZIP-Bomben

Status
Für weitere Antworten geschlossen.
BFF schrieb:
Hier gut zu sehen. Das die ssd intensiv genutzt wurde. Respekt!

Ich denke immer noch, daß es aber auch genug negativ Beispiele gibt. Hier im Forum ja auch oft Thema. Die hat zwar viel geleistet. Aber hat halt noch kein Jahr an Betriebsstunden gesammelt. Wenn da von einer üblichen Nutzung 7-8 Jahre stehen. Also physisch entsprechend älter. Eine intensive nutzung vorlag. Sieht man auch mal deutlich niedrigere % Angaben. Status immer noch good. Test haben ja gezeigt, daß ssd's ein zichfaches mehr abkönnen als die Hersteller mit ihrer Garantie abdecken. Wenn es einen aber erwischt... Gerade bei den Preisen heutzutage! Wäre der ein oder andere Verschleiß Vorgang in der Vergangenheit vielleicht schön gewesen, zu vermeiden. Wobei ich es halt gar nicht so beim entpacken sehe...
 
andy_m4 schrieb:
Davon würde ich jetzt nicht unbedingt ausgehen.

Davon wuerde ich bei WinZip, 7-Zip und WinRAR ausgehen. Es gab vor Ewigkeiten mal "Meldungen" von denen bezueglich dieser Zip-Bomben. Ich such nicht selber. Es ging aber grundsaetzlich um das Einfuehren von Ressourcengrenzen, Reccursionsstop und Erkennen von unerklaerlichen Kompressionsraten etc. 🤷‍♂️

Matthias80 schrieb:
Test haben ja gezeigt, daß ssd's ein zichfaches mehr abkönnen als die Hersteller mit ihrer Garantie abdecken.

Eben das macht das Tool des TE, oder besser seine eigene Aussage, fuer diesen Punkt obsolet.

1793288580465.png

Ja es ist ein Verschleiss da. Nur stoert das wirklich? Ich denke nein.

Im Endeffekt bist Du dennoch in Deinem Post #29 voellig falsch abgebogen.

1793289159513.png
 
BFF schrieb:
Davon wuerde ich bei WinZip, 7-Zip und WinRAR ausgehen.
Ich lasse mich ja gerne eines besseren belehren, aber wenn ich beispielsweise man den 7-Zip-Quelltext durchsuche nach "bomb", "resource exhausion" und ähnlichen Begriffen sucht, findet man da nix.

Finde ich auch nachvollziehbar. Denn wie soll das Programm denn unterscheiden, ob 'ne hohe sehr hohe Kompressionsrate gewollt ist oder ungewollt.

BFF schrieb:
Es gab vor Ewigkeiten mal "Meldungen" von denen bezueglich dieser Zip-Bomben.
Das waren dann aber eher Sicherheitslücken. Sprich: Der Enpacker ließ sich durch entsprechend präparierte Dateien zu unerwünschten Verhalten (aka Sicherheitslücke) bewegen.

BFF schrieb:
Ich such nicht selber.
Das ist in Ordnung.
Nur sollte man dann vielleicht auch mit Mutmaßungen zurückhaltender sein.

BFF schrieb:
Es ging aber grundsaetzlich um das Einfuehren von Ressourcengrenzen
Ja. Aber genau das hatte ich ja adressiert mit Write-Limits.
 
andy_m4 schrieb:
7-Zip-Quelltext durchsuche nach "bomb", "resource exhausion" und ähnlichen Begriffen sucht, findet man da nix.

Echt jetzt? 🤣
Mit den Woertern im Qelltext kommt der Entwickler von 7-zip nicht mehr durch die TSA. 🤣

Anyway.
Es wurde definitiv bei allen bekannten Packern etwas getan wenn es sich um die Zip-Bomen handelt.
Im Zweifelsfall bau eine solche Bombe und probier es aus. Ob der im Windows inkludierte Entpacker damit klarkommt ist ein anderes Blatt.
 
Will ich kritischen Code lieber im RAM haben als auf der SSD? NEIN, ganz bestimmt nicht.
 
BFF schrieb:
Wäre jetzt kein Beweis für irgendwas. Aber wäre ja zumindest ein Anhaltspunkt.
btw. sind im Quelltext auch Kommentare und Dokumentation drin.

Ich mein, ich hab mich wenigstens bemüht.
Von Dir kommt lediglich ein substanzloses: "Ich hab irgendwie irgendwann mal irgendwas gehört, kann das aber nicht wieder geben und kann auch nix verlinken und rate hier nur rum".

Und DAS ist dann aber kein Problem, während Du bei anderen die (von mir aus auch unvollkommenen) Methoden ankreidest. 🤪
Merkst selbst, oder?

BFF schrieb:
Es wurde definitiv bei allen bekannten Packern etwas getan wenn es sich um die Zip-Bomen handelt.
Du kannst nix benennen oder verlinken, aber sagen das definitiv was getan wurde.
Ähm ja. Keine weiteren Fragen. 😁
 
BFF schrieb:
Das sollte man eigentlich niemanden unterstellen. Es sind nicht Deine Systeme.
Aber wenn Du schon so gut bist. 😉
Die SSD funktioniert immer noch wunderpraechtig wenn ich zum Thema Datenrettung z.B. eine SSD nuken muss. CDI meint da das es keinen Gesamtzustand mehr gibt. Woran das liegt hat mal wer irgendwo bei CB erklaert. Die SSD wurde bewusst (oft fast voll) beschrieben waehrend ihrer Laufzeit.

Anhang anzeigen 1773062

Anyway.



Haben da nicht so gut wie Alle eh schon eine "Spassbremse" eingebaut?



Das der Krams teuer geworden ist stimmt. Nur wird bei halbwegs vernuenftiger Qualitaet kaum einer mehr einen Datentraeger der sich SSD schimpft kaputt schreiben. Da nun unbedingt auf den RAM ausweichen zu muessen, welcher auch teuer geworden ist und den nicht jeder endlos hat, mag Deine Entscheidung sein.

Was ich von Dir wissen will ist, was Dein Tool macht, wenn ich mit 8 Gbyte physikalischem RAM auf einer W11 Home Kiste ein Archiv auspacken will was 6 GByte gross ist.



Das wird zu 99% auf veraltete Regeln hinauslaufen. Nutzer die Dein (Pro) Produkt mal kaufen sollen, wollen sich damit nicht wirklich beschaeftigen. Das hat irgndwie automatisch zu laufen.

Hi @Matthias80,

danke für dein kritisches Feedback und die berechtigte Frage am Ende! Genau dafür ist eine Projektvorstellung ja da.
Zur Frage mit dem 8 GB RAM System:
Da hast du vollkommen recht, das ist aktuell die architektonische Sollbruchstelle bei reinen In-Memory-Tools. Wenn du auf einer 8 GB Kiste (wo Windows 11 sich meistens schon 3–4 GB krallt) ein 6 GB Archiv entpacken willst, läuft der RAM über.
  • Aktueller Stand (v2.0): Das Programm würde in einen unkontrollierten MemoryError laufen und für den Nutzer einfrieren/ababstürzen. Das System bleibt stabil (Windows fängt das ab), aber die UX ist natürlich unschön.
  • Die Lösung für das nächste Update (v2.1): Ein auf GitHub eingereichter Issue hat genau das gestern auch bemängelt. Ich baue für die v2.1 einen Vorab-Sicherheitscheck ein (via psutil). Das Tool prüft vor dem Entpacken den exakt verfügbaren RAM. Ist das Archiv entpackt größer als der freie RAM minus Sicherheits-Puffer, bricht das Tool den Vorgang sofort sauber ab und gibt eine Meldung aus („Nicht genügend RAM vorhanden“), anstatt abzustürzen.
Zum Thema SSD-Verschleiß:
Natürlich schreiben moderne Qualitäts-SSDs heute viel mehr TBW als früher. Das Tool richtet sich primär an Power-User, die täglich gigantische Mengen (z.B. im dreistelligen GB-Bereich) temporär entpacken, modden oder testen – oder schlicht an Nutzer, die den Komfort schätzen, dass potenzieller Schadcode physisch nie die Festplatte berührt (Zero-Disk-Quarantäne).
Wer den RAM nicht hat oder das Feature nicht braucht, nutzt weiterhin 7-Zip – das ist völlig legitim! 😉

Viele Grüße

Sven
 
andy_m4 schrieb:
Ich mein, ich hab mich wenigstens bemüht.
Neee, hast nicht. 🤣

Ich hab klipperklar getippt das ich am TatschFone nicht suche. Das ich Gehörtes und Gelesene dennoch wiedergeben kann ist unbestritten. Das Du nicht damit zufrieden bist, ja ok. Ist ja bekannt.

@*Achilles*
Irgendwie passt Dein Zitat nicht. 👻
 
tomgit schrieb:
Anhand der einfachen Tatsache, dass man den Source Code nicht einsehen kann.

Python:
import io
import os
import queue
import sys
import threading
import tkinter as tk
from tkinter import (filedialog, messagebox, scrolledtext, simpledialog)
import zipfile
try:
    import py7zr
except ImportError:
    py7zr = None
try:
    import rarfile
except ImportError:
    rarfile = None
try:
    from watchdog.events import FileSystemEventHandler
    from watchdog.observers import Observer
except ImportError:
    FileSystemEventHandler, Observer = None, None
try:
    from win10toast import ToastNotifier
except ImportError:
    ToastNotifier = None
try:
    import yara
except ImportError:
    yara = None
MAX_DATEI_GROESSE = 209715200
MAX_GESAMT_GROESSE = 1073741824
MAX_KOMPRESSIONS_RATIO = 100
DOWNLOADS_ORDNER = os.path.join(os.path.expanduser('~'), 'Downloads')
GEFAEHRLICHE_ENDUNGEN = {'.js', '.py', '.sh', '.bat', '.cmd', '.com', '.dll', '.exe', '.jse', '.lnk', '.msc', '.pif', '.ps1', '.scr', '.sys', '.vbe', '.vbs', '.wsf', '.wsh'}
YARA_REGELN_TEXT = '\nrule Verdaechtiges_Muster_Entdeckt {\n    strings:\n        $cmd_exec = "cmd.exe /c" nocase\n        $powershell = "powershell -nop -w hidden" nocase\n        $download_string = "DownloadString(" nocase\n        $shellcode_pattern = { E8 00 00 00 00 58 }\n    condition:\n        any of them\n}\n'

class DownloadWatcher(FileSystemEventHandler):
    def __init__(self, app_callback):
        self.app_callback = app_callback

    def on_created(self, event):
        if not event.is_directory:
            _, ext = os.path.splitext(event.src_path.lower())
            if ext in ('.zip', '.7z', '.rar'):
                self.app_callback(event.src_path)


class RAMpartApp:
    def __init__(self, root):
        self.root = root
        self.root.title('RAMpart Extractor Pro - Zero-Disk Quarantäne v2.0')
        self.root.geometry('700x550')
        self.root.configure(bg='#1e1e1e')
        self.queue = queue.Queue()
        titel = tk.Label(root, text='🛡️ RAMpartExtractor', font=('Arial', 20, 'bold'), fg='#00ff66', bg='#1e1e1e')
        titel.pack(pady=(15, 0))
        untertitel = tk.Label(root, text='by Sven Nahrstedt', font=('Times New Roman', 11, 'italic'), fg='#ffffff', bg='#1e1e1e')
        untertitel.pack(pady=(2, 15))
        self.erstelle_pfad_gui()
        self.btn_start = tk.Button(root, text='ARCHIV SICHER IM RAM PRÜFEN & ENTPACKEN', font=('Arial', 11, 'bold'), bg='#00ff66', fg='black', command=self.starte_manuell)
        self.btn_start.pack(pady=10, fill='x', padx=20)
        tk.Label(root, text='Sicherheits-Protokoll:', fg='white', bg='#1e1e1e').pack(anchor='w', padx=20)
        self.log_area = scrolledtext.ScrolledText(root, bg='#111111', fg='#00ff66', font=('Consolas', 10))
        self.log_area.pack(padx=20, pady=5, fill='both', expand=True)
        self.log('[*] RAMpart Schilde online. System bereit.')
        self.pruefe_module()
        self.starte_downloads_watcher()
        self.root.after(100, self.verarbeite_queue)

    def erstelle_pfad_gui(self):
        f1 = tk.Frame(self.root, bg='#1e1e1e')
        f1.pack(pady=3, fill='x', padx=20)
        tk.Label(f1, text='Archiv-Pfad: ', fg='white', bg='#1e1e1e', width=12).pack(side='left')
        self.entry_zip = tk.Entry(f1, bg='#2d2d2d', fg='white')
        self.entry_zip.pack(side='left', fill='x', expand=True, padx=5)
        tk.Button(f1, text='Durchsuchen...', command=self.waehle_archiv, bg='#444').pack(side='right')
        f2 = tk.Frame(self.root, bg='#1e1e1e')
        f2.pack(pady=3, fill='x', padx=20)
        tk.Label(f2, text='Zielordner: ', fg='white', bg='#1e1e1e', width=12).pack(side='left')
        self.entry_ziel = tk.Entry(f2, bg='#2d2d2d', fg='white')
        self.entry_ziel.pack(side='left', fill='x', expand=True, padx=5)
        tk.Button(f2, text='Durchsuchen...', command=self.waehle_ziel, bg='#444').pack(side='right')

    def pruefe_module(self):
        if not py7zr:
            self.log("[-] Warnung: 'py7zr' fehlt. Keine .7z Unterstützung.")
        if not rarfile:
            self.log("[-] Warnung: 'rarfile' fehlt. Keine .rar Unterstützung.")
        if not Observer:
            self.log("[-] Warnung: 'watchdog' fehlt. Downloads-Auto-Scan deaktiviert.")

    def send_windows_notification(self, titel, nachricht):
        '''Sendet eine native Windows-Push-Nachricht ins Info-Center.'''

        if ToastNotifier:
            try:
                toaster = ToastNotifier()
                toaster.show_toast(titel, nachricht, icon_path=None, duration=5, threaded=True)
                return
            except:
                pass

    def starte_downloads_watcher(self):
        if Observer:
            handler = DownloadWatcher(self.auto_abfangen_callback)
            self.observer = Observer()
            self.observer.schedule(handler, path=DOWNLOADS_ORDNER, recursive=False)
            self.observer.start()
            self.log('[+] Auto-Schild aktiv: Überwache Downloads-Ordner nach neuen Archiven...')

    def auto_abfangen_callback(self, datei_pfad):
        self.queue.put(datei_pfad)

    def verarbeite_queue(self):
        try:
            datei_pfad = self.queue.get_nowait()
            self.entry_zip.delete(0, tk.END)
            self.entry_zip.insert(0, datei_pfad)
            self.send_windows_notification('RAMpart Schutzschild', f'Neues Archiv im Download-Ordner abgefangen: {os.path.basename(datei_pfad)}')
            desktop = os.path.join(os.path.expanduser('~'), 'Desktop')
            self.entry_ziel.delete(0, tk.END)
            self.entry_ziel.insert(0, os.path.join(desktop, 'RAMpart_Sicher_Extrakt'))
            self.starte_prozess(datei_pfad, self.entry_ziel.get())
        except queue.Empty:
            pass
        self.root.after(100, self.verarbeite_queue)

    def log(self, text):
        self.log_area.insert(tk.END, text + '\n')
        self.log_area.see(tk.END)
        self.root.update_idletasks()

    def waehle_archiv(self):
        datei = filedialog.askopenfilename(filetypes=[('Archive', '*.zip *.7z *.rar')])
        if datei:
            self.entry_zip.delete(0, tk.END)
            self.entry_zip.insert(0, datei)

    def waehle_ziel(self):
        ordner = filedialog.askdirectory()
        if ordner:
            self.entry_ziel.delete(0, tk.END)
            self.entry_ziel.insert(0, ordner)

    def frage_passwort(self):
        return simpledialog.askstring('Passwort benötigt', 'Dieses Archiv ist verschlüsselt.\nBitte gib das Passwort ein:', show='*')

    def starte_manuell(self):
        self.starte_prozess(self.entry_zip.get(), self.entry_ziel.get())

    def starte_prozess(self, archiv_pfad, ziel_ordner):
        if not archiv_pfad or not ziel_ordner:
            messagebox.showerror('Fehler', 'Pfade unvollständig!')
            return
        self.log_area.delete('1.0', tk.END)
        self.log(f'[*] STARTE HARDENING-ANALYSE FÜR: {os.path.basename(archiv_pfad)}')
        yara_scanner = None
        if yara:
            try:
                yara_scanner = yara.compile(source=YARA_REGELN_TEXT)
            except:
                pass
        _, ext = os.path.splitext(archiv_pfad.lower())
        threading.Thread(target=self.quarantaene_entpacken, args=(archiv_pfad, ziel_ordner, ext, yara_scanner), daemon=True).start()

    def quarantaene_entpacken(self, pfad, ziel, ext, yara_scanner):
        try:
            with open(pfad, 'rb') as f:
                ram_buffer = io.BytesIO(f.read())
            self.log('[+] Datei erfolgreich in Quarantäne-RAM isoliert.')
        except Exception as e:
            self.log(f'[!] Ladefehler: {e}')
        isolierter_speicher = {}
        passwort = None
        try:
            if ext == '.zip':
                with zipfile.ZipFile(ram_buffer) as archiv:
                    if archiv.namelist() and hasattr(archiv, 'testzip'):
                        try:
                            archiv.testzip()
                        except RuntimeError:
                            passwort = self.frage_passwort()
                            if not passwort:
                                pass
                for name in archiv.namelist():
                    if name.endswith('/'):
                        continue
                    if self.pruefe_bedrohung(name, archiv.getinfo(name)):
                        return
                    isolierter_speicher[name] = archiv.read(name, pwd=passwort.encode() if passwort else None)
            elif ext == '.7z' and py7zr:
                pass
            elif ext == '.rar' and rarfile:
                with rarfile.RarFile(ram_buffer) as archiv:
                    if archiv.needs_password():
                        passwort = self.frage_passwort()
                    for info in archiv.infolist():
                        if info.isdir():
                            continue
                        if info.file_size > MAX_DATEI_GROESSE:
                            self.log(f'[!] Datei zu groß: {info.filename}')
                            return
                        isolierter_speicher[info.filename] = archiv.read(info.filename, psw=passwort)
        except Exception as e:
            self.log(f'[!] Fehler bei der Extraktion: {e}')
        if yara_scanner:
            self.log('[*] Starte YARA-Malware-Signatur-Scan im RAM...')
            for name, datei_bytes in isolierter_speicher.items():
                treffer = yara_scanner.match(data=datei_bytes)
                if not treffer:
                    continue
                alarm_msg = f"VIRUS ERKANNT: '{name}' enthält bekannte Malware-Muster!"
                self.log(f'[!!!] {alarm_msg}')
                self.send_windows_notification('🚨 KRITISCHER ALARM', alarm_msg)
                messagebox.showerror('ALARM', alarm_msg)
                return
        self.log('[+] Alle Schilde grün. Keine Bedrohungen gefunden.')
        self.log('[*] Schreibe bereinigte Daten auf SSD...')
        for name, datei_bytes in isolierter_speicher.items():
            end_pfad = os.path.abspath(os.path.join(ziel, name))
            os.makedirs(os.path.dirname(end_pfad), exist_ok=True)
            with open(end_pfad, 'wb') as f_out:
                f_out.write(datei_bytes)
        self.log(f'[++++] SUCCESS: {len(isolierter_speicher)} Dateien sicher entpackt.')
        self.send_windows_notification('RAMpart Schutzschild', 'Archiv absolut sicher entpackt!')

    def pruefe_bedrohung(self, name, info):
        _, endung = os.path.splitext(name.lower())
        if endung in GEFAEHRLICHE_ENDUNGEN:
            self.log(f"[!] BLOCKIERT: Gefährliche Endung '{endung}' bei '{name}'.")
            self.send_windows_notification('Bedrohung blockiert', f'Datei isoliert: {name}')
            return True
        if info.file_size > MAX_DATEI_GROESSE:
            self.log(f"[!] BLOCKIERT: Datei '{name}' überschreitet RAM-Größenlimit.")
            return True
        return False


if __name__ == '__main__':
    root = tk.Tk()
    app = RAMpartApp(root)
    root.mainloop()

was die ki dazu sagt (sorry, keine lust das alles manuell auszuformulieren...):


Main issues / bugs:
  • .7z extraction is not implemented at all (pass).
  • zipfile.ZipFile(ram_buffer) is used, but archiv is referenced outside the with block; that works only because Python keeps the variable alive, but it’s sloppy and fragile.
  • testzip() does not detect encryption the way this code assumes. The password detection logic is unreliable.
  • rarfile.RarFile(ram_buffer) is likely wrong: rarfile usually expects a filename or a file-like object with proper support, but password handling and reading from BytesIO may not work as intended depending on backend.
  • No total-extracted-size enforcement, despite MAX_GESAMT_GROESSE being defined.
  • No compression-ratio check, despite MAX_KOMPRESSIONS_RATIO being defined.
  • No path traversal protection. A malicious archive name like ../../evil.exe could escape the target folder.
  • No symlink handling safeguards.
  • yara_scanner.match(data=datei_bytes) scans each file, but there’s no exception handling around YARA matches.
  • GUI thread safety: quarantaene_entpacken() runs in a worker thread but directly calls Tkinter methods (log, messagebox, entry_* updates). Tkinter is not thread-safe.
  • self.root.update_idletasks() inside log() from a worker thread is also unsafe.
  • The Downloads watcher may keep running forever with no shutdown cleanup.
  • send_windows_notification() silently swallows all exceptions.
  • io, sys, and threading are used, but sys seems unused.
Security problems:
  • The dangerous-extension blacklist is not enough; archives can contain harmless extensions with malicious content.
  • Extracting after only extension checks still risks zip bombs, path traversal, and resource exhaustion.
  • Writing files to disk happens without validating that the resolved path stays under ziel.
Design issues:
  • A lot of hardcoded behavior, no configuration UI.
  • Mixed German/English names and strings make maintenance harder.
  • The code is trying to be “security software” but lacks the core defensive controls needed for that claim.
Suggested fixes:
  • Add safe path resolution to prevent directory traversal.
  • Enforce total uncompressed size and compression ratio.
  • Move all Tkinter updates to the main thread via root.after(...).
  • Implement proper 7z support.
  • Replace password detection with explicit archive-encryption checks per library.
  • Cleanly stop the observer on exit.
  • Validate extracted filenames and reject absolute paths, .., and weird device paths on Windows.
  • Add structured logging and error reporting.
Biggest concern:
  • The app gives a sense of safety, but as written it is not robust enough to safely handle untrusted archives.
 
  • Gefällt mir
Reaktionen: Knergy, Wo bin ich hier, Xero261286 und eine weitere Person
GokuSS4 schrieb:
hat die KI so vorgeschlagen, soll gut klingen
Nein, ich arbeite mit Python schon über 20 Jahre. Klar es gibt auch Zonen, wo man sich einlesen muss, oder wieder im TS jemanden fragt der gute Erfahrungen in diesem Bereich hat, der einen Helfen kann. Bis jetzt benötige ich keine Hilfe im Coden.

Danke

Ich möchte einfach nur , Verbesserungen planen und einbinden. Mit eurer Hilfe.
 
*Achilles* schrieb:
Das Tool richtet sich primär an Power-User, die täglich gigantische Mengen (z.B. im dreistelligen GB-Bereich)
Und 3-stellig GB an RAM haben dann die Power-User über?
Und wenn sie das über haben, wieso nutzen die dann nicht einfach ne RAM-Disk? Als Power-User schaffen die die sicher reinzurichten.

*Achilles* schrieb:
dass potenzieller Schadcode physisch nie die Festplatte berührt
Was ist denn das für ein komisches Argument. Als Schadcode wird nicht automatisch dadurch problematisch, weil er Deine Festplatte berührt. Du tust so, als wäre die dann instant kaputt oder infiziert oder was auch immer.

*Achilles* schrieb:
Wer den RAM nicht hat oder das Feature nicht braucht, nutzt weiterhin 7-Zip – das ist völlig legitim!
Die Frage ist ja eher, ob man das mit Bordmitteln alles nicht besser hinkriegt.
Also wenn ich jetzt viel zu testen hab, schaffe ich mir eine isolierte Umgebung und sorge dann dafür, das alles contained ist.
Das Ding ist, Dein Tool deckt halt eine spezifische Bedrohung ab. Gibt aber noch zig andere Bedrohungen die ich beachten möchte. Ich brauche dann definitiv weitere Tools.

Und dann stellt sich halt wiederum die Frage: Warum nehm' ich nicht einfach eine isolierte Umgebung und muss dann nicht mehr händisch gucken und darauf achten, das wirklich alle potentiell problematischen Szenarien abgedeckt sind.

BFF schrieb:
Neee, hast nicht.
Kann man sehen wie man will.
Ich bin da auch gar nicht in der Bringschuld.
Derjenige der Dinge behauptet muss die belegen.
 
So und jetzt an jene die sich den Kopf darüber zerbrechen,

Wirklich?, da habt ihr die EXE ja schneller seziert als gedacht – Respekt an @0x8100 für das Reverse-Engineering! 😉 Genau das ist der Grund, warum ich das Projekt hier vorgestellt habe: Ich wollte echtes, ungeschöntes Feedback, um das Tool auf ein professionelles Level zu bringen.
Zu der geposteten KI-Analyse: Die Punkte treffen teilweise den Nagel auf den Kopf. Da sind absolut valide Kritikpunkte dabei, die ich im aktuellen Entwicklungsstand (v2.0) tatsächlich noch als „Sloppy Code“ drin hatte oder die schlicht unvollständig waren.
Ich nehme mir die Liste direkt als Roadmap für das Update v2.1:
  1. Thread-Sicherheit (Tkinter): Vollkommen richtig. Dass quarantaene_entpacken im Worker-Thread direkt UI-Elemente manipuliert, ist unsauber und wird auf root.after() umgestellt.
  2. Path Traversal (Zip-Slip): Ein kritischer Punkt. Ich werde eine saubere Pfad-Validierung einbauen, damit manipulierte Archive nicht über ../ aus dem Zielverzeichnis ausbrechen können.
  3. Ressourcen-Limits: Die Konstanten MAX_GESAMT_GROESSE und MAX_KOMPRESSIONS_RATIO waren im Code zwar schon definiert, aber die Durchsetzung in der Schleife fehlte noch – das wird jetzt scharf geschaltet.
  4. 7z-Support: Das pass wird durch die echte In-Memory-Logik für py7zr ersetzt.
  5. RAM-Check: Wie im vorherigen Post erwähnt, kommt die Abfrage über psutil rein, um den MemoryError bei kleinen Systemen (8 GB) abzufangen.
Das Tool ist als Hobby-Projekt gestartet, um das Konzept der reinen In-Memory-Isolierung auszuprobieren. Dank eurer Analyse weiß ich jetzt ganz genau, an welchen Schrauben ich drehen muss, um aus der 2.0-Version ein wirklich sicheres Werkzeug zu machen.
Ich setze mich ans Code-Update und melde mich, sobald die v2.1 auf GitHub bereitsteht!

Danke an jeden.
 
  • Gefällt mir
Reaktionen: EscobarPablo
0x8100 schrieb:
was die ki dazu sagt (sorry, keine lust das alles manuell auszuformulieren...)
Diese Anmerkungen hast du aber bei praktisch jeder Anwendung, sogar bei von mit ki geschriebenen Anwendungen, also das Argument zählt nur halb.
 
BFF schrieb:
Was ich von Dir wissen will ist, was Dein Tool macht, wenn ich mit 8 Gbyte physikalischem RAM auf einer W11 Home Kiste ein Archiv auspacken will was 6 GByte gross ist.
Wer glaubt daas die Anforderungen Sinn machen, der denkt erst recht nicht an sowas.
Ergänzung ()

*Achilles* schrieb:
Ich setze mich ans Code-Update und melde mich, sobald die v2.1 auf GitHub bereitsteht!
Wir können es kaum erwarten.
 
EscobarPablo schrieb:
Diese Anmerkungen hast du aber bei praktisch jeder Anwendung
gerade die sicherheitskritischen anmerkungen sind aber richtig - nicht ganz unwichtig bei einem programm, das unbekannte daten verarbeiten und die sicherheit für den user verbessern soll, oder?
 
  • Gefällt mir
Reaktionen: tomgit und Alter_Falter
@0x8100 Ich hab gar nicht in Abrede gestellt, was du und ki durch reverse engineering herausgefunden habt. Nur man muss anderen auch eine Chance geben. Ich zweifle nicht daran, dass er in guter Absicht handelt.

(Meine Beiträge müssen immer erst freigeschaltet werden, was manchmal dauert, das Spam-Sys mag mich wohl nicht) :(
 
Hi zusammen,

erst einmal ein riesiges Dankeschön für das extrem detaillierte und ungeschönte Feedback – vor allem an @0x8100 für das Reverse-Engineering und die fundierte Analyse sowie an @BFF und @Matthias80 für die kritischen Fragen bezüglich RAM und SSD! Genau dafür habe ich das Projekt hier vorgestellt.
Ich habe mir eure Punkte zu Herzen genommen und das Tool in den letzten Stunden komplett auf den Kopf gestellt. Die neue Version 2.1 steht ab sofort als Open-Source-Quellcode und als Standalone-EXE auf GitHub bereit.

Hier ist die Antwort auf eure Kritikpunkte, die im neuen Update alle umgesetzt wurden:
  1. Volle Thread-Sicherheit (Tkinter-Fix): Der Worker-Thread feuert nicht mehr wild in die UI. Die gesamte Kommunikation läuft jetzt über eine thread-sichere gui_queue, die asynchron vom Haupt-Thread via root.after() verarbeitet wird. Keine GUI-Freezes oder Abstürze mehr.
  2. Echter Path-Traversal-Schutz (Zip-Slip): Eine harte Pfad-Validierung (validiere_pfad) löst relative Pfade auf und verhindert rigoros das Ausbrechen (../) aus dem Zielverzeichnis.
  3. Scharfe Ressourcen-Limits: Die Konstanten für maximale Gesamtgröße und Kompressions-Ratio (Schutz vor ZIP-Bomben) werden nun live bei jeder Datei in der Schleife mathematisch erzwungen.
  4. Echtes In-Memory-7z: Der alte Platzhalter ist weg. Über die Streaming-Architektur von py7zr (readall()) werden .7z-Archive nun zu 100 % verlustfrei im RAM gehalten.
  5. Dynamischer RAM-Check (psutil): Um den berechtigten Einwand bei kleineren Systemen (8 GB) abzufangen, prüft das Tool vorab den real verfügbaren RAM. Droht der Speicher zu überlaufen, bricht das Programm kontrolliert mit einer Meldung ab, anstatt Windows in den Freeze zu treiben.
  6. Sauberes Watcher-Terminieren: Beim Schließen des Fensters wird der Watchdog-Hintergrundthread nun ordnungsgemäß gestoppt und entlassen (.stop() und .join()). Keine Zombie-Prozesse mehr im Taskmanager.
  7. Modulare Struktur & UI: Die Anwendung wurde in ein sauberes 3-Dateien-System aufgeteilt (main.py, security.py, extractor.py). Zudem gibt es jetzt einen Ladebalken während des SSD-Schreibens und eine exakte Abrechnung der abgelegten Gigabytes im Log.
Schaut gerne mal in den Quellcode rein – maximale Transparenz ist mir bei einem solchen Quarantäne-Tool extrem wichtig.

Zum GitHub-Repository (Quellcode & Releases):
https://github.com/sven007sven/RAMpartExtractor_Pro

Ich freue mich auf eure zweite Testrunde!
Viele Grüße

Sven
 
  • Gefällt mir
Reaktionen: Matthias80
Erst schreibst Du du weißt noch nicht ob Open Source oder Freeware. Dann jetzt das dir maximale Transparenz extrem wichtig ist. ;-)
 
@Beneee Haha, erwischt! 😉 Du hast vollkommen recht, der Schwenk kam jetzt schnell.
Die v2.1 ist das direkte Ergebnis eurer Kritik – und ich finde, genau so sollte Community-Entwicklung laufen!

Haut rein !!!
 
Status
Für weitere Antworten geschlossen.
Zurück
Oben