Sto eseguendo un demone software che richiede che determinate azioni inseriscano una passphrase per sbloccare alcune funzionalità che sembrano ad esempio così:

$ darkcoind masternode start <mypassphrase>

Ora ho avuto alcuni problemi di sicurezza sul mio server debian senza testa.

Ogni volta che cerco nella mia cronologia di bash per esempio con Ctrl+Rposso vedere questa password super forte. Ora immagino che il mio server sia compromesso e alcuni intrusi abbiano accesso alla shell e riescano semplicemente Ctrl+Ra trovare la mia passphrase nella cronologia.

C'è un modo per inserire la passphrase senza che sia mostrata nella storia di bash ps, /proco altrove?

Aggiornamento 1 : il passaggio di nessuna password al demone genera un errore. Questa non è un'opzione.

Aggiornamento 2 : non dirmi di eliminare il software o altri suggerimenti utili come appendere gli sviluppatori. So che questo non è un esempio di best practice, ma questo software si basa su bitcoin e tutti i client basati su bitcoin sono una sorta di server json rpc che ascolta questi comandi ed è ancora in discussione un problema di sicurezza noto ( a , b , c ) .

Aggiornamento 3 : il daemon è già avviato e in esecuzione con il comando

$ darkcoind -daemon

Fare psmostra solo il comando di avvio.

$ ps aux | grep darkcoin
user     12337  0.0  0.0  10916  1084 pts/4    S+   09:19   0:00 grep darkcoin
user     21626  0.6  0.3 1849716 130292 ?      SLl  May02   6:48 darkcoind -daemon

Quindi passare i comandi con la passphrase non viene visualizzato pso /procaffatto.

$ darkcoind masternode start <mypassphrase>
$ ps aux | grep darkcoin
user     12929  0.0  0.0  10916  1088 pts/4    S+   09:23   0:00 grep darkcoin
user     21626  0.6  0.3 1849716 130292 ?      SLl  May02   6:49 darkcoind -daemon

Questo lascia la domanda dove si presenta la storia? Solo in .bash_history?

Davvero, questo dovrebbe essere risolto nell'applicazione stessa. E tali applicazioni dovrebbero essere open source, quindi l'opzione di risolvere il problema nell'app stessa dovrebbe essere un'opzione. Un'applicazione relativa alla sicurezza che commette questo tipo di errore potrebbe fare anche altri errori, quindi non mi fiderei.

Interposer semplice

Ma stavi chiedendo un modo diverso, quindi eccone uno:

#define _GNU_SOURCE
#include <dlfcn.h>

int __libc_start_main(
    int (*main) (int, char * *, char * *),
    int argc, char * * ubp_av,
    void (*init) (void),
    void (*fini) (void),
    void (*rtld_fini) (void),
    void (* stack_end)
  )
{
  int (*next)(
    int (*main) (int, char * *, char * *),
    int argc, char * * ubp_av,
    void (*init) (void),
    void (*fini) (void),
    void (*rtld_fini) (void),
    void (* stack_end)
  ) = dlsym(RTLD_NEXT, "__libc_start_main");
  ubp_av[argc - 1] = "secret password";
  return next(main, argc, ubp_av, init, fini, rtld_fini, stack_end);
}

Compila questo con

gcc -O2 -fPIC -shared -o injectpassword.so injectpassword.c -ldl

quindi eseguire il processo con

LD_PRELOAD=$PWD/injectpassword.so darkcoind masternode start fakepasshrase

La libreria interposer eseguirà questo codice prima dell'esecuzione della mainfunzione dell'applicazione. Sostituirà l'ultimo argomento della riga di comando con la password effettiva nella chiamata a main. La riga di comando stampata /proc/*/cmdline(e quindi vista da strumenti come ps) conterrà comunque l'argomento falso. Ovviamente dovresti rendere il codice sorgente e la libreria che compili da esso leggibile solo a te stesso, quindi è meglio operare in una chmod 0700directory. E poiché la password non fa parte dell'invocazione del comando, anche la cronologia di bash è sicura.

Interposer più avanzato

