Wie schützt curl ein Passwort vor dem Erscheinen in der ps-Ausgabe?

Vor einiger Zeit ist mir aufgefallen, dass Benutzernamen und Kennwörter, die curlals Befehlszeilenargumente angegeben wurden, nicht in der psAusgabe erscheinen (obwohl sie natürlich in Ihrem Bash-Verlauf erscheinen können).

Sie erscheinen ebenfalls nicht in /proc/PID/cmdline.

(Die Länge des kombinierten Benutzernamen / Passwort-Arguments kann jedoch abgeleitet werden.)

Demonstration unten:

[root@localhost ~]# nc -l 80 &
[1] 3342
[root@localhost ~]# curl -u iamsam:samiam localhost &
[2] 3343
[root@localhost ~]# GET / HTTP/1.1
Authorization: Basic aWFtc2FtOnNhbWlhbQ==
User-Agent: curl/7.19.7 (x86_64-redhat-linux-gnu) libcurl/7.19.7 NSS/3.15.3 zlib/1.2.3 libidn/1.18 libssh2/1.4.2
Host: localhost
Accept: */*



[1]+  Stopped                 nc -l 80
[root@localhost ~]# jobs
[1]+  Stopped                 nc -l 80
[2]-  Running                 curl -u iamsam:samiam localhost &
[root@localhost ~]# ps -ef | grep curl
root      3343  3258  0 22:37 pts/1    00:00:00 curl -u               localhost
root      3347  3258  0 22:38 pts/1    00:00:00 grep curl
[root@localhost ~]# od -xa /proc/3343/cmdline 
0000000    7563    6c72    2d00    0075    2020    2020    2020    2020
          c   u   r   l nul   -   u nul  sp  sp  sp  sp  sp  sp  sp  sp
0000020    2020    2020    0020    6f6c    6163    686c    736f    0074
         sp  sp  sp  sp  sp nul   l   o   c   a   l   h   o   s   t nul
0000040
[root@localhost ~]# 

Wie wird dieser Effekt erzielt? Liegt es irgendwo im Quellcode von curl? (Ich nehme an, es ist eine curlFunktion, keine psFunktion? Oder ist es eine Art Kernel-Funktion?)

Außerdem: Kann dies von außerhalb des Quellcodes einer ausführbaren Binärdatei erreicht werden? ZB durch die Verwendung von Shell-Befehlen, wahrscheinlich kombiniert mit Root-Berechtigungen?

Mit anderen Worten, könnte ich ein Argument , das ich an einen beliebigen Shell-Befehl weitergegeben habe, irgendwie davor verbergen, in /procoder in der psAusgabe zu erscheinen (ich glaube dasselbe) ? (Ich denke, die Antwort auf diese Frage ist "Nein", aber es scheint sich zu lohnen, diese zusätzliche halbe Frage einzuschließen.)

Wenn der Kernel einen Prozess ausführt, kopiert er die Befehlszeilenargumente in den zum Prozess gehörenden Lese- / Schreibspeicher (auf dem Stack, zumindest unter Linux). Der Prozess kann wie jeder andere Speicher in diesen Speicher schreiben. Wenn psdas Argument angezeigt wird, wird alles zurückgelesen, was an dieser bestimmten Adresse im Speicher des Prozesses gespeichert ist. Die meisten Programme behalten die ursprünglichen Argumente bei, aber es ist möglich, sie zu ändern. Die POSIX-Beschreibung vonps gibt an, dass

Es ist nicht festgelegt, ob die dargestellte Zeichenfolge eine Version der Argumentliste ist, wie sie beim Start an den Befehl übergeben wurde, oder eine Version der Argumente, wie sie möglicherweise von der Anwendung geändert wurden. Anwendungen können nicht davon abhängen, dass sie ihre Argumentliste ändern können und dass sich diese Änderung in der Ausgabe von ps widerspiegelt.

Der Grund dafür ist, dass die meisten Unix-Varianten die Änderung widerspiegeln, POSIX-Implementierungen auf anderen Betriebssystemen jedoch möglicherweise nicht.

Diese Funktion ist von begrenztem Nutzen, da der Prozess keine willkürlichen Änderungen vornehmen kann. Zumindest kann die Gesamtlänge der Argumente nicht erhöht werden, da das Programm die Position, an der die Argumente abgerufen werden, nicht ändern psund den Bereich nicht über seine ursprüngliche Größe hinaus erweitern kann. Die Länge kann effektiv durch Setzen von Null-Bytes am Ende verringert werden, da Argumente C-terminierte Zeichenfolgen sind (dies ist nicht zu unterscheiden, wenn am Ende eine Reihe leerer Argumente stehen).

Wenn Sie wirklich graben möchten, können Sie sich die Quelle einer Open-Source-Implementierung ansehen. Unter Linux ist die Quelle von psnicht interessant. Sie sehen lediglich , dass sie die Befehlszeilenargumente aus dem proc-Dateisystem in liest . Der Code, der den Inhalt dieser Datei generiert, befindet sich im Kernel in in . Der Teil des Speichers des Prozesses (auf den mit zugegriffen wird ) geht von der Adresse zu ; Diese Adressen werden beim Start des Prozesses im Kernel aufgezeichnet und können danach nicht mehr geändert werden./proc/PID/cmdlineproc_pid_cmdline_readfs/proc/base.caccess_remote_vmmm->arg_startmm->arg_end

Einige Daemons verwenden diese Fähigkeit, um ihren Status widerzuspiegeln, z. B. ändern sie ihren Status argv[1]in einen String wie startingoder availableoder exiting. Viele Unix-Varianten haben dazu eine setproctitleFunktion. Einige Programme verwenden diese Funktion, um vertrauliche Daten zu verbergen. Beachten Sie, dass dies von begrenztem Nutzen ist, da die Befehlszeilenargumente sichtbar sind, während der Prozess gestartet wird.

Die meisten höheren Sprachen kopieren die Argumente in Zeichenfolgenobjekte und bieten keine Möglichkeit, den ursprünglichen Speicher zu ändern. Hier ist ein C-Programm, das diese Fähigkeit demonstriert, indem argvElemente direkt geändert werden.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
    int i;
    system("ps -p $PPID -o args=");
    for (i = 0; i < argc; i++)
    {
        memset(argv[i], '0' + (i % 10), strlen(argv[i]));
    }
    system("ps -p $PPID -o args=");
    return 0;
}

Beispielausgabe:

./a.out hello world
0000000 11111 22222

Sie können argvÄnderungen im Curl-Quellcode sehen. Curl definiert eine Funktion, cleanargmitsrc/tool_paramhlp.c der ein Argument in alle Leerzeichen geändert wird memset. In src/tool_getparam.cdieser Funktion wird durch Schwärzen der einige Male, zum Beispiel verwendet , Benutzer - Passwort . Da die Funktion über das Parameter-Parsing aufgerufen wird, geschieht dies zu Beginn eines Curl-Aufrufs. Wenn Sie jedoch die Befehlszeile davor sichern, werden weiterhin alle Kennwörter angezeigt.

Da die Argumente im eigenen Speicher des Prozesses gespeichert sind, können sie nur mit einem Debugger von außen geändert werden.

Die anderen Antworten beantworten die Frage allgemein. Um konkret zu antworten: " Wie wird dieser Effekt erzielt? Befindet er sich irgendwo im Quellcode von curl? ":

Im Argument-Parsing-Abschnitt des Curl-Quellcodes wird die -uOption wie folgt behandelt:

    case 'u':
      /* user:password  */
      GetStr(&config->userpwd, nextarg);
      cleanarg(nextarg);
      break;

Und die cleanarg()Funktion ist wie folgt definiert :

void cleanarg(char *str)
{
#ifdef HAVE_WRITABLE_ARGV
  /* now that GetStr has copied the contents of nextarg, wipe the next
   * argument out so that the username:password isn't displayed in the
   * system process list */
  if(str) {
    size_t len = strlen(str);
    memset(str, ' ', len);
  }
#else
  (void)str;
#endif
}

Wir können also explizit sehen, dass das Argument Benutzername: Kennwort in argvmit Leerzeichen überschrieben wird, wie in den anderen Antworten beschrieben.

Ein Prozess kann seine Parameter nicht nur lesen, sondern auch schreiben.

Ich bin kein Entwickler, daher bin ich mit diesen Dingen nicht vertraut, aber es kann von außen mit einem Ansatz möglich sein, der dem Ändern von Umgebungsparametern ähnelt:

https://stackoverflow.com/questions/205064/is-there-a-way-to-change-another-processs-environment-variables