# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

#

# Translators:

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.15\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-09-28 03:11+0000\n"

"PO-Revision-Date: 2026-10-15 06:00+0200\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: German (https://github.com/python/python-docs-de)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../howto/remote_debugging.rst:4

msgid "Remote debugging attachment protocol"

msgstr "Protokoll zum Anhängen eines Debuggers aus der Ferne"

#: ../../howto/remote_debugging.rst:6

msgid ""

"This protocol enables external tools to attach to a running CPython process "

"and execute Python code remotely."

msgstr ""

"Dieses Protokoll erlaubt es externen Werkzeugen, sich an einen laufenden "

"CPython-Prozess anzuhängen und Python-Code aus der Ferne auszuführen."

#: ../../howto/remote_debugging.rst:9

msgid ""

"Attaching to another Python process may require additional permissions or "

"configuration, depending on the platform."

msgstr ""

"Sich an einen anderen Python-Prozess anzuhängen kann je nach Plattform "

"zusätzliche Berechtigungen oder Konfiguration erfordern."

#: ../../howto/remote_debugging.rst:13

msgid "Disabling remote debugging"

msgstr "Debuggen aus der Ferne abschalten"

#: ../../howto/remote_debugging.rst:15

msgid "To disable remote debugging support, use any of the following:"

msgstr ""

"Um die Unterstützung für das Debuggen aus der Ferne abzuschalten, verwende "

"eine der folgenden Möglichkeiten:"

#: ../../howto/remote_debugging.rst:17

msgid ""

"Set the :envvar:`PYTHON_DISABLE_REMOTE_DEBUG` environment variable to ``1`` "

"before starting the interpreter."

msgstr ""

"Setze die Umgebungsvariable :envvar:`PYTHON_DISABLE_REMOTE_DEBUG` auf ``1``, "

"bevor du den Interpreter startest."

#: ../../howto/remote_debugging.rst:19

msgid "Use the :option:`-X disable_remote_debug` command-line option."

msgstr "Verwende die Befehlszeilenoption :option:`-X disable_remote_debug`."

#: ../../howto/remote_debugging.rst:20

msgid "Compile Python with the :option:`--without-remote-debug` build flag."

msgstr "Kompiliere Python mit dem Build-Flag :option:`--without-remote-debug`."

#: ../../howto/remote_debugging.rst:25

msgid "Permission requirements"

msgstr "Anforderungen an die Berechtigungen"

#: ../../howto/remote_debugging.rst:27

msgid ""

"Attaching to a running Python process for remote debugging requires special "

"configuration on most platforms. The specific requirements and "

"troubleshooting steps depend on your operating system:"

msgstr ""

"Sich zum Debuggen aus der Ferne an einen laufenden Python-Prozess anzuhängen "

"erfordert auf den meisten Plattformen eine besondere Konfiguration. Die "

"genauen Anforderungen und die Schritte zur Fehlersuche hängen von deinem "

"Betriebssystem ab:"

#: ../../howto/remote_debugging.rst:32

msgid "Linux"

msgstr "Linux"

#: ../../howto/remote_debugging.rst:33

msgid ""

"In general, you can debug your own processes, but there are several common "

"configurations that may disable this. Some Linux distributions enable "

"**ptrace restrictions**, aka \"Yama,\" as a form of system hardening. Recent "

"versions of the ``setpriv`` command (util-linux 2.41, released June 2025) "

"let you loosen ptrace restrictions on a per-process basis:"

msgstr ""

"Im Allgemeinen kannst du deine eigenen Prozesse debuggen, aber es gibt "

"mehrere verbreitete Konfigurationen, die das abschalten können. Manche Linux-"

"Distributionen schalten als Form der Systemhärtung **ptrace-Beschränkungen** "

"ein, auch „Yama“ genannt. Neuere Fassungen des Befehls ``setpriv`` (util-"

"linux 2.41, veröffentlicht im Juni 2025) erlauben es dir, die ptrace-"

"Beschränkungen je Prozess zu lockern:"

#: ../../howto/remote_debugging.rst:39

msgid "``setpriv --ptracer any python3``"

msgstr "``setpriv --ptracer any python3``"

#: ../../howto/remote_debugging.rst:41

msgid ""

"(This is configured on the process *being debugged*.) You can also turn off "

"ptrace restrictions for all processes until reboot with:"

msgstr ""

"(Das wird an dem Prozess eingestellt, der *gedebuggt werden soll*.) Du "

"kannst die ptrace-Beschränkungen bis zum nächsten Neustart auch für alle "

"Prozesse abschalten:"

#: ../../howto/remote_debugging.rst:44

msgid "``echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope``"

msgstr "``echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope``"

#: ../../howto/remote_debugging.rst:46

msgid "This can also be configured persistently, usually in ``/etc/sysctl.d``."

msgstr ""

"Das lässt sich auch dauerhaft einstellen, üblicherweise in ``/etc/sysctl.d``."

#: ../../howto/remote_debugging.rst:50

msgid ""

"Disabling ``ptrace_scope`` reduces system hardening and should only be done "

"in low-security environments."

msgstr ""

"``ptrace_scope`` abzuschalten verringert die Systemhärtung und sollte nur in "

"Umgebungen mit geringem Sicherheitsbedarf geschehen."

#: ../../howto/remote_debugging.rst:53

msgid ""

"It is also possible that the ``ptrace`` system call is disabled because of a "

"security filter. In particular, this was common with older versions of some "

"container software. Docker 19.03 or newer (released 2019) and containerd "

"1.6.7 or newer (released 2022) will automatically allow usage of the "

"``ptrace`` system call inside containers, when running on Linux kernel 4.8 "

"or higher. If you cannot upgrade to these versions, you can create your "

"container with an option like ``--security-opt seccomp=unconfined`` to "

"disable the system call security filter for that container. This weakens the "

"container's isolation and should only be done in low-security environments."

msgstr ""

"Es ist auch möglich, dass der Systemaufruf ``ptrace`` wegen eines "

"Sicherheitsfilters abgeschaltet ist. Das war insbesondere bei älteren "

