So debuggen Sie Programme mit “sudo” in VSCODE

Ich versuche, ein Programm in VSCODE zu debuggen. Das Programm muss als root oder mit “sudo” auf Ubuntu gestartet werden. Was ist der beste Weg, dies zu erreichen? Eine beispielhafte Startkonfiguration wäre hilfreich. Vielen Dank.

Ich war kürzlich in einer ähnlichen Situation. Ich habe es gelöst, indem ich {“sudo”: true} in der Datei launch.json im Verzeichnis .vscode hinzugefügt habe.

habe gerade die folgende Zeile in .vscode>launch.json hinzugefügt

{
    "version": "0.2.0",
    "configurations": [
        {
            "other..." : "configs...",
            "request": "launch",
            "console": "integratedTerminal",
            "args": [
                "${file}"
            ],
            "sudo": true
        }
    ]
}

VS-Code-Version, die ich verwende, ist –

Version: 1.49.1 Betriebssystem: Ubuntu 16.04 LTS, 64-Bit

Dies scheint nicht in allen Sprachen zu funktionieren. Für mich hat es für Python 3.x funktioniert. Andere Benutzer haben berichtet, dass es für C/C++ nicht funktioniert.

Ich habe folgendes gemacht:

1. Erstellen Sie ein Skript namens “gdb” in z. B. meinem Home-Verzeichnis, das Folgendes enthält:
   pkexec /usr/bin/gdb "$@"
2. ausführbar machen
3. ändern Sie die launch.json in VSCode, um das Skript aufzurufen (offensichtlich change Nutzername entsprechend) durch Hinzufügen von “miDebuggerPath”:

...
            "externalConsole": false,
            "miDebuggerPath": "/home/<username>/gdb",
            "MIMode": "gdb",
...

4. Verwenden Sie beim Debuggen top oder Ähnliches, um zu überprüfen, ob der Prozess als Root ausgeführt wird.

Das sollte genug sein.

Meine Lösung:

hinzufügen /usr/bin/gdb zu /etc/sudoers wie hier

fügen Sie eine ausführbare Datei hinzu, deren Inhalt ist

sudo /usr/bin/gdb "$@"

einstellen miDebuggerPath zur Datei

Sie wissen nicht, wie Sie vscode dazu bringen, sudo gdb auszuführen. Aber Sie können sudo verwenden, um vscode auszuführen, so dass Sie natürlich gdb zum Debuggen verwenden können.

sudo-Code. –user-data-dir=”.”

Wie aus den vorherigen Antworten musste ich die Methode mit einer ausführbaren Datei im Home-Verzeichnis wie: /home/youruser/gdbasroot verwenden

Aber ich musste den Inhalt verwenden:

sudo /usr/bin/gdb “$@”

anstelle von gdbk, weil ich gdbk nicht zum Laufen bringen konnte, ohne nach einem Passwort zu fragen (was nicht funktionierte, da es vom vscode-Remote-Debugger aufgerufen wurde). Ich habe es gemäß diesem Beitrag getan (die positiv bewertete und akzeptierte Antwort):

https://askubuntu.com/questions/542397/change-default-user-for-authentication

Wenn Sie sudo verwenden, können Sie im vscode-Terminal einen sudo-Befehl ausführen und von da an können Sie den “sudo-Debugger” ohne das Passwort verwenden. Andernfalls wird vscode aufgefordert und kann damit nicht umgehen.

Grüße

Ich habe folgendes gemacht:

1. versuchen, was Jason tat
2. müde mit endlosen lästigen Dialogfeldern für das Passwort
3. Schreiben Sie ein Python-Skript, um das zu lösen

launch.json:

...
"externalConsole": false,
"miDebuggerPath": "${workspaceFolder}/scripts/gdb_root.py",
"MIMode": "gdb",
...

gdb_root.py:

#!/usr/bin/python3
import os
import sys
import stat
import time
import json
import hashlib
from pathlib import Path

GRANT_EXPIRE_SEC = 2 * 60 * 60
TARGET_EXECUTABLE = '/usr/bin/gdb'
TMP_BIN_DIR = '/tmp/exec_as_root'


class ExecFailed(Exception):
    pass


def instance_hash(argv):
    command = ' '.join(argv)
    return hashlib.md5(command.encode()).hexdigest()


def write_c_code(path, argv):
    CODE_TEMPLATE = '''
    #include <time.h>
    #include <stdlib.h>
    #include <unistd.h>

    int main(int argc, char *argv[])
    {
        int test_mode = (argc > 1);
        if (time(NULL) > (time_t)EXPIRE) {
            char path[1024] = { 0 };
            readlink("/proc/self/exe", path, sizeof(path));
            unlink(path);
            return !test_mode;
        }

        if (!test_mode)
            execl(PARAMS, NULL);

        return 0;
    }'''

    expire = time.time() + GRANT_EXPIRE_SEC
    params = [argv[0]] + argv
    params = json.dumps(params)[1:-1]
    content = CODE_TEMPLATE \
        .replace('EXPIRE', str(expire)) \
        .replace('PARAMS', params)

    with open(path, 'w') as f:
        f.write(content)


def system(cmd):
    is_ok = os.system(cmd) == 0
    if not is_ok:
        cmd_str = json.dumps(cmd)
        summary = 'failed to execute:'
        os.system(f'notify-send -- "{summary}" {cmd_str}')
        raise ExecFailed()


def build_instance(instance, argv):
    c_file = instance.with_suffix('.c')
    write_c_code(c_file, argv)
    compile_cmd = f'gcc -o {instance} {c_file}'
    system(compile_cmd)


def did_grant_root(file):
    fs = os.stat(file)
    root_own = (fs.st_uid == 0)
    uid_set = fs.st_mode & stat.S_ISUID
    return root_own and uid_set


def grant_root(file):
    setuid_cmd = f'chown root:root {file}; chmod 4111 {file}'
    pkexec_cmd = f'pkexec bash -c "{setuid_cmd}"'
    system(pkexec_cmd)


def main():
    bin_dir = Path(TMP_BIN_DIR)
    bin_dir.mkdir(exist_ok=True)

    argv = [TARGET_EXECUTABLE] + sys.argv[1:]
    instance = bin_dir / instance_hash(argv)

    if instance.exists():
        system(f'{instance} test')

    if not instance.exists():
        build_instance(instance, argv)

    if not did_grant_root(instance):
        grant_root(instance)

    os.execv(instance, [instance.name])


if __name__ == '__main__':
    try:
        main()
    except ExecFailed:
        exit(1)

Dies ist eine tragbare Lösung, keine Auswirkung auf das System, und vergessen Sie nicht: chmod +x scripts/gdb_root.py

Dies funktionierte für Java, aber vielleicht auch für andere Sprachen:

Beim ersten Ausführen einer Debug-Sitzung erstellt VSCode ein Terminal namens eg Debug: Main. Öffnen Sie einfach das Terminal, drücken Sie Strg + C, geben Sie einsudo sugeben Sie Ihr Passwort ein und beim nächsten Mal wird die Debug-Sitzung von diesem Terminal mit Root-Rechten gestartet