ฉันจะรัน ssh-add อัตโนมัติได้อย่างไรโดยไม่ต้องใส่รหัสผ่าน?

ฉันต้องการสื่อสารระหว่างคอมพิวเตอร์หลายเครื่องบนเครือข่ายของฉัน (สแตติกอีเธอร์เน็ต) ผ่าน SSH เพื่อที่จะทำเช่นนั้นฉันจำเป็นต้องเรียกใช้ ssh-add ทุกครั้งที่ฉันเข้าสู่ระบบบนเครื่องที่เฉพาะเจาะจงฉันจะทำมันได้อย่างไรเพื่อให้มันตั้งขึ้นหนึ่งครั้งและไม่ถามฉันสำหรับวลีรหัสผ่านทุกครั้งที่ฉันเข้าสู่ระบบหรือรีบูต เครื่องของฉัน

ฉันรู้ว่ามีวิธีที่คุณควรเพิ่มบางบรรทัดในbash_profileไฟล์ แต่ฉันยังต้องพิมพ์รหัสผ่านทุกครั้งที่ฉันรีบูต / เข้าสู่ระบบไปยังเครื่องเฉพาะ

if [ -z "$SSH_AUTH_SOCK" ] ; then
    eval `ssh-agent -s`
    ssh-add
fi

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

ssh-key พร้อมข้อความรหัสผ่านไม่ ssh-agent

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

ssh-key พร้อมข้อความรหัสผ่านด้วย ssh-agent

การเพิ่มรายการต่อไปนี้เพื่อ~/.bash_profileจะเริ่มต้นโดยอัตโนมัติssh-agentและโหลด ssh-key (s) เมื่อเข้าสู่ระบบ:

if [ -z "$SSH_AUTH_SOCK" ] ; then
  eval `ssh-agent -s`
  ssh-add
fi

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

หากต้องการฆ่าssh_agentเมื่อออกจากระบบให้เพิ่มรายการต่อไปนี้ใน~/.bash_logout

if [ -n "$SSH_AUTH_SOCK" ] ; then
  eval `/usr/bin/ssh-agent -k`
fi

หรือต่อไปนี้เพื่อ ~/.bash_profile

trap 'test -n "$SSH_AUTH_SOCK" && eval `/usr/bin/ssh-agent -k`' 0

การสร้างหลายssh-agentกรณีสามารถหลีกเลี่ยงได้โดยการสร้างซ็อกเก็ตการสื่อสารแบบถาวรไปยังตัวแทนในตำแหน่งที่คงที่ในระบบแฟ้มเช่นในคำตอบ Collin เดอร์สัน นี่คือการปรับปรุงการวางไข่เอเจนต์หลายอินสแตนซ์อย่างไรก็ตามยกเว้นการฆ่าคีย์ถอดรหัสที่ยังคงอยู่ในหน่วยความจำหลังจากออกจากระบบอย่างชัดเจน

บนเดสก์ท็อป ssh-agent ที่มาพร้อมกับสภาพแวดล้อมเดสก์ท็อปเช่นGnome Keyring SSH Agentอาจเป็นวิธีที่ดีกว่าเนื่องจากพวกเขาสามารถทำการขอให้ใส่ข้อความรหัสผ่านในครั้งแรกที่ใช้ ssh-key ในระหว่างการเข้าสู่ระบบและ เก็บคีย์ส่วนตัวที่ถอดรหัสไว้ในหน่วยความจำจนกระทั่งสิ้นสุดเซสชัน

ssh-key พร้อมข้อความรหัสผ่านด้วย ssh-ident