"Fassungen mancher Container-Software verbreitet. Docker 19.03 oder neuer "

"(veröffentlicht 2019) und containerd 1.6.7 oder neuer (veröffentlicht 2022) "

"erlauben die Verwendung des Systemaufrufs ``ptrace`` innerhalb von "

"Containern automatisch, wenn sie auf Linux-Kernel 4.8 oder höher laufen. "

"Wenn du nicht auf diese Fassungen aktualisieren kannst, kannst du deinen "

"Container mit einer Option wie ``--security-opt seccomp=unconfined`` "

"erzeugen, um den Sicherheitsfilter für Systemaufrufe für diesen Container "

"abzuschalten. Das schwächt die Isolation des Containers und sollte nur in "

"Umgebungen mit geringem Sicherheitsbedarf geschehen."

#: ../../howto/remote_debugging.rst:63

msgid ""

"If you need to trace a process that you *do not* own, you will need "

"superuser access or equivalent. This also applies to processes that have "

"changed their security credentials, e.g., set-user-ID or set-group-ID "

"processes (though this is unusual for Python). Try running the debugging "

"command with ``sudo -E``."

msgstr ""

"Wenn du einen Prozess verfolgen musst, der dir *nicht* gehört, brauchst du "

"Superuser-Zugriff oder etwas Gleichwertiges. Das gilt auch für Prozesse, die "

"ihre Sicherheitsmerkmale geändert haben, etwa Prozesse mit set-user-ID oder "

"set-group-ID (was bei Python allerdings unüblich ist). Versuche, den Debug-"

"Befehl mit ``sudo -E`` auszuführen."

#: ../../howto/remote_debugging.rst:70

msgid ""

"The ``CAP_SYS_PTRACE`` capability is equivalent to superuser access, in that "

"it allows debugging *any* process, not just your own. You may see advice on "

"the internet suggesting using it to work around ptrace restrictions or "

"system call filters. This may work in practice, as would ``sudo``, but this "

"gives the debugging process much more access than it needs and should only "

"be done in low-security environments."

msgstr ""

"Die Fähigkeit ``CAP_SYS_PTRACE`` entspricht Superuser-Zugriff, insofern sie "

"das Debuggen *jedes* Prozesses erlaubt und nicht nur der eigenen. Im "

"Internet findest du vielleicht den Rat, sie zu verwenden, um ptrace-"

"Beschränkungen oder Filter für Systemaufrufe zu umgehen. In der Praxis kann "

"das funktionieren, genau wie ``sudo``, aber es gibt dem Debug-Prozess viel "

"mehr Zugriff, als er braucht, und sollte nur in Umgebungen mit geringem "

"Sicherheitsbedarf geschehen."

#: ../../howto/remote_debugging.rst:77

msgid ""

"Finally, note that a process can only have one tracer at a time. If you have "

"already attached to a Python process under ``strace``, ``gdb``, etc., you "

"won't be able to simultaneously use remote debugging. (Superuser access "

"cannot get around this restriction.)"

msgstr ""

"Beachte schließlich, dass ein Prozess immer nur einen Verfolger haben kann. "

"Wenn du dich an einen Python-Prozess schon mit ``strace``, ``gdb`` oder "

"Ähnlichem angehängt hast, kannst du das Debuggen aus der Ferne nicht "

"gleichzeitig verwenden. (Superuser-Zugriff hilft über diese Beschränkung "

"nicht hinweg.)"

#: ../../howto/remote_debugging.rst:83

msgid "macOS"

msgstr "macOS"

#: ../../howto/remote_debugging.rst:84

msgid "By default, macOS disables the ability to debug other processes."

msgstr ""

"Standardmäßig schaltet macOS die Möglichkeit ab, andere Prozesse zu debuggen."

#: ../../howto/remote_debugging.rst:86

msgid ""

"You can modify your Python binary to opt in to being debugged by giving it "

"an **ad-hoc code signature** with an **entitlement** enabling it to be "

"debugged. (An ad-hoc \"signature\" is just a configuration without any "

"actual cryptographic signature or a need for a certificate or anything else "

"such as an Apple developer program membership.)"

msgstr ""

"Du kannst deine Python-Programmdatei so verändern, dass sie dem Debuggen "

"zustimmt – indem du ihr eine **Ad-hoc-Codesignatur** mit einer "

"**Berechtigung** gibst, die das Debuggen erlaubt. (Eine Ad-hoc-„Signatur“ "

"ist nur eine Konfiguration ohne echte kryptografische Signatur und ohne die "

"Notwendigkeit eines Zertifikats oder einer Mitgliedschaft im Apple-"

"Entwicklerprogramm.)"

#: ../../howto/remote_debugging.rst:92

msgid ""

"The following commands will create a file ``get-task-allow.plist`` with the "

"necessary entitlement and add it to the Python binary:"

msgstr ""

"Die folgenden Befehle erzeugen eine Datei ``get-task-allow.plist`` mit der "

"nötigen Berechtigung und fügen sie der Python-Programmdatei hinzu:"

#: ../../howto/remote_debugging.rst:95

msgid ""

"echo '{\"com.apple.security.get-task-allow\": true}' | plutil -convert xml1 -"

"o get-task-allow.plist -\n"

"codesign --sign - --entitlements get-task-allow.plist path/to/bin/python3"

msgstr ""

"echo '{\"com.apple.security.get-task-allow\": true}' | plutil -convert xml1 -"

"o get-task-allow.plist -\n"

"codesign --sign - --entitlements get-task-allow.plist path/to/bin/python3"

#: ../../howto/remote_debugging.rst:100

msgid ""

"where ``path/to/bin/python3`` is the path to your Python binary, which you "

"can find by e.g. running ``which python3`` or evaluating ``sys."

"base_executable`` at the Python REPL. (These instructions are for a non-"

"framework build of Python. Framework builds may need to be configured "

"differently.)"

msgstr ""

"wobei ``path/to/bin/python3`` der Pfad zu deiner Python-Programmdatei ist, "

"den du zum Beispiel über ``which python3`` oder durch Auswerten von ``sys."