Se vuoi fare qualcosa di più elaborato, dovresti tenere presente che __libc_start_mainviene eseguito prima che la libreria di runtime sia stata inizializzata correttamente. Quindi suggerirei di evitare qualsiasi chiamata di funzione a meno che non sia assolutamente essenziale. Se vuoi essere in grado di chiamare funzioni al contenuto del tuo cuore, assicurati di farlo appena prima che mainvenga invocato, dopo che è stata eseguita tutta l'inizializzazione. Per il seguente esempio devo ringraziare Grubermensch che ha sottolineato come nascondere una password passata come argomento della riga di comando che ha portato getpassalla mia attenzione.

#define _GNU_SOURCE
#include <dlfcn.h>
#include <unistd.h>

static int (*real_main) (int, char * *, char * *);

static int my_main(int argc, char * * argv, char * * env) {
  char *pass = getpass(argv[argc - 1]);
  if (pass == NULL) return 1;
  argv[argc - 1] = pass;
  return real_main(argc, argv, env);
}

int __libc_start_main(
    int (*main) (int, char * *, char * *),
    int argc, char * * ubp_av,
    void (*init) (void),
    void (*fini) (void),
    void (*rtld_fini) (void),
    void (* stack_end)
  )
{
  int (*next)(
    int (*main) (int, char * *, char * *),
    int argc, char * * ubp_av,
    void (*init) (void),
    void (*fini) (void),
    void (*rtld_fini) (void),
    void (* stack_end)
  ) = dlsym(RTLD_NEXT, "__libc_start_main");
  real_main = main;
  return next(my_main, argc, ubp_av, init, fini, rtld_fini, stack_end);
}

Questo richiede la password, quindi non è più necessario mantenere segreta la libreria interposer. L'argomento segnaposto viene riutilizzato come prompt della password, quindi invocare questo come

LD_PRELOAD=$PWD/injectpassword.so darkcoind masternode start "Password: "

Un'altra alternativa potrebbe leggere la password da un descrittore di file (come ad esempio gpg --passphrase-fd), o da x11-ssh-askpass, o qualsiasi altra cosa.

Non è solo la storia. Verrà visualizzato anche nell'output ps .

Chiunque abbia scritto quel pezzo di software dovrebbe essere appeso, disegnato e diviso in quarti. È un NO assoluto dover fornire una password sulla riga di comando, indipendentemente dal software.
Per un processo daemon è persino PIÙ imperdonabile ...

Oltre a rm -f sul software stesso non conosco alcuna soluzione per questo. Onestamente: trova altri software per completare il lavoro. Non usare questa spazzatura.

Questo cancellerà l' psoutput.

ATTENZIONE : questo potrebbe interrompere l'applicazione. Sei debitamente avvisato che qui ci sono draghi.

• I processi estranei non dovrebbero armeggiare nella memoria dei processi.
• Se il processo si basa su questa regione per la password, è possibile interrompere l'applicazione.
• Ciò potrebbe danneggiare i dati di lavoro che hai in quel processo.
• Questo è un trucco folle.

Ora sei debitamente informato di questi terribili avvertimenti. Questo cancellerà l'output visualizzato in ps. Non cancellerà la tua cronologia, né cancellerà la cronologia dei lavori bash (come eseguire il processo come myprocess myargs &). Ma psnon mostrerà più gli argomenti.

#!/usr/bin/python
import os, sys
import re

PAGESIZE=4096

