ฉันใช้ daemon ซอฟต์แวร์ที่ต้องการการดำเนินการบางอย่างเพื่อป้อนวลีรหัสผ่านเพื่อปลดล็อกคุณสมบัติบางอย่างที่มีลักษณะเช่นนี้:

$ darkcoind masternode start <mypassphrase>

ตอนนี้ฉันมีความกังวลด้านความปลอดภัยบนเซิร์ฟเวอร์เดเบียนที่ไม่มีหัวของฉัน

เมื่อใดก็ตามที่ฉันค้นหาประวัติทุบตีของฉันด้วยCtrl+Rฉันสามารถดูรหัสผ่านที่แข็งแกร่งสุดนี้ ตอนนี้ฉันจินตนาการว่าเซิร์ฟเวอร์ของฉันถูกบุกรุกและผู้บุกรุกบางคนมีสิทธิ์เข้าถึงเชลล์และสามารถCtrl+Rค้นหาข้อความรหัสผ่านของฉันในประวัติศาสตร์ได้

มีวิธีการใส่รหัสผ่านโดยไม่ได้ที่จะแสดงในประวัติศาสตร์ทุบตีps, /procหรืออื่นใด?

อัปเดต 1 : การส่งรหัสผ่านไปที่ daemon จะไม่มีข้อผิดพลาดเกิดขึ้น ไม่มีตัวเลือกนี้

อัปเดต 2 : อย่าบอกให้ฉันลบซอฟต์แวร์หรือคำแนะนำที่เป็นประโยชน์อื่น ๆ เช่นการแขวนนักพัฒนา ฉันรู้ว่านี่ไม่ใช่ตัวอย่างการปฏิบัติที่ดีที่สุด แต่ซอฟต์แวร์นี้ใช้bitcoinและลูกค้า bitcoin ทั้งหมดเป็นเซิร์ฟเวอร์ json rpc บางชนิดซึ่งรับฟังคำสั่งเหล่านี้และปัญหาความปลอดภัยที่รู้จักยังคงถูกกล่าวถึง ( a , b , c ) .

อัปเดต 3 : daemon เริ่มต้นแล้วและทำงานด้วยคำสั่ง

$ darkcoind -daemon

การทำpsแสดงเฉพาะคำสั่งเริ่มต้น

$ 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

ดังนั้นการส่งคำสั่งด้วยวลีรหัสผ่านจึงไม่ปรากฏขึ้นpsหรือ/procเลย

$ 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

นี่เป็นคำถามที่ว่าประวัติศาสตร์จะปรากฏที่ใด เฉพาะใน.bash_history?

จริงๆนี้ควรได้รับการแก้ไขในแอปพลิเคชันเอง และแอปพลิเคชันดังกล่าวควรเป็นโอเพ่นซอร์สดังนั้นการแก้ไขปัญหาในแอปควรเป็นตัวเลือก แอปพลิเคชันที่เกี่ยวข้องกับความปลอดภัยซึ่งทำให้เกิดข้อผิดพลาดประเภทนี้อาจทำให้เกิดข้อผิดพลาดอื่นเช่นกันดังนั้นฉันจะไม่เชื่อใจ

ตัวคั่นง่าย

แต่คุณกำลังขอวิธีที่แตกต่างดังนั้นนี่คือ:

#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);
}

รวบรวมสิ่งนี้ด้วย

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

จากนั้นเรียกใช้กระบวนการของคุณด้วย

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