ssh-identเป็นยูทิลิตี้ที่สามารถจัดการssh-agentในนามของคุณและโหลดตัวตนตามความจำเป็น มันจะเพิ่มปุ่มเพียงครั้งเดียวที่พวกเขามีความจำเป็นโดยไม่คำนึงถึงวิธีการหลายขั้ว, SSH ssh-agentหรือเข้าสู่ระบบการประชุมที่จำเป็นต้องมีการเข้าถึง นอกจากนี้ยังสามารถเพิ่มและใช้ตัวแทนที่แตกต่างกันและชุดคีย์ที่แตกต่างกันขึ้นอยู่กับโฮสต์ที่เชื่อมต่อกับหรือไดเรกทอรี ssh ถูกเรียกใช้จาก สิ่งนี้ช่วยให้สามารถแยกคีย์เมื่อใช้ตัวแทนการส่งต่อกับโฮสต์ที่แตกต่างกัน นอกจากนี้ยังอนุญาตให้ใช้หลายบัญชีในเว็บไซต์เช่น GitHub

หากต้องการเปิดใช้งานให้ssh-identติดตั้งและเพิ่มนามแฝงต่อไปนี้ใน~/bash_profile:

alias ssh='/path/to/ssh-ident'

ssh-key พร้อมข้อความรหัสผ่านด้วย keychain

keychainเป็นยูทิลิตี้ขนาดเล็กที่จัดการssh-agentในนามของคุณและช่วยให้การssh-agentยังคงทำงานเมื่อสิ้นสุดเซสชั่นการเข้าสู่ระบบ เมื่อเข้าสู่ระบบในภายหลังkeychainจะเชื่อมต่อกับssh-agentอินสแตนซ์ที่มีอยู่ ในทางปฏิบัติหมายความว่าต้องป้อนวลีรหัสผ่านเฉพาะในระหว่างการเข้าสู่ระบบครั้งแรกหลังจากรีบูต ในการเข้าสู่ระบบครั้งต่อไปจะใช้รหัสที่ไม่ได้เข้ารหัสจากssh-agentอินสแตนซ์ที่มีอยู่ สิ่งนี้ยังมีประโยชน์สำหรับการอนุญาตให้ใช้การพิสูจน์ตัวตน RSA / DSA แบบcronไม่ใช้รหัสผ่านในงานโดยไม่มีรหัสผ่าน ssh-keys

หากต้องการเปิดใช้งานให้keychainติดตั้งและเพิ่มสิ่งต่อไปนี้เพื่อ~/.bash_profile:

eval `keychain --agents ssh --eval id_rsa`

จากมุมมองด้านความปลอดภัยssh-identและkeychainแย่กว่าssh-agentอินสแตนซ์ที่ จำกัด อายุการใช้งานของเซสชันที่ระบุ แต่จะให้ความสะดวกในระดับสูง เพื่อปรับปรุงความปลอดภัยของkeychainบางคนเพิ่ม--clearตัวเลือกในการขอ~/.bash_profileพวงกุญแจของพวกเขา ด้วยการทำข้อความรหัสผ่านนี้จะต้องป้อนอีกครั้งในการเข้าสู่ระบบดังกล่าวข้างต้น แต่cronงานจะยังคงมีการเข้าถึงกุญแจที่ไม่ได้เข้ารหัสหลังจากที่ผู้ใช้ออกจากระบบ keychain หน้าวิกิพีเดียมีข้อมูลเพิ่มเติมและตัวอย่าง

ssh-key โดยไม่ต้องใช้วลีรหัสผ่าน

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

ssh-key พร้อมวลีรหัสผ่าน, พร้อม ssh-agent , ส่งข้อความรหัสผ่านไปยัง ssh-add จากสคริปต์

ในขณะที่มันอาจจะดูเหมือนเป็นความคิดที่ตรงไปตรงมาผ่านรหัสผ่านไปssh-addจากสคริปต์เช่นecho "passphrase\n" | ssh-addนี้ไม่ได้เป็น straighforward ที่ดูเหมือนว่าเป็นssh-add ไม่ได้อ่านข้อความรหัสผ่านจากstdinแต่เปิด/dev/ttyโดยตรงสำหรับการอ่าน