"base_executable`` in der Python-REPL findest. (Diese Anweisungen gelten für "

"einen Python-Build ohne Framework. Framework-Builds müssen möglicherweise "

"anders eingerichtet werden.)"

#: ../../howto/remote_debugging.rst:105

msgid ""

"You should then be able to debug your own Python processes started with that "

"binary."

msgstr ""

"Danach solltest du deine eigenen Python-Prozesse debuggen können, die mit "

"dieser Programmdatei gestartet wurden."

#: ../../howto/remote_debugging.rst:108

msgid ""

"Alternatively, much as with Linux, processes with superuser privileges e.g. "

"``sudo`` are not subject to this check and can debug any user's process on "

"the system (though there are additional checks on specific binaries, such as "

"OS-provided commands, due to System Integrity Protection)."

msgstr ""

"Wie unter Linux unterliegen Prozesse mit Superuser-Rechten, etwa über "

"``sudo``, dieser Prüfung nicht und können jeden Prozess jedes Benutzers auf "

"dem System debuggen (wobei es wegen des System Integrity Protection "

"zusätzliche Prüfungen für bestimmte Programmdateien gibt, etwa für vom "

"Betriebssystem bereitgestellte Befehle)."

#: ../../howto/remote_debugging.rst:114

msgid "Windows"

msgstr "Windows"

#: ../../howto/remote_debugging.rst:115

msgid ""

"To attach to another process, you usually need to run your debugging tool "

"with administrative privileges. Start the command prompt or terminal as "

"Administrator."

msgstr ""

"Um dich an einen anderen Prozess anzuhängen, musst du dein Debug-Werkzeug "

"üblicherweise mit Administratorrechten ausführen. Starte die "

"Eingabeaufforderung oder das Terminal als Administrator."

#: ../../howto/remote_debugging.rst:119

msgid ""

"Some processes may still be inaccessible even with Administrator rights, "

"unless you have the ``SeDebugPrivilege`` privilege enabled."

msgstr ""

"Manche Prozesse können selbst mit Administratorrechten unzugänglich bleiben, "

"sofern du nicht das Recht ``SeDebugPrivilege`` eingeschaltet hast."

#: ../../howto/remote_debugging.rst:122

msgid ""

"To resolve file or folder access issues, adjust the security permissions:"

msgstr ""

"Um Zugriffsprobleme bei Dateien oder Ordnern zu lösen, passe die "

"Sicherheitsberechtigungen an:"

#: ../../howto/remote_debugging.rst:124

msgid "Right-click the file or folder and select **Properties**."

msgstr ""

"Klicke die Datei oder den Ordner mit der rechten Maustaste an und wähle "

"**Eigenschaften**."

#: ../../howto/remote_debugging.rst:125

msgid "Go to the **Security** tab to view users and groups with access."

msgstr ""

"Wechsle auf die Registerkarte **Sicherheit**, um Benutzer und Gruppen mit "

"Zugriff zu sehen."

#: ../../howto/remote_debugging.rst:126

msgid "Click **Edit** to modify permissions."

msgstr "Klicke auf **Bearbeiten**, um die Berechtigungen zu ändern."

#: ../../howto/remote_debugging.rst:127

msgid "Select your user account."

msgstr "Wähle dein Benutzerkonto aus."

#: ../../howto/remote_debugging.rst:128

msgid "In **Permissions**, check **Read** or **Full control** as needed."

msgstr ""

"Setze unter **Berechtigungen** nach Bedarf ein Häkchen bei **Lesen** oder "

"**Vollzugriff**."

#: ../../howto/remote_debugging.rst:129

msgid "Click **Apply**, then **OK** to confirm."

msgstr "Klicke auf **Übernehmen** und dann auf **OK**, um zu bestätigen."

#: ../../howto/remote_debugging.rst:134

msgid ""

"Ensure you've satisfied all :ref:`permission-requirements` before proceeding."

msgstr ""

"Stelle sicher, dass du alle :ref:`permission-requirements` erfüllt hast, "

"bevor du weitermachst."

#: ../../howto/remote_debugging.rst:136

msgid ""

"This section describes the low-level protocol that enables external tools to "

"inject and execute a Python script within a running CPython process."

msgstr ""

"Dieser Abschnitt beschreibt das tiefliegende Protokoll, mit dem externe "

"Werkzeuge ein Python-Skript in einen laufenden CPython-Prozess einspeisen "

"und dort ausführen können."

#: ../../howto/remote_debugging.rst:139

msgid ""

"This mechanism forms the basis of the :func:`sys.remote_exec` function, "

"which instructs a remote Python process to execute a ``.py`` file. However, "

"this section does not document the usage of that function. Instead, it "

"provides a detailed explanation of the underlying protocol, which takes as "

"input the ``pid`` of a target Python process and the path to a Python source "

"file to be executed. This information supports independent reimplementation "

"of the protocol, regardless of programming language."

msgstr ""

"Dieser Mechanismus ist die Grundlage der Funktion :func:`sys.remote_exec`, "

"die einen fernen Python-Prozess anweist, eine ``.py``-Datei auszuführen. "

"Dieser Abschnitt dokumentiert allerdings nicht die Verwendung dieser "

"Funktion. Er erklärt vielmehr ausführlich das zugrunde liegende Protokoll, "

"das als Eingabe die ``pid`` eines Ziel-Python-Prozesses und den Pfad zu "

"einer auszuführenden Python-Quelldatei nimmt. Diese Informationen erlauben "

"es, das Protokoll unabhängig und in jeder Programmiersprache neu umzusetzen."

#: ../../howto/remote_debugging.rst:149

msgid ""

"The execution of the injected script depends on the interpreter reaching a "

"safe evaluation point. As a result, execution may be delayed depending on "

"the runtime state of the target process."

msgstr ""

"Die Ausführung des eingespeisten Skripts hängt davon ab, dass der "

"Interpreter einen sicheren Auswertungspunkt erreicht. Die Ausführung kann "

"sich daher je nach Laufzeitzustand des Zielprozesses verzögern."

#: ../../howto/remote_debugging.rst:153

msgid ""

"Once injected, the script is executed by the interpreter within the target "