ไลบรารีตัวคั่นจะเรียกใช้รหัสนี้ก่อนที่จะเรียกใช้mainฟังก์ชันจากแอปพลิเคชันของคุณ มันจะแทนที่อาร์กิวเมนต์บรรทัดคำสั่งสุดท้ายด้วยรหัสผ่านจริงในการโทรไปยังหลัก บรรทัดคำสั่งตามที่พิมพ์ไว้ใน/proc/*/cmdline(และเห็นด้วยเครื่องมือเช่นps) จะยังคงมีอาร์กิวเมนต์ปลอมอยู่ เห็นได้ชัดว่าคุณต้องสร้างซอร์สโค้ดและchmod 0700ไลบรารี่ที่คุณคอมไพล์จากมันเท่านั้นที่สามารถอ่านได้ด้วยตัวเองดังนั้นทำงานได้ดีที่สุดในไดเรกทอรี และเนื่องจากรหัสผ่านไม่ได้เป็นส่วนหนึ่งของการเรียกใช้คำสั่งประวัติทุบตีของคุณก็ปลอดภัยเช่นกัน

ตัวคั่นขั้นสูงเพิ่มเติม

หากคุณต้องการทำอะไรที่ซับซ้อนกว่านี้คุณควรระลึกไว้เสมอว่า__libc_start_mainถูกเรียกใช้งานก่อนที่ไลบรารีรันไทม์จะเริ่มต้นอย่างถูกต้อง ดังนั้นฉันขอแนะนำให้หลีกเลี่ยงการเรียกใช้ฟังก์ชันใด ๆ เว้นแต่จะจำเป็นอย่างยิ่ง หากคุณต้องการที่จะเรียกฟังก์ชั่นไปยังเนื้อหาในหัวใจของคุณตรวจสอบให้แน่ใจก่อนที่mainจะเรียกใช้ตัวเองก่อนที่จะเริ่มต้นหลังจากเสร็จสิ้นการเริ่มต้นทั้งหมด สำหรับตัวอย่างต่อไปนี้ฉันต้องขอบคุณ Grubermensch ที่ชี้ให้เห็นว่าจะซ่อนรหัสผ่านที่ผ่านเป็นอาร์กิวเมนต์บรรทัดคำสั่งซึ่งทำให้getpassฉันสนใจ

#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);
}

การดำเนินการนี้จะขอรหัสผ่านดังนั้นคุณไม่จำเป็นต้องเก็บรักษารหัสลับไว้ในไลบรารีอีกต่อไป อาร์กิวเมนต์ตัวยึดตำแหน่งถูกนำมาใช้ซ้ำเป็นพรอมต์รหัสผ่านดังนั้นให้เรียกใช้สิ่งนี้

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

อีกทางเลือกหนึ่งจะอ่านรหัสผ่านจากตัวให้คำอธิบายไฟล์ (เช่นgpg --passphrase-fdทำเช่นนั้น) หรือจากx11-ssh-askpassหรืออะไรก็ตาม

มันไม่ใช่แค่ประวัติศาสตร์ มันจะแสดงในเอาต์พุตpsเช่นกัน

ใครก็ตามที่เขียนชิ้นส่วนของซอฟต์แวร์นั้นควรถูกแขวนวาดและแบ่งออกเป็นสี่ส่วน ไม่จำเป็นที่จะต้องใส่รหัสผ่านบนบรรทัดคำสั่งโดยไม่คำนึงว่าซอฟต์แวร์ใดก็ตาม
สำหรับกระบวนการภูตมันยิ่งให้อภัยไม่ได้ ...

นอกจากrm-fบนตัวซอฟต์แวร์เองฉันไม่รู้วิธีแก้ปัญหาสำหรับเรื่องนี้ สุจริต: ค้นหาซอฟต์แวร์อื่น ๆ เพื่อให้งานสำเร็จลุล่วง อย่าใช้ขยะเช่นนั้น

นี่จะล้างpsเอาท์พุท

ระวังตัวมาก : สิ่งนี้อาจทำให้แอปพลิเคชันหยุดทำงาน คุณได้รับการเตือนอย่างถูกต้องว่าที่นี่เป็นมังกร

• กระบวนการต่างประเทศไม่ควรเล่นซอในหน่วยความจำกระบวนการ
• หากกระบวนการนี้ขึ้นอยู่กับภูมิภาคนี้สำหรับรหัสผ่านคุณอาจทำลายแอปพลิเคชันของคุณ
• การทำเช่นนี้อาจทำให้ข้อมูลการทำงานที่คุณมีในกระบวนการนั้นเสียหาย
• นี่คือการแฮ็กที่บ้า

ตอนนี้คุณจะได้รับแจ้งจากคำเตือนที่น่ากลัวเหล่านี้ psนี้จะล้างเอาท์พุทที่แสดงใน มันจะไม่ล้างประวัติของคุณและจะไม่ล้างประวัติงานทุบตี (เช่นการเรียกใช้กระบวนการเช่นmyprocess myargs &) แต่psจะไม่แสดงข้อโต้แย้งอีกต่อไป

#!/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)

เรียกใช้โปรแกรมโดยการบันทึกchmod +xมัน จากนั้นทำ./whatever <pidoftarget> ถ้ามันใช้งานได้มันจะไม่สร้างเอาต์พุต ถ้ามันล้มเหลวมันจะบ่นเกี่ยวกับบางสิ่งและเลิก

คุณสามารถส่งผ่านอาร์กิวเมนต์จากไฟล์เข้าถึงได้โดย root หรือผู้ใช้ที่ต้องการหรือไม่

มันเป็นเรื่องใหญ่มากที่จะพิมพ์รหัสผ่านในคอนโซล แต่การขอความช่วยเหลือครั้งสุดท้าย ... เริ่มต้นบรรทัดของคุณด้วยช่องว่างเพื่อไม่ให้ปรากฏในประวัติ

อาจใช้งานได้ (?):

darkcoind masternode start `cat password.txt`

แต่ถ้าคุณสั่งคาดว่ารหัสผ่านเป็นอาร์กิวเมนต์บรรทัดคำสั่งแล้วก็จะได้สัมผัสผ่านสาธารณูปโภคเช่นdarkcoind psเพียงการแก้ปัญหาที่แท้จริงคือการให้ความรู้แก่นักพัฒนา

แม้ว่าการpsเปิดเผยอาจไม่สามารถหลีกเลี่ยงได้ แต่อย่างน้อยคุณสามารถป้องกันไม่ให้รหัสผ่านถูกเขียนลงในไฟล์ประวัติเชลล์

$ xargs darkcoind masternode start

password⏎

CtrlD

ไฟล์ประวัติควรบันทึกเท่านั้นxargs darkcoind masternode startไม่ใช่รหัสผ่าน

ดังที่คนอื่นได้กล่าวไว้ดูที่การควบคุมประวัติเชลล์ของคุณเพื่อซ่อนข้อมูลจากประวัติ

แต่สิ่งหนึ่งที่ดูเหมือนไม่มีใครมีข้อเสนอแนะเลยคือการติด/procกับhidepidพารามิเตอร์ ลองปรับเปลี่ยน/procสาย ของคุณ/etc/fstabเพื่อรวมhidepidเช่น:

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

คุณสามารถป้องกันรหัสผ่านออกจากประวัติเชลล์ของคุณได้โดยการดำเนินการคำสั่งจากกระบวนการเชลล์ใหม่ซึ่งคุณจะยุติทันที ตัวอย่างเช่น:

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

ตรวจสอบให้แน่ใจว่าshมีการกำหนดค่าไม่ให้บันทึกประวัติในไฟล์

หลักสูตรนี้ไม่ได้อยู่ที่ปัญหาอื่น ๆ psเช่นรหัสผ่านที่ถูกมองเห็นได้ใน ฉันเชื่อว่ามีวิธีสำหรับdarkcoindตัวโปรแกรมในการซ่อนข้อมูลจากpsแต่นั่นจะทำให้หน้าต่างของช่องโหว่สั้นลงเท่านั้น

สำหรับ Bitcoin คำตอบของผู้พัฒนาอย่างเป็นทางการคือใช้ตัวห่อหลามที่ให้มาในcontrib/bitrpc/bitrpc.py( gitHub ):

มันถามรหัสผ่านในวิธีที่ปลอดภัยถ้าคุณใช้คำสั่งwalletpassphraseเช่น bitcoin-cliไม่มีแผนการที่จะเพิ่มฟังก์ชันการทำงานแบบโต้ตอบเพื่อเป็น

และ:

bitcoin-cli จะยังคงเป็นอยู่และไม่ได้รับฟังก์ชันการทำงานแบบโต้ตอบ

ที่มา: # 2318

ปลดล็อคกระเป๋าเงิน:

$ python bitrpc.py walletpassphrase

เปลี่ยนข้อความรหัสผ่าน:

$ python bitrpc.py walletpassphrasechange

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

สำหรับ darkcoin มันทำงานได้อย่างเป็นทางการ:

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