นี้สามารถทำงานรอบด้วยexpectซึ่งเป็นเครื่องมือสำหรับการทำงานอัตโนมัติใช้งานแบบโต้ตอบ ด้านล่างเป็นตัวอย่างของสคริปต์ที่เพิ่ม ssh-key โดยใช้วลีรหัสผ่านที่เก็บไว้ในสคริปต์:

#!/usr/bin/expect -f
spawn ssh-add /home/user/.ssh/id_rsa
expect "Enter passphrase for /home/user/.ssh/id_rsa:"
send "passphrase\n";
expect "Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)"
interact

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

เพิ่มลงในของคุณ~/.bashrcจากนั้นออกจากระบบและกลับเข้ามาใหม่เพื่อให้มีผล

if [ ! -S ~/.ssh/ssh_auth_sock ]; then
  eval `ssh-agent`
  ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock
ssh-add -l > /dev/null || ssh-add

นี่ควรจะถามรหัสผ่านในครั้งแรกที่คุณเข้าสู่ระบบหลังจากรีบูตแต่ละครั้ง มันจะนำมาใช้ซ้ำssh-agentตราบใดที่มันยังคงทำงานอยู่

ไม่เกี่ยวข้องกับคำถามของ OP อย่างใกล้ชิด แต่อาจเป็นประโยชน์กับผู้อื่น: เนื่องจาก 7.2.0 ssh (1) มีตัวเลือกที่อนุญาตให้เพิ่มคีย์ใน ssh-agent เมื่อทำการพิสูจน์ตัวตนครั้งแรก ตัวเลือกที่ถูกAddKeysToAgentและสามารถตั้งค่าให้yes, no, askหรือconfirm, systemwide หรือส่วนบุคคลของคุณ.ssh/configไฟล์

การอ้างอิง: https://www.openssh.com/txt/release-7.2

ssh-agent แคช ssh-keys ที่ปลดล็อกต่าง ๆ ดังนั้นคุณสามารถมี ssh-keys ที่ป้องกันด้วยรหัสผ่าน แต่ไม่ต้องพิมพ์ทุกครั้ง

ในการที่จะปลดล็อคกุญแจแคชมันจะต้องปลดล็อคกุญแจเหล่านั้น สำหรับการปลดล็อกคีย์ที่ถูกล็อกด้วยวลีรหัสผ่านจำเป็นต้องทราบรหัสผ่านเหล่านี้อย่างชัดเจน

วิธีการใด ๆ ที่ไม่ต้องการการอนุญาตจากมนุษย์ (เช่น "การพิมพ์รหัสผ่าน") ไม่เพียง แต่จะทำให้ระบบของคุณไม่ปลอดภัยเท่านั้น มันจะทำให้วัตถุประสงค์ทั้งหมดของ ssh-agent ไร้ความหมาย

เมื่อพูดทั้งหมดนี้คุณสามารถใช้ ssh-keys ที่ไม่ได้รับการป้องกันด้วยรหัสผ่าน (กดEnterเมื่อถูกถามถึงรหัสผ่านในระหว่างการสร้างคีย์) เนื่องจากไม่มีรหัสผ่านใด ๆssh-agentจึงไม่จำเป็นต้องขอรหัสผ่านจากคุณเพื่อแคช (ไม่)

ต่อไปนี้เป็นวิธีแก้ไขปัญหาโดยอัตโนมัติสำหรับข้อความรหัสผ่าน SSH ของคุณ

1. สร้างสคริปต์แบบหนึ่งบรรทัดซึ่งพิมพ์ข้อความรหัสผ่านของคุณไปที่เอาต์พุตมาตรฐานเช่น:

    echo 'echo MY_SSH_PASSWORD' > ~/.print_ssh_password && chmod 700 ~/.print_ssh_password
   

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

และใช้วิธีใดวิธีหนึ่งต่อไปนี้