"process the next time a safe evaluation point is reached. This approach "

"enables remote execution capabilities without modifying the behavior or "

"structure of the running Python application."

msgstr ""

"Nach dem Einspeisen wird das Skript vom Interpreter im Zielprozess "

"ausgeführt, sobald das nächste Mal ein sicherer Auswertungspunkt erreicht "

"wird. Dieser Ansatz erlaubt die Ausführung aus der Ferne, ohne das Verhalten "

"oder den Aufbau der laufenden Python-Anwendung zu verändern."

#: ../../howto/remote_debugging.rst:158

msgid ""

"Subsequent sections provide a step-by-step description of the protocol, "

"including techniques for locating interpreter structures in memory, safely "

"accessing internal fields, and triggering code execution. Platform-specific "

"variations are noted where applicable, and example implementations are "

"included to clarify each operation."

msgstr ""

"Die folgenden Abschnitte beschreiben das Protokoll Schritt für Schritt, "

"einschließlich der Techniken, um Interpreter-Strukturen im Speicher zu "

"finden, sicher auf interne Felder zuzugreifen und die Codeausführung "

"anzustoßen. Plattformspezifische Abweichungen sind, wo nötig, angemerkt, und "

"Beispielumsetzungen verdeutlichen jeden Vorgang."

#: ../../howto/remote_debugging.rst:165

msgid "Locating the PyRuntime structure"

msgstr "Die Struktur PyRuntime finden"

#: ../../howto/remote_debugging.rst:167

msgid ""

"CPython places the ``PyRuntime`` structure in a dedicated binary section to "

"help external tools find it at runtime. The name and format of this section "

"vary by platform. For example, ``.PyRuntime`` is used on ELF systems, and "

"``__DATA,__PyRuntime`` is used on macOS. Tools can find the offset of this "

"structure by examining the binary on disk."

msgstr ""

"CPython legt die Struktur ``PyRuntime`` in einen eigenen Abschnitt der "

"Programmdatei, damit externe Werkzeuge sie zur Laufzeit finden können. Name "

"und Format dieses Abschnitts unterscheiden sich je nach Plattform. So wird "

"auf ELF-Systemen ``.PyRuntime`` verwendet und unter macOS ``__DATA,"

"__PyRuntime``. Werkzeuge können den Versatz dieser Struktur finden, indem "

"sie die Programmdatei auf der Festplatte untersuchen."

#: ../../howto/remote_debugging.rst:173

msgid ""

"The ``PyRuntime`` structure contains CPython’s global interpreter state and "

"provides access to other internal data, including the list of interpreters, "

"thread states, and debugger support fields."

msgstr ""

"Die Struktur ``PyRuntime`` enthält den globalen Interpreter-Zustand von "

"CPython und bietet Zugriff auf weitere interne Daten, darunter die Liste der "

"Interpreter, die Thread-Zustände und die Felder für die Debugger-"

"Unterstützung."

#: ../../howto/remote_debugging.rst:177

msgid ""

"To work with a remote Python process, a debugger must first find the memory "

"address of the ``PyRuntime`` structure in the target process. This address "

"can’t be hardcoded or calculated from a symbol name, because it depends on "

"where the operating system loaded the binary."

msgstr ""

"Um mit einem fernen Python-Prozess zu arbeiten, muss ein Debugger zuerst die "

"Speicheradresse der Struktur ``PyRuntime`` im Zielprozess finden. Diese "

"Adresse lässt sich nicht fest eintragen oder aus einem Symbolnamen "

"berechnen, weil sie davon abhängt, wohin das Betriebssystem die "

"Programmdatei geladen hat."

#: ../../howto/remote_debugging.rst:182

msgid ""

"The method for finding ``PyRuntime`` depends on the platform, but the steps "

"are the same in general:"

msgstr ""

"Wie man ``PyRuntime`` findet, hängt von der Plattform ab, aber die Schritte "

"sind im Allgemeinen dieselben:"

#: ../../howto/remote_debugging.rst:185

msgid ""

"Find the base address where the Python binary or shared library was loaded "

"in the target process."

msgstr ""

"Finde die Basisadresse, an der die Python-Programmdatei oder die dynamische "

"Bibliothek im Zielprozess geladen wurde."

#: ../../howto/remote_debugging.rst:187

msgid ""

"Use the on-disk binary to locate the offset of the ``.PyRuntime`` section."

msgstr ""

"Bestimme über die Programmdatei auf der Festplatte den Versatz des "

"Abschnitts ``.PyRuntime``."

#: ../../howto/remote_debugging.rst:188

msgid ""

"Add the section offset to the base address to compute the address in memory."

msgstr ""

"Addiere den Versatz des Abschnitts zur Basisadresse, um die Adresse im "

"Speicher zu berechnen."

#: ../../howto/remote_debugging.rst:190

msgid ""

"The sections below explain how to do this on each supported platform and "

"include example code."

msgstr ""

"Die folgenden Abschnitte erklären, wie das auf jeder unterstützten Plattform "

"geht, und enthalten Beispielcode."

#: ../../howto/remote_debugging.rst:194

msgid "Linux (ELF)"

msgstr "Linux (ELF)"

#: ../../howto/remote_debugging.rst:195

msgid "To find the ``PyRuntime`` structure on Linux:"

msgstr "Um die Struktur ``PyRuntime`` unter Linux zu finden:"

#: ../../howto/remote_debugging.rst:197

msgid ""

"Read the process’s memory map (for example, ``/proc/<pid>/maps``) to find "

"the address where the Python executable or ``libpython`` was loaded."

msgstr ""

"Lies die Speicherkarte des Prozesses (zum Beispiel ``/proc/<pid>/maps``), um "

"die Adresse zu finden, an der die Python-Programmdatei oder ``libpython`` "

"geladen wurde."

#: ../../howto/remote_debugging.rst:199

msgid ""

"Parse the ELF section headers in the binary to get the offset of the ``."

"PyRuntime`` section."

msgstr ""

"Zerlege die ELF-Abschnittsköpfe in der Programmdatei, um den Versatz des "