if __name__ == "__main__":
  if len(sys.argv) < 2:
    sys.stderr.write("Must provide a pid\n")
    sys.exit(1)

  pid = sys.argv[1]

  try:
    cmdline = open("/proc/{0}/cmdline".format(pid)).read(8192)

    ## On linux, at least, argv is located in the stack. This is likely o/s
    ## independent.
    ## Open the maps file and obtain the stack address.
    maps = open("/proc/{0}/maps".format(pid)).read(65536)
    m = re.search('([0-9a-f]+)-([0-9a-f]+)\s+rw.+\[stack\]\n', maps)
    if not m:
      sys.stderr.write("Could not find stack in process\n");
      sys.exit(1)

    start = int("0x"+m.group(1), 0)
    end = int("0x"+m.group(2), 0)

    ## Open the mem file
    mem = open('/proc/{0}/mem'.format(pid), 'r+')
    ## As the stack grows downwards, start at the end. It is expected
    ## that the value we are looking for will be at the top of the stack
    ## somewhere
    ## Seek to the end of the stack minus a couple of pages.
    mem.seek(end-(2*PAGESIZE))

    ## Read this buffer to the end of the stack
    stackportion = mem.read(8192)
    ## look for a string matching cmdline. This is pretty dangerous.
    ## HERE BE DRAGONS
    m = re.search(cmdline, stackportion)
    if not m:
      ## cause this is an example dont try to search exhaustively, just give up
      sys.stderr.write("Could not find command line in the stack. Giving up.")
      sys.exit(1)

    ## Else, we got a hit. Rewind our file descriptor, plus where we found the first argument.
    mem.seek(end-(2*PAGESIZE)+m.start())
    ## Additionally, we'll keep arg0, as thats the program name.
    arg0len = len(cmdline.split("\x00")[0]) + 1
    mem.seek(arg0len, 1)

    ## lastly overwrite the remaining region with nulls.
    writeover = "\x00" * (len(cmdline)-arg0len)
    mem.write(writeover)

    ## cleanup
    mem.close()

  except OSError, IOError:
    sys.stderr.write("Cannot find pid\n")
    sys.exit(1)

Richiama il programma salvandolo chmod +x. Quindi facendo ./whatever <pidoftarget> Se funziona, non produrrà alcun output. Se fallisce, si lamenterà di qualcosa e si fermerà.

Puoi passare l'argomento da un file, accessibile solo dal root o dall'utente richiesto?

È un ENORME no-no digitare le password nella console, ma l'ultima risorsa ... iniziare la linea con uno spazio in modo che non compaia nella cronologia.

Forse funziona (?):

darkcoind masternode start `cat password.txt`

Sfortunatamente, se il tuo darkcoindcomando prevede che la password sia un argomento della riga di comando, sarà esposta attraverso utility come ps. L'unica vera soluzione è educare gli sviluppatori .

Sebbene l' psesposizione possa essere inevitabile, è possibile almeno impedire che la password venga scritta nel file cronologico della shell.

$ xargs darkcoind masternode start

password⏎

CtrlD

Il file della cronologia deve solo registrare xargs darkcoind masternode start, non la password.

Come altri hanno già detto, controlla il controllo della cronologia della shell per nascondere le informazioni dalla cronologia.

Ma una cosa che nessuno sembra aver ancora suggerito è montare /proccon il hidepidparametro. Prova a modificare la /procriga /etc/fstabper includerla hidepid, in questo modo:

# <file system> <mount point>   <type>  <options>       <dump>  <pass>
proc            /proc           proc    defaults,hidepid=2        0       0

È possibile mantenere la password fuori dalla cronologia della shell eseguendo il comando da un nuovo processo di shell, che si termina immediatamente. Per esempio:

bash$ sh
sh$ darkcoind masternode start 'correct horse battery staple'
sh$ exit
bash$

Assicurarsi che shsia configurato per non salvare la sua cronologia in un file.

Naturalmente questo non affronta gli altri problemi, come la password in cui è visibile ps. Credo che ci siano modi in cui il darkcoindprogramma stesso può nascondere le informazioni ps, ma ciò riduce solo la finestra della vulnerabilità.

Per Bitcoin, la risposta ufficiale dello sviluppatore è utilizzare il wrapper python fornito in contrib/bitrpc/bitrpc.py( github ):

Richiede una password in modo sicuro se si utilizza il comando walletpassphrase, ad esempio. Non ci sono piani per aggiungere funzionalità interattive a bitcoin-cli.

e:

bitcoin-cli rimarrà così com'è e non acquisirà funzionalità interattive.

Fonte: # 2318

Sblocca portafoglio:

$ python bitrpc.py walletpassphrase

Cambia passphrase:

$ python bitrpc.py walletpassphrasechange

https://github.com/bitcoin/bitcoin/tree/master/contrib/bitrpc

Per darkcoin funziona anlogue:

https://github.com/darkcoin/darkcoin/tree/master/contrib/bitrpc