• ใช้วิธีการอินพุตมาตรฐาน:

  cat ~/.ssh/id_rsa | SSH_ASKPASS=~/.print_ssh_password ssh-add -
  

• หรือวิธีการท่อชื่อ :

  1. สร้างไปป์ที่มีชื่อ (คุณสามารถลองเปลี่ยนกระบวนการ ):

     mkfifo --mode 0600 ~/.ssh_fifo
     

  2. เรียกใช้ssh-addโดยการระบุโปรแกรมที่ใช้สำหรับการรับรองความถูกต้อง:

     cat ~/.ssh/id_rsa >~/.ssh_fifo | SSH_ASKPASS=~/.print_ssh_password ssh-add ~/.ssh_fifo
     

  ดู: เพื่ออ่านข้อมูลเพิ่มเติมเกี่ยวกับman ssh-addSSH_ASKPASS

ฉันจะไม่แนะนำให้คุณ ssh-add (ซึ่งจำเป็นต้องเปิด ssh-agent) เมื่อเข้าสู่ระบบ นี่เป็นเพราะคุณไม่สามารถควบคุมได้เมื่อส่วน ssh-agent สิ้นสุดลงและสามารถสร้างความเสี่ยงด้านความปลอดภัยเมื่อคุณไม่ต้องการใช้ keyfiles ในส่วนการเข้าสู่ระบบเดียว

แต่ฉันขอแนะนำให้เขียนสคริปต์ซึ่งเปิด sub-shell ส่วนของ ssh-agent ด้วยการเพิ่ม keyfiles อัตโนมัติทั้งหมดและถูกเรียกใช้เมื่อต้องการใช้ ssh หากคุณสามารถรับรองได้โปรดอ่านต่อ

คุณจะมีสองทางเลือก:

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

2. ใช้ข้อความรหัสผ่านเดียวกันสำหรับคีย์ของคุณ จากนั้นเมื่อคุณssh-add keyfile1 keyfile2 ...คุณจะต้องพิมพ์ข้อความรหัสผ่านเพียงครั้งเดียวต่อส่วน

ในทั้งสองกรณีคุณสามารถเขียนไฟล์สคริปต์ "ssh_keys_section.sh" ดังต่อไปนี้:

#!/bin/bash
# This script run a ssh-agent on a sub-shell and automatically ssh-add all keyfiles at once.
# This agent ends when you type `exit` to close the sub-shell.
exec ssh-agent bash -c "ssh-add /path/to/keyfile1 /path/to/keyfile2 ...; exec bash"

หมายเหตุ:

• คำสั่งเพื่อเปลี่ยนหรือลบข้อความรหัสผ่าน: ssh-keygen -p -f keyfile
• ภายใน sub-shell คุณอาจแยกเทอร์มินัลให้มากขึ้นซึ่งแชร์คีย์ปลดล็อคเดียวกันโดยใช้คำสั่งเช่น/path/to/yourterminal &(ขึ้นอยู่กับระบบปฏิบัติการ)

if [ ! -S ${HOME}/.ssh/ssh_auth_sock ]; then
  eval $(ssh-agent)
  ln -sf "${SSH_AUTH_SOCK}" ${HOME}/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=${HOME}/.ssh/ssh_auth_sock

ssh_keys=$(find -E ~/.ssh -type f -regex '.*(rsa$|pem)')
ssh_agent_keys=$(ssh-add -l | awk '{key=NF-1; print $key}')

for k in "${ssh_keys}"; do
    for l in "${ssh_agent_keys}"; do
        if [[ ! "${k}" = "${l}" ]]; then
            ssh-add "${k}" > /dev/null 2>&1
        fi
    done
done

ฉันเคยใช้สคริปต์ที่กล่าวถึงโดย steampowered ฉันทำด้านล่างหนึ่งตอนนี้เพราะมันไม่ปล่อยให้ไฟล์วางอยู่รอบ ๆ

ทำงานบนzshเชลล์เท่านั้น