"Abschnitts ``.PyRuntime`` zu bekommen."

#: ../../howto/remote_debugging.rst:201

msgid ""

"Add that offset to the base address from step 1 to get the memory address of "

"``PyRuntime``."

msgstr ""

"Addiere diesen Versatz zur Basisadresse aus Schritt 1, um die "

"Speicheradresse von ``PyRuntime`` zu bekommen."

#: ../../howto/remote_debugging.rst:204 ../../howto/remote_debugging.rst:266

#: ../../howto/remote_debugging.rst:336 ../../howto/remote_debugging.rst:605

msgid "The following is an example implementation::"

msgstr "Hier eine Beispielumsetzung::"

#: ../../howto/remote_debugging.rst:206

msgid ""

"def find_py_runtime_linux(pid: int) -> int:\n"

" # Step 1: Try to find the Python executable in memory\n"

" binary_path, base_address = find_mapped_binary(\n"

" pid, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 2: Fallback to shared library if executable is not found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_mapped_binary(\n"

" pid, name_contains=\"libpython\"\n"

" )\n"

"\n"

" # Step 3: Parse ELF headers to get .PyRuntime section offset\n"

" section_offset = parse_elf_section_offset(\n"

" binary_path, \".PyRuntime\"\n"

" )\n"

"\n"

" # Step 4: Compute PyRuntime address in memory\n"

" return base_address + section_offset"

msgstr ""

"def find_py_runtime_linux(pid: int) -> int:\n"

" # Step 1: Try to find the Python executable in memory\n"

" binary_path, base_address = find_mapped_binary(\n"

" pid, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 2: Fallback to shared library if executable is not found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_mapped_binary(\n"

" pid, name_contains=\"libpython\"\n"

" )\n"

"\n"

" # Step 3: Parse ELF headers to get .PyRuntime section offset\n"

" section_offset = parse_elf_section_offset(\n"

" binary_path, \".PyRuntime\"\n"

" )\n"

"\n"

" # Step 4: Compute PyRuntime address in memory\n"

" return base_address + section_offset"

#: ../../howto/remote_debugging.rst:227

msgid ""

"On Linux systems, there are two main approaches to read memory from another "

"process. The first is through the ``/proc`` filesystem, specifically by "

"reading from ``/proc/[pid]/mem`` which provides direct access to the "

"process's memory. This requires appropriate permissions - either being the "

"same user as the target process or having root access. The second approach "

"is using the ``process_vm_readv()`` system call which provides a more "

"efficient way to copy memory between processes. While ptrace's "

"``PTRACE_PEEKTEXT`` operation can also be used to read memory, it is "

"significantly slower as it only reads one word at a time and requires "

"multiple context switches between the tracer and tracee processes."

msgstr ""

"Auf Linux-Systemen gibt es zwei wesentliche Ansätze, um Speicher aus einem "

"anderen Prozess zu lesen. Der erste führt über das ``/proc``-Dateisystem, "

"genauer über das Lesen von ``/proc/[pid]/mem``, das unmittelbaren Zugriff "

"auf den Speicher des Prozesses gibt. Das erfordert passende Berechtigungen – "

"entweder derselbe Benutzer wie beim Zielprozess zu sein oder Root-Zugriff zu "

"haben. Der zweite Ansatz ist der Systemaufruf ``process_vm_readv()``, der "

"einen effizienteren Weg bietet, Speicher zwischen Prozessen zu kopieren. Die "

"ptrace-Operation ``PTRACE_PEEKTEXT`` lässt sich zum Lesen von Speicher "

"ebenfalls verwenden, ist aber deutlich langsamer, weil sie immer nur ein "

"Wort liest und mehrere Kontextwechsel zwischen dem verfolgenden und dem "

"verfolgten Prozess erfordert."

#: ../../howto/remote_debugging.rst:238

msgid ""

"For parsing ELF sections, the process involves reading and interpreting the "

"ELF file format structures from the binary file on disk. The ELF header "

"contains a pointer to the section header table. Each section header contains "

"metadata about a section including its name (stored in a separate string "

"table), offset, and size. To find a specific section like .PyRuntime, you "

"need to walk through these headers and match the section name. The section "

"header then provides the offset where that section exists in the file, which "

"can be used to calculate its runtime address when the binary is loaded into "

"memory."

msgstr ""

"Zum Zerlegen von ELF-Abschnitten gehört es, die Strukturen des ELF-"

"Dateiformats aus der Programmdatei auf der Festplatte zu lesen und "

"auszuwerten. Der ELF-Kopf enthält einen Zeiger auf die Tabelle der "

"Abschnittsköpfe. Jeder Abschnittskopf enthält Metadaten über einen "

"Abschnitt, darunter seinen Namen (in einer separaten Zeichenkettentabelle "

"gespeichert), seinen Versatz und seine Größe. Um einen bestimmten Abschnitt "

"wie .PyRuntime zu finden, musst du diese Köpfe durchgehen und den "

"Abschnittsnamen vergleichen. Der Abschnittskopf liefert dann den Versatz, an "

"dem dieser Abschnitt in der Datei liegt, mit dem sich seine Laufzeitadresse "

"berechnen lässt, sobald die Programmdatei in den Speicher geladen ist."

#: ../../howto/remote_debugging.rst:247

msgid ""

"You can read more about the ELF file format in the `ELF specification "

"<https://en.wikipedia.org/wiki/Executable_and_Linkable_Format>`_."

msgstr ""

"Mehr über das ELF-Dateiformat kannst du in der `ELF-Spezifikation <https://"

"en.wikipedia.org/wiki/Executable_and_Linkable_Format>`_ nachlesen."

#: ../../howto/remote_debugging.rst:252

msgid "macOS (Mach-O)"

msgstr "macOS (Mach-O)"

#: ../../howto/remote_debugging.rst:253

msgid "To find the ``PyRuntime`` structure on macOS:"

msgstr "Um die Struktur ``PyRuntime`` unter macOS zu finden:"

#: ../../howto/remote_debugging.rst:255

msgid ""

"Call ``task_for_pid()`` to get the ``mach_port_t`` task port for the target "

"process. This handle is needed to read memory using APIs like "

"``mach_vm_read_overwrite`` and ``mach_vm_region``."

msgstr ""

"Rufe ``task_for_pid()`` auf, um den ``mach_port_t``-Task-Port des "

"Zielprozesses zu bekommen. Dieses Handle ist nötig, um Speicher über APIs "

"wie ``mach_vm_read_overwrite`` und ``mach_vm_region`` zu lesen."

#: ../../howto/remote_debugging.rst:258

msgid ""

"Scan the memory regions to find the one containing the Python executable or "

"``libpython``."

msgstr ""

"Durchsuche die Speicherbereiche, um den zu finden, der die Python-"

"Programmdatei oder ``libpython`` enthält."

#: ../../howto/remote_debugging.rst:260

msgid ""

"Load the binary file from disk and parse the Mach-O headers to find the "

"section named ``PyRuntime`` in the ``__DATA`` segment. On macOS, symbol "

"names are automatically prefixed with an underscore, so the ``PyRuntime`` "

"symbol appears as ``_PyRuntime`` in the symbol table, but the section name "

"is not affected."

msgstr ""

"Lade die Programmdatei von der Festplatte und zerlege die Mach-O-Köpfe, um "

"den Abschnitt namens ``PyRuntime`` im Segment ``__DATA`` zu finden. Unter "

"macOS werden Symbolnamen automatisch mit einem Unterstrich versehen. Das "

"Symbol ``PyRuntime`` erscheint in der Symboltabelle daher als "

"``_PyRuntime``, der Abschnittsname bleibt davon aber unberührt."

#: ../../howto/remote_debugging.rst:268

msgid ""

"def find_py_runtime_macos(pid: int) -> int:\n"

" # Step 1: Get access to the process's memory\n"

" handle = get_memory_access_handle(pid)\n"

"\n"

" # Step 2: Try to find the Python executable in memory\n"

" binary_path, base_address = find_mapped_binary(\n"

" handle, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 3: Fallback to libpython if the executable is not found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_mapped_binary(\n"

" handle, name_contains=\"libpython\"\n"

" )\n"

"\n"

" # Step 4: Parse Mach-O headers to get __DATA,__PyRuntime section offset\n"

" section_offset = parse_macho_section_offset(\n"

" binary_path, \"__DATA\", \"__PyRuntime\"\n"

" )\n"

"\n"

" # Step 5: Compute the PyRuntime address in memory\n"

" return base_address + section_offset"

msgstr ""

"def find_py_runtime_macos(pid: int) -> int:\n"

" # Step 1: Get access to the process's memory\n"

" handle = get_memory_access_handle(pid)\n"

"\n"

" # Step 2: Try to find the Python executable in memory\n"

" binary_path, base_address = find_mapped_binary(\n"

" handle, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 3: Fallback to libpython if the executable is not found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_mapped_binary(\n"

" handle, name_contains=\"libpython\"\n"

" )\n"

"\n"

" # Step 4: Parse Mach-O headers to get __DATA,__PyRuntime section offset\n"

" section_offset = parse_macho_section_offset(\n"

" binary_path, \"__DATA\", \"__PyRuntime\"\n"

" )\n"

"\n"

" # Step 5: Compute the PyRuntime address in memory\n"

" return base_address + section_offset"

#: ../../howto/remote_debugging.rst:291

msgid ""

"On macOS, accessing another process's memory requires using Mach-O specific "

"APIs and file formats. The first step is obtaining a ``task_port`` handle "

"via ``task_for_pid()``, which provides access to the target process's memory "

"space. This handle enables memory operations through APIs like "

"``mach_vm_read_overwrite()``."

msgstr ""

"Unter macOS erfordert der Zugriff auf den Speicher eines anderen Prozesses "

"Mach-O-spezifische APIs und Dateiformate. Der erste Schritt ist, über "

"``task_for_pid()`` ein ``task_port``-Handle zu bekommen, das Zugriff auf den "

"Speicherbereich des Zielprozesses gibt. Dieses Handle ermöglicht "

"Speicheroperationen über APIs wie ``mach_vm_read_overwrite()``."

#: ../../howto/remote_debugging.rst:297

msgid ""

"The process memory can be examined using ``mach_vm_region()`` to scan "

"through the virtual memory space, while ``proc_regionfilename()`` helps "

"identify which binary files are loaded at each memory region. When the "

"Python binary or library is found, its Mach-O headers need to be parsed to "

"locate the ``PyRuntime`` structure."

msgstr ""

"Der Speicher des Prozesses lässt sich mit ``mach_vm_region()`` untersuchen, "

"um den virtuellen Speicherbereich zu durchsuchen, während "

"``proc_regionfilename()`` dabei hilft, zu erkennen, welche Programmdateien "

"an welchem Speicherbereich geladen sind. Ist die Python-Programmdatei oder -"

"Bibliothek gefunden, müssen ihre Mach-O-Köpfe zerlegt werden, um die "

"Struktur ``PyRuntime`` zu finden."

#: ../../howto/remote_debugging.rst:302

msgid ""

"The Mach-O format organizes code and data into segments and sections. The "

"``PyRuntime`` structure lives in a section named ``__PyRuntime`` within the "

"``__DATA`` segment. The actual runtime address calculation involves finding "

"the ``__TEXT`` segment which serves as the binary's base address, then "

"locating the ``__DATA`` segment containing our target section. The final "

"address is computed by combining the base address with the appropriate "

"section offsets from the Mach-O headers."

msgstr ""

"Das Mach-O-Format gliedert Code und Daten in Segmente und Abschnitte. Die "

"Struktur ``PyRuntime`` liegt in einem Abschnitt namens ``__PyRuntime`` "

"innerhalb des Segments ``__DATA``. Für die eigentliche Berechnung der "

"Laufzeitadresse muss das Segment ``__TEXT`` gefunden werden, das als "

"Basisadresse der Programmdatei dient, und dann das Segment ``__DATA``, das "

"unseren Zielabschnitt enthält. Die endgültige Adresse ergibt sich aus der "

"Basisadresse und den passenden Abschnittsversätzen aus den Mach-O-Köpfen."