#!/bin/sh

AGENT_BIN=`which ssh-agent`
AGENT_ADD_BIN=`which ssh-add`
AGENT_PID=`ps -fe | grep ${AGENT_BIN} | awk -vuser=$USER -vcmd="$AGENT_BIN" '$1==user && $8==cmd{print $2;exit;}'`
if [ -z "$AGENT_BIN" ]; then
    echo "no ssh agent found!";
    return
fi
if [ "" -eq "$AGENT_PID" ]; then
    if read -sq "YN?Do you want to unlock your ssh keys?"; then
        echo ""
        output=`$AGENT_BIN | sed 's/echo/#echo/g'`
        eval $output
        $AGENT_ADD_BIN
    fi
else
    for f in "/proc/"*
    do
        cmdline=`cat "$f/cmdline"`
        if [ "${AGENT_BIN}" -ef "${cmdline}" ]; then
            export SSH_AUTH_SOCK=`cat $f/net/unix | grep --binary-file=text -oP '((/[^/]*?)+/ssh-[^/]+/agent\.\d+$)'`
            export SSH_AGENT_PID=${f##*/}
            break;
        fi
    done
fi

SSH_ENV="$HOME/.ssh/environment"

function start_agent {
     echo "Initialising new SSH agent..."
     /usr/bin/ssh-agent | sed 's/^echo/#echo/' > "${SSH_ENV}"
     echo succeeded
     chmod 600 "${SSH_ENV}"
     . "${SSH_ENV}" > /dev/null
     /usr/bin/ssh-add;
}

# Source SSH settings, if applicable

if [ -f "${SSH_ENV}" ]; then
     . "${SSH_ENV}" > /dev/null
     #ps ${SSH_AGENT_PID} doesn't work under cywgin
     ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
         start_agent;
     }
else
     start_agent;
fi

ให้เครดิตที่นี่: https://www.cygwin.com/ml/cygwin/2001-06/msg00537.html

โซลูชันนี้รับรองที่นี่ด้วย: http://mah.everybody.org/docs/ssh

เข้าสู่ระบบเดียวในการแก้ปัญหาสำหรับ SSH pam_sshสามารถนำฉันไป

ตามบทความนี้แนวคิดคือ:

หากคุณทำงานกับเครื่องที่ใช้ * nix หลายเครื่องผ่าน ssh คุณอาจเบื่อที่จะต้องป้อนรหัสผ่านของคุณทุกครั้งที่คุณต้องการเข้าถึงกล่องอื่น มีวิธีที่ปลอดภัยในการอนุญาตให้คุณเข้าถึงทุกเครื่องที่คุณมีการเข้าถึง ssh โดยไม่ต้องป้อนรหัสผ่านอื่น (นอกเหนือจากที่คุณลงชื่อเข้าใช้ด้วยเดิม)

นี่เป็นเรื่องง่ายที่จะทำโดยทั่วไปคุณเพียงแค่สร้างคู่กุญแจสาธารณะ / ส่วนตัวเพื่อรับรองความถูกต้องของตัวคุณเองกับเครื่องอื่น ๆ จากนั้นให้ PAM วางตัวแทนเพื่อโหลดกุญแจของคุณหลังจากที่คุณเข้าสู่ระบบ เครื่อง คำแนะนำนี้จะแนะนำคุณเกี่ยวกับการตั้งค่านี้

ฉันยังไม่ได้ยืนยันสิ่งนี้จะได้ผล

เพิ่มลงใน~/.bashrcไฟล์ของคุณ:

ssh-add -L|grep identities > /dev/null && ssh-add /path/to/ssh/private/key

เพื่อเพิ่มคีย์ (อาจไม่มีรหัสผ่าน) และตรวจสอบให้แน่ใจว่าssh-addจะไม่พร้อมท์รหัสผ่านไม่ว่าจะเกิดอะไรขึ้นแม้ว่าจะทำงานภายใต้X :