#: ../../howto/remote_debugging.rst:310

msgid ""

"Note that accessing another process's memory on macOS typically requires "

"elevated privileges - either root access or special security entitlements "

"granted to the debugging process."

msgstr ""

"Beachte, dass der Zugriff auf den Speicher eines anderen Prozesses unter "

"macOS üblicherweise erhöhte Rechte erfordert – entweder Root-Zugriff oder "

"besondere Sicherheitsberechtigungen für den Debug-Prozess."

#: ../../howto/remote_debugging.rst:316

msgid "Windows (PE)"

msgstr "Windows (PE)"

#: ../../howto/remote_debugging.rst:317

msgid "To find the ``PyRuntime`` structure on Windows:"

msgstr "Um die Struktur ``PyRuntime`` unter Windows zu finden:"

#: ../../howto/remote_debugging.rst:319

msgid ""

"Use the ToolHelp API to enumerate all modules loaded in the target process. "

"This is done using functions such as `CreateToolhelp32Snapshot <https://"

"learn.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-"

"createtoolhelp32snapshot>`_, `Module32First <https://learn.microsoft.com/en-"

"us/windows/win32/api/tlhelp32/nf-tlhelp32-module32first>`_, and "

"`Module32Next <https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/"

"nf-tlhelp32-module32next>`_."

msgstr ""

"Verwende die ToolHelp-API, um alle im Zielprozess geladenen Module "

"aufzuzählen. Das geschieht über Funktionen wie `CreateToolhelp32Snapshot "

"<https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-"

"createtoolhelp32snapshot>`_, `Module32First <https://learn.microsoft.com/en-"

"us/windows/win32/api/tlhelp32/nf-tlhelp32-module32first>`_ und `Module32Next "

"<https://learn.microsoft.com/en-us/windows/win32/api/tlhelp32/nf-tlhelp32-"

"module32next>`_."

#: ../../howto/remote_debugging.rst:326

msgid ""

"Identify the module corresponding to :file:`python.exe` or :file:`python{XY}."

"dll`, where ``X`` and ``Y`` are the major and minor version numbers of the "

"Python version, and record its base address."

msgstr ""

"Bestimme das Modul, das zu :file:`python.exe` oder :file:`python{XY}.dll` "

"gehört, wobei ``X`` und ``Y`` die Haupt- und Nebenversionsnummer der Python-"

"Version sind, und notiere seine Basisadresse."

#: ../../howto/remote_debugging.rst:329

msgid ""

"Locate the ``PyRuntim`` section. Due to the PE format's 8-character limit on "

"section names (defined as ``IMAGE_SIZEOF_SHORT_NAME``), the original name "

"``PyRuntime`` is truncated. This section contains the ``PyRuntime`` "

"structure."

msgstr ""

"Finde den Abschnitt ``PyRuntim``. Wegen der Begrenzung von Abschnittsnamen "

"auf 8 Zeichen im PE-Format (festgelegt als ``IMAGE_SIZEOF_SHORT_NAME``) wird "

"der ursprüngliche Name ``PyRuntime`` abgeschnitten. Dieser Abschnitt enthält "

"die Struktur ``PyRuntime``."

#: ../../howto/remote_debugging.rst:333

msgid ""

"Retrieve the section’s relative virtual address (RVA) and add it to the base "

"address of the module."

msgstr ""

"Hole die relative virtuelle Adresse (RVA) des Abschnitts und addiere sie zur "

"Basisadresse des Moduls."

#: ../../howto/remote_debugging.rst:338

msgid ""

"def find_py_runtime_windows(pid: int) -> int:\n"

" # Step 1: Try to find the Python executable in memory\n"

" binary_path, base_address = find_loaded_module(\n"

" pid, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 2: Fallback to shared pythonXY.dll if the executable is not\n"

" # found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_loaded_module(\n"

" pid, name_contains=\"python3\"\n"

" )\n"

"\n"

" # Step 3: Parse PE section headers to get the RVA of the PyRuntime\n"

" # section. The section name appears as \"PyRuntim\" due to the\n"

" # 8-character limit defined by the PE format (IMAGE_SIZEOF_SHORT_NAME).\n"

" section_rva = parse_pe_section_offset(binary_path, \"PyRuntim\")\n"

"\n"

" # Step 4: Compute PyRuntime address in memory\n"

" return base_address + section_rva"

msgstr ""

"def find_py_runtime_windows(pid: int) -> int:\n"

" # Step 1: Try to find the Python executable in memory\n"

" binary_path, base_address = find_loaded_module(\n"

" pid, name_contains=\"python\"\n"

" )\n"

"\n"

" # Step 2: Fallback to shared pythonXY.dll if the executable is not\n"

" # found\n"

" if binary_path is None:\n"

" binary_path, base_address = find_loaded_module(\n"

" pid, name_contains=\"python3\"\n"

" )\n"

"\n"

" # Step 3: Parse PE section headers to get the RVA of the PyRuntime\n"

" # section. The section name appears as \"PyRuntim\" due to the\n"

" # 8-character limit defined by the PE format (IMAGE_SIZEOF_SHORT_NAME).\n"

" section_rva = parse_pe_section_offset(binary_path, \"PyRuntim\")\n"

"\n"

" # Step 4: Compute PyRuntime address in memory\n"

" return base_address + section_rva"

#: ../../howto/remote_debugging.rst:360

msgid ""

"On Windows, accessing another process's memory requires using the Windows "

"API functions like ``CreateToolhelp32Snapshot()`` and ``Module32First()/"

"Module32Next()`` to enumerate loaded modules. The ``OpenProcess()`` function "

"provides a handle to access the target process's memory space, enabling "

"memory operations through ``ReadProcessMemory()``."

msgstr ""

"Unter Windows erfordert der Zugriff auf den Speicher eines anderen Prozesses "

"Windows-API-Funktionen wie ``CreateToolhelp32Snapshot()`` und "

"``Module32First()/Module32Next()``, um die geladenen Module aufzuzählen. Die "

"Funktion ``OpenProcess()`` liefert ein Handle für den Zugriff auf den "