DISPLAY= ssh-add -k /path/to/key </dev/null &>/dev/null

สถานะการออกแสดงว่าสำเร็จหรือล้มเหลว

หากคุณกำลังใช้ม้าน้ำในฐานะผู้จัดการรหัสผ่านของคุณ ... ซึ่งคุณน่าจะเป็น;

โซลูชันอื่นที่บรรลุเป้าหมายที่คุณค้นหาคือเพียงเพิ่มคีย์ ssh ไปที่ม้าน้ำเพื่อปลดล็อกอัตโนมัติเมื่อเข้าสู่ระบบ ประโยชน์หลักของการทำเช่นนี้คือคุณไม่ต้องป้อนรหัสผ่านสำหรับคีย์หลังจากลงชื่อเข้าใช้ผ่าน gdm หรืออะไรก็ตามที่คุณลงชื่อเข้าใช้ด้วยแม้ว่ารหัสจะมีรหัสผ่านก็ตาม ต้องใช้ทั้งรหัสส่วนตัวและรหัสสาธารณะ พวกเขายังต้องปฏิบัติตามแผนการตั้งชื่อสำหรับม้าน้ำ ค่าเริ่มต้นเป็นที่ยอมรับ (id_rsa สำหรับคีย์ส่วนตัวและ id_rsa.pub สำหรับกุญแจสาธารณะ ... จริงๆทุกสิ่งที่เป็นprivatekeynameและprivatekeyname.pub )

ในการเพิ่มคุณ ssh key เพื่อ seahorse สำหรับการปลดล็อกอัตโนมัติเมื่อเข้าสู่ระบบ; (บน fedora25 ฉันไม่แน่ใจว่าเส้นทางนั้นอยู่ที่ distros อื่น ๆ แม้ว่ามันจะคล้ายกันมากที่สุด)

/lib64/seahorse/seahorse-ssh-askpass /path/to/keys/here

สำหรับฉันมันเป็น

/lib64/seahorse/seahorse-ssh-askpass ~/.ssh/id_rsa

(ม้าน้ำจะถือว่ากุญแจสาธารณะในกรณีของฉันคือ id_rsa.pub โดยอัตโนมัติ)

หลังจากดำเนินการคำสั่งแล้วม้าน้ำจะปรากฏขึ้นเปิดฟิลด์รหัสผ่าน gtk เล็ก ๆ น่ารักเพื่อป้อนรหัสผ่านสำหรับคีย์ส่วนตัว หรือปล่อยว่างไว้หากคุณสร้างรหัสโดยไม่มีรหัสผ่าน

ม้าน้ำจะไม่แจ้งให้คุณทราบหากทุกอย่างโอเค คุณจะต้องพยายาม ssh เข้าไปในเครื่องเป้าหมาย จากนั้นม้าน้ำจะแจ้งให้คุณปลดล็อคกุญแจด้วยรหัสผ่านแบบกราฟิก (นี่จะเกิดขึ้นครั้งเดียวเท่านั้น) อีกครั้ง แต่มันควรจะดูแตกต่างออกไปเล็กน้อยในเวลานี้ P (นี่ก็เป็นส่วนที่ม้าน้ำทำม้าน้ำ ) และเสนอตัวเลือกเพื่อปลดล็อคคีย์เมื่อเข้าสู่ระบบคุณต้องเลือกตัวเลือกนี้เพื่อให้บรรลุเป้าหมายของคุณ

เพียงเพราะฉันไม่ได้อ่านคำตอบทั้งหมดฉันจะแนะนำให้เลิกทำในสิ่งที่ทุกคนบอกให้คุณทำกับ ssh-add ก่อนลองตอบคำถามนี้ การทำเช่นนั้นอาจส่งผลให้เกิดสิ่งที่ไม่ดีเกิดขึ้นกับคีย์ของคุณ idk

นี่คือสคริปต์ที่ชัดเจน