"Speicherbereich des Zielprozesses und ermöglicht damit Speicheroperationen "

"über ``ReadProcessMemory()``."

#: ../../howto/remote_debugging.rst:366

msgid ""

"The process memory can be examined by enumerating loaded modules to find the "

"Python binary or DLL. When found, its PE headers need to be parsed to locate "

"the ``PyRuntime`` structure."

msgstr ""

"Der Speicher des Prozesses lässt sich untersuchen, indem man die geladenen "

"Module aufzählt, um die Python-Programmdatei oder -DLL zu finden. Ist sie "

"gefunden, müssen ihre PE-Köpfe zerlegt werden, um die Struktur ``PyRuntime`` "

"zu finden."

#: ../../howto/remote_debugging.rst:370

msgid ""

"The PE format organizes code and data into sections. The ``PyRuntime`` "

"structure lives in a section named \"PyRuntim\" (truncated from "

"\"PyRuntime\" due to PE's 8-character name limit). The actual runtime "

"address calculation involves finding the module's base address from the "

"module entry, then locating our target section in the PE headers. The final "

"address is computed by combining the base address with the section's virtual "

"address from the PE section headers."

msgstr ""

"Das PE-Format gliedert Code und Daten in Abschnitte. Die Struktur "

"``PyRuntime`` liegt in einem Abschnitt namens „PyRuntim“ (von „PyRuntime“ "

"abgeschnitten wegen der Begrenzung der PE-Namen auf 8 Zeichen). Für die "

"eigentliche Berechnung der Laufzeitadresse muss die Basisadresse des Moduls "

"aus dem Moduleintrag ermittelt und dann unser Zielabschnitt in den PE-Köpfen "

"gefunden werden. Die endgültige Adresse ergibt sich aus der Basisadresse und "

"der virtuellen Adresse des Abschnitts aus den PE-Abschnittsköpfen."

#: ../../howto/remote_debugging.rst:377

msgid ""

"Note that accessing another process's memory on Windows typically requires "

"appropriate privileges - either administrative access or the "

"``SeDebugPrivilege`` privilege granted to the debugging process."

msgstr ""

"Beachte, dass der Zugriff auf den Speicher eines anderen Prozesses unter "

"Windows üblicherweise passende Rechte erfordert – entweder "

"Administratorzugriff oder das Recht ``SeDebugPrivilege`` für den Debug-"

"Prozess."

#: ../../howto/remote_debugging.rst:383

msgid "Reading _Py_DebugOffsets"

msgstr "_Py_DebugOffsets lesen"

#: ../../howto/remote_debugging.rst:385

msgid ""

"Once the address of the ``PyRuntime`` structure has been determined, the "

"next step is to read the ``_Py_DebugOffsets`` structure located at the "

"beginning of the ``PyRuntime`` block."

msgstr ""

"Sobald die Adresse der Struktur ``PyRuntime`` bestimmt ist, besteht der "

"nächste Schritt darin, die Struktur ``_Py_DebugOffsets`` zu lesen, die am "

"Anfang des ``PyRuntime``-Blocks liegt."

#: ../../howto/remote_debugging.rst:389

msgid ""

"This structure provides version-specific field offsets that are needed to "

"safely read interpreter and thread state memory. These offsets vary between "

"CPython versions and must be checked before use to ensure they are "

"compatible."

msgstr ""

"Diese Struktur liefert versionsspezifische Feldversätze, die nötig sind, um "

"den Speicher des Interpreter- und Thread-Zustands sicher zu lesen. Diese "

"Versätze unterscheiden sich zwischen CPython-Versionen und müssen vor der "

"Verwendung geprüft werden, damit sie auch passen."

#: ../../howto/remote_debugging.rst:393

msgid "To read and check the debug offsets, follow these steps:"

msgstr "Um die Debug-Versätze zu lesen und zu prüfen, folge diesen Schritten:"

#: ../../howto/remote_debugging.rst:395

msgid ""

"Read memory from the target process starting at the ``PyRuntime`` address, "

"covering the same number of bytes as the ``_Py_DebugOffsets`` structure. "

"This structure is located at the very start of the ``PyRuntime`` memory "

"block. Its layout is defined in CPython’s internal headers and stays the "

"same within a given minor version, but may change in major versions."

msgstr ""

"Lies ab der ``PyRuntime``-Adresse Speicher aus dem Zielprozess, und zwar so "

"viele Bytes, wie die Struktur ``_Py_DebugOffsets`` groß ist. Diese Struktur "

"liegt am ganz Anfang des ``PyRuntime``-Speicherblocks. Ihre Anordnung ist in "

"den internen Headern von CPython festgelegt und bleibt innerhalb einer "

"Nebenversion gleich, kann sich in Hauptversionen aber ändern."

#: ../../howto/remote_debugging.rst:401

msgid "Check that the structure contains valid data:"

msgstr "Prüfe, ob die Struktur gültige Daten enthält:"

#: ../../howto/remote_debugging.rst:403

msgid "The ``cookie`` field must match the expected debug marker."

msgstr "Das Feld ``cookie`` muss zur erwarteten Debug-Markierung passen."

#: ../../howto/remote_debugging.rst:404

msgid ""

"The ``version`` field must match the version of the Python interpreter used "

"by the debugger."

msgstr ""

"Das Feld ``version`` muss zur Version des Python-Interpreters passen, die "

"der Debugger verwendet."

#: ../../howto/remote_debugging.rst:406

msgid ""

"If either the debugger or the target process is using a pre-release version "

"(for example, an alpha, beta, or release candidate), the versions must match "

"exactly."

msgstr ""

"Wenn der Debugger oder der Zielprozess eine Vorabversion verwendet (zum "

"Beispiel eine Alpha-, Beta- oder Release-Candidate-Version), müssen die "

"Versionen genau übereinstimmen."

#: ../../howto/remote_debugging.rst:409

msgid ""

"The ``free_threaded`` field must have the same value in both the debugger "

"and the target process."

msgstr ""

"Das Feld ``free_threaded`` muss im Debugger und im Zielprozess denselben "

"Wert haben."