อัปเดต $ PASSW แล้วคัดลอกวางในเทอร์มินัลของคุณ

# <sshpass> via typinator
# Updated: 2017-01-18_21h36
#
# apt-get update -y; apt-get install expect -qy

# Pass this value to ssh-add
PASSW="myfancypass123"

# Define a name for this script
THIS_SCRIPT="$(date +%Y-%m-%d_%H-%M-%S-%N)".sh

# Create a fresh directory to work from / Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la


# Output our bash script file - BEGIN
cat <<< '
#!/bin/bash

set -u     # Stop if an unbound variable is referenced
set -e     # Stop on first error
export HISTIGNORE="expect*";

# Normal CMDs
echo && echo "The process should take about 10 seconds:" && echo
eval "$(ssh-agent -s)"; sleep 0.5;

# Define VAR passed when this bash-script was launched
password="$@"

# Launch the expect magic
expect -c "
    spawn ssh-add /root/.ssh/id_rsa
    expect "?assword:"
    send \"$password\r\"
    expect "?password:"
    send \"$password\r\"
    expect eof"

export HISTIGNORE="";
export password="";
' > $THIS_SCRIPT
# Output our bash script file - END


# Ensure we are in the right path
cd ~/temp; ls -la; sleep 1;

# Run the bash script
chmod +x ./$THIS_SCRIPT; ./$THIS_SCRIPT "$PASSW"; unset password;

# Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la

วิธีที่ดีที่สุดที่ฉันทราบคือใช้สคริปต์เข้าสู่ระบบ PAM ที่ฉันดัดแปลงมาจากงานก่อนหน้านี้เพราะฉันไม่พบคำตอบที่น่าพอใจในคำถามนี้

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

https://github.com/capocasa/systemd-user-pam-ssh

ข้อได้เปรียบเหนือโซลูชันอื่น ๆ ที่นำเสนอคือการรวมความปลอดภัยเทียบเท่ากับการรัน ssh-add ด้วยตนเองเมื่อบู๊ตโดยไม่ต้องใช้ความพยายาม มันไม่จำเป็นต้องมีเครื่องมือพิเศษและมีการพึ่งพาพิเศษหนึ่งครั้งที่ติดตั้งไว้แล้วตามค่าเริ่มต้นในระบบส่วนใหญ่ (OpenSSL)

การตั้งค่าของฉันบน macOS มีดังต่อไปนี้ (ใน.zshrcหรือ.bash_profileสำหรับ bash folks):

# Kill then Load the ssh-agent and set the necessary env variables it outputs
sshRestart() {
    # if all else fails
    # pkill -u $(whoami) ssh-agent;

    if [ -n "$SSH_AUTH_SOCK" ] ; then
        eval `/usr/bin/ssh-agent -k`
    fi
    eval `ssh-agent -s`
    ssh-add ~/.ssh/YOUR_KEY_FILE
    echo "Restarted SSH agent"
}

if [ -z "$SSH_AUTH_SOCK" ] || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]] ; then
    eval `ssh-agent -s` > /dev/null 2>&1
    ssh-add ~/.ssh/YOUR_KEY_FILE > /dev/null 2>&1
fi

|| [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]]ส่วนหนึ่งเป็นสิ่งที่จำเป็นใน MacOS /private/tmp/com.apple.launchd.SOMETHINGHERE/Listenersเนื่องจากค่าเริ่มต้นคือ มิฉะนั้น @Thomas Nyman คำตอบที่ครอบคลุมล้มเหลวเพราะ$SSH_AUTH_SOCKถูกตั้งค่าเป็นบางสิ่งเสมอ

จากนั้นใน.zlogout(หรือ.bash_logoutสำหรับคนทุบตี):

if [ -n "$SSH_AUTH_SOCK" ] ; then
    eval `/usr/bin/ssh-agent -k`
fi

ทดสอบบน macOS Mojave 10.14.5