วิธีรักษาความปลอดภัยการเชื่อมต่อ SSH บนเซิร์ฟเวอร์ Linux ข้อ จำกัด การเข้าถึง IP

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

ไฟล์การกำหนดค่า

• /etc/ssh/sshd_config.php- ไฟล์กำหนดค่าเซิร์ฟเวอร์ OpenSSH;
• /etc/ssh/ssh_config.php- ไฟล์การกำหนดค่าไคลเอนต์ OpenSSH;
• ~/.ssh/- ไดเร็กทอรีที่เก็บการตั้งค่า SSH ของผู้ใช้
• ~/.ssh/authorized_keys หรือ ~/.ssh/authorized_keys- รายการคีย์ (RSA หรือ DSA) ที่ใช้เชื่อมต่อกับบัญชีผู้ใช้
• /etc/nologin- หากไฟล์นี้มีอยู่ในระบบ sshd จะห้ามผู้ใช้ทั้งหมดยกเว้นรูทไม่ให้เชื่อมต่อกับระบบ
• /etc/hosts.allow และ /etc/hosts.deny- ระบบห้าม (ส่วนหนึ่งของการรักษาความปลอดภัย) ทำงานคล้ายกับ ACL;
• พอร์ต SSH เริ่มต้น - 22

ไม่จำเป็น - ปิดมัน

หากเซิร์ฟเวอร์ของคุณไม่ต้องการการเชื่อมต่อ SSH ระยะไกล อย่าลืมปิดการใช้งานแล้ว ในระบบเช่น CentOS/RHEL จะทำดังนี้:

Chkconfig sshd ปิด yum ลบ openssh-server

ใช้ SSH เวอร์ชัน 2

โปรโตคอล SSH เวอร์ชันแรกมีปัญหาด้านความปลอดภัยซึ่งได้รับการแก้ไขในเวอร์ชันที่สอง ดังนั้นให้ใช้เวอร์ชันที่สอง ตรวจสอบให้แน่ใจว่าได้ระบุตัวเลือก Protocol 2 ในไฟล์ /etc/ssh/sshd_config

จำกัดการเข้าถึง SSH

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

AllowUsers รูทเครือข่าย Merion

ในทางกลับกัน คุณสามารถอนุญาตให้ผู้ใช้ทุกคนเข้าถึงได้ ยกเว้นที่ระบุไว้:

ปฏิเสธผู้ใช้เครือข่าย Merion รูท

เวลาไม่มีการใช้งาน

สิ่งสำคัญคือต้องระบุเวลาที่เซสชั่นที่ไม่ได้ใช้งานจะสิ้นสุดลง (เสร็จสิ้น) ซึ่งสามารถทำได้ด้วยตัวเลือกต่อไปนี้:

ClientAliveInterval 300 ClientAliveCountMax 0

ในการตั้งค่านี้ เราระบุเวลาที่ไม่มีการใช้งานเป็น 300 วินาที (5 นาที)

เกี่ยวกับไฟล์ .rhosts

ความจริงก็คือไฟล์นี้มีรายชื่อโฮสต์และผู้ใช้ ถ้าเข้า. ไฟล์นี้ประกอบด้วยโฮสต์และผู้ใช้รวมกันแล้ว ผู้ใช้รายนี้จะสามารถเชื่อมต่อระบบผ่าน SSH ได้โดยไม่ต้องขอรหัสผ่าน เราขอแนะนำให้ปิดการใช้งานคุณสมบัติ "มหัศจรรย์" นี้:

ไม่สนใจRhosts ใช่

ไม่มีการรับรองความถูกต้องตามโฮสต์!

ที่เรียกว่า การรับรองความถูกต้องตามโฮสต์อนุญาตให้ผู้ใช้จากโฮสต์เฉพาะเชื่อมต่อกับเซิร์ฟเวอร์ ปิดการใช้งาน:

หมายเลขการตรวจสอบความถูกต้องตามโฮสต์

การเชื่อมต่อโดยตรงผ่านรูท

หมายเลข PermitRootLogin

ทำแบนเนอร์

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

พอร์ต 22 จากภายในเท่านั้น!

เข้าถึงพอร์ตระบบ 22 ผ่านกฎลูกโซ่ของไฟร์วอลล์เท่านั้น วิธีที่ดีที่สุดคือปล่อยให้เข้าถึงได้จากภายใน LAN เท่านั้น ตัวอย่างเช่นใน ไอพีเทเบิลคุณสามารถให้สิทธิ์เข้าถึง 192.168.11.0/24:

RH-Firewall-1-INPUT -s 192.168.11.0/24 -m state --state ใหม่ -p tcp --dport 22 -j ยอมรับ

ฟังได้ที่ไหน.

ตามค่าเริ่มต้น SSH จะรับฟังการเชื่อมต่อบนอินเทอร์เฟซที่มีอยู่ทั้งหมด เราขอแนะนำให้เปลี่ยนพอร์ตเริ่มต้นและระบุที่อยู่ IP ที่จะรอการเชื่อมต่อ เช่น เราจะระบุพอร์ต 962 และที่อยู่ IP 192.168.11.24

พอร์ต 962 ListenAddress 192.168.11.24

รหัสผ่านที่รัดกุมแบบเข้ารหัส

ใช้รหัสผ่านที่รัดกุม มีเครื่องมือมากมายบนอินเทอร์เน็ตที่จะสร้างรหัสผ่านที่รัดกุมแบบออนไลน์ ไม่มีค่าใช้จ่ายและไม่มี SMS :)

ห้ามรหัสผ่านที่ว่างเปล่า

มีผู้ใช้ที่ไม่มีรหัสผ่าน การเข้าถึง SSH จะต้องถูกปฏิเสธโดยใช้ตัวเลือก:

พอร์ต 962 PermitEmptyPasswords no

วิเคราะห์บันทึก

ตั้งค่าการบันทึกเหตุการณ์เป็นโหมด INFO หรือ DEBUG ซึ่งจะช่วยให้คุณขยายการควบคุมระบบได้:

ข้อมูลระดับบันทึก

บทความนี้มีประโยชน์กับคุณหรือไม่?

โปรดบอกฉันว่าทำไม?

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

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

การวิเคราะห์ไฟล์บันทึกการตรวจสอบสิทธิ์ /var/log/auth.log หรือแอนะล็อกแสดงให้เห็นว่าความพยายามที่จะเดารหัสผ่านมักจะทำจาก IP หลายรายการในคราวเดียว และขยายออกไปเมื่อเวลาผ่านไป

การป้องกัน SSH Bruteforce

คุณสามารถป้องกันตัวเองจากสิ่งนี้ได้หลายวิธี:

• การใช้ตัวเลือกการกำหนดค่า SSH daemon
• ตัวกรองแพ็คเก็ต
• การใช้งานพิเศษ
• เคาะพอร์ต

ที่ง่ายที่สุดและ วิธีที่มีประสิทธิภาพ- นี่คือการเปลี่ยนพอร์ตเริ่มต้น 22 เช่นเป็น 2002 หากไม่รบกวนงานอื่น เราสร้างรายการใน /etc/ssh/sshd_config:

หลังจากนั้น ความพยายามที่จะเดารหัสผ่านจะหยุดลงในทางปฏิบัติ มีบางครั้งที่คุณไม่สามารถเปลี่ยนพอร์ตได้ หรือคุณสามารถจำกัดการเข้าถึง SSH ให้กับผู้ใช้บางราย (โดยเฉพาะรูท) หรือกลุ่มได้ ใน sshd_config พารามิเตอร์จำนวนหนึ่งมีหน้าที่รับผิดชอบสิ่งนี้: AllowUsers, AllowGroups, DenyUsers และ DenyGroups สะดวกที่คุณสามารถระบุ IP หรือซับเน็ตด้วยการเข้าสู่ระบบของคุณ ตัวอย่างเช่น อนุญาตให้เข้าถึงผู้ใช้ ผู้ดูแลระบบ และผู้ใช้ ซึ่งคนหลังจาก IP เดียวเท่านั้น:

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

# อนุญาตให้ทุกคนเข้าถึงโดยใช้รหัสผ่าน
การตรวจสอบรหัสผ่านใช่
# root จะใช้เฉพาะใบรับรองเท่านั้น
จับคู่รูทผู้ใช้
รหัสผ่านการตรวจสอบเลขที่
KbdInteractiveAuthentication หมายเลข

เมื่อใช้ TCP Wrapper เรายังจำกัดการเข้าถึงบริการใดๆ จาก IP บางตัวเท่านั้น ในการดำเนินการนี้ คุณเพียงแค่ต้องเขียนกฎที่จำเป็นในไฟล์ /etc/hosts.allow หรือ /etc/hosts.deny อนุญาตให้เข้าถึงใน /etc/hosts.allow จากซับเน็ตที่ต้องการเท่านั้น:

sshd:192.168.1.0/24:อนุญาต

หรือใน /etc/hosts.deny:

sshd: ทั้งหมด: ปฏิเสธ
sshd: ทั้งหมดยกเว้น 192.168.1.0/24: อนุญาต

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

iptables -A อินพุต -s !192.168.0.1 -p tcp -m tcp --dport 22 ↵
-j ปฏิเสธ - ปฏิเสธด้วย icmp-port-unreachable

การกรองแพ็กเก็ตตามพอร์ตและที่อยู่ IP จะไม่มีประสิทธิภาพมากนักหากผู้ดูแลระบบไม่ได้เชื่อมโยงกับที่ทำงาน ในกรณีนี้พวกเขาจะช่วย สาธารณูปโภคพิเศษ: Fail2ban, Sshguard Fail2ban เดิมได้รับการพัฒนาเพื่อความปลอดภัย SSH แม้ว่าในปัจจุบันนี้จะเป็นเฟรมเวิร์กที่สามารถปรับแต่งได้อย่างง่ายดายสำหรับแอปพลิเคชันใดๆ ก็ตาม หลักการทำงานนั้นง่ายมาก ดีมอนจะตรวจสอบบันทึกของกิจกรรมที่น่าสงสัยเป็นระยะๆ ที่อยู่ IP ที่น่าสงสัยจะถูกบล็อกโดยใช้ iptables หรือ TCP Wrapper หลังจากเวลาที่ระบุไว้ในการตั้งค่า การบล็อกมักจะถูกลบออก เพื่อไม่ให้บล็อกโหนดที่ถูกต้องโดยไม่ตั้งใจ เมื่อกฎถูกทริกเกอร์ เหตุการณ์จะถูกเขียนลงในบันทึก /var/log/fail2ban.log และสามารถส่งอีเมลได้

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

บน Ubuntu และ Debian จะถูกติดตั้งด้วยคำสั่ง:

$ sudo apt-get ติดตั้ง failed2ban

การตั้งค่าทั้งหมดทำในหลายไฟล์ที่อยู่ในไดเร็กทอรี /etc/fail2ban failed2ban.conf เก็บพารามิเตอร์การเปิดตัวของ daemon เอง Jail.conf อธิบายบริการที่ได้รับการควบคุม (ภายในส่วน SSH)

เปิดใช้งาน = จริง
พอร์ต = 22
ตัวกรอง = sshd
logpath = /var/log/auth.log
แม็กซ์รีทรีท = 3

ตัวกรองและการดำเนินการถูกเขียนในไฟล์ที่อยู่ในไดเร็กทอรีย่อย filter.d และ action.d ตามค่าเริ่มต้น ไฟล์ทั้งหมดจะมีนามสกุล .conf ไม่ควรแตะต้องไฟล์เหล่านั้น (รวมถึง Jail.conf ด้วย) การเปลี่ยนแปลงทั้งหมดควรทำกับไฟล์ที่มีนามสกุล .local (เช่น Jail.local) ซึ่งเป็นพารามิเตอร์ที่จะแทนที่การตั้งค่าจากอันแรก และจะไม่สูญหายระหว่างการอัพเดต หากต้องการตรวจสอบการทำงานของตัวกรอง คุณสามารถใช้ยูทิลิตี failed2ban-regex

กฎหลายข้อในการปกป้องการเข้าถึงเซิร์ฟเวอร์ ssh

1. เพิ่มการกำหนดค่าเซิร์ฟเวอร์ ssh เพื่อฟังพอร์ตอีกหนึ่งพอร์ต นอกเหนือจากพอร์ตมาตรฐาน (เพื่อความสะดวกในการจดจำ คุณสามารถใช้ตัวเลขซ้ำ 4 ตัวสำหรับเซิร์ฟเวอร์ทั้งหมดของคุณ)

2. เราจำกัดการโทรไปที่พอร์ต 22 เฉพาะที่อยู่ IP ที่เชื่อถือได้เท่านั้น *เช่น 8.8.8.8 (คุณสามารถสร้างกฎดังกล่าวได้หลายข้อ ที่ทำงาน/ที่บ้าน)

3. อย่าลืมตรวจสอบว่าเราใช้ ipv6 หรือไม่ หากเป็นเช่นนั้นให้ปิดอันที่ไม่จำเป็น

หากต้องการใช้ ssh เฉพาะกับที่อยู่ที่ระบุ ก็เพียงพอแล้วในไฟล์การกำหนดค่า sshd_configระบุพารามิเตอร์ ListenAddress(เช่น ListenAddress 74.125.200.100) ในกรณีนี้ ssh จะใช้ได้เฉพาะกับที่อยู่นี้และจะไม่ทำงานผ่าน ipv6

4. ใช้ไฟล์การกำหนดค่า ssh บนฝั่งไคลเอ็นต์

ที่ตั้ง: ~/.ssh/config

# แก้ไขการเขียนล้มเหลว: ไปป์ที่ใช้งานไม่ได้ ServerAliveInterval 120 TCPKeepAlive no # เพื่อใช้ชื่อย่อ Host dev-vps # ที่อยู่ ip หรือสาธารณะ ชื่อโดเมนโฮสต์ ชื่อโฮสต์ 127.0.0.3 # ภายใต้ผู้ใช้ที่จะเข้าสู่ระบบ ผู้พัฒนาผู้ใช้ # ไฟล์คีย์สำหรับการอนุญาต (ถ้าใช้) IdentityFile ~/.ssh/id_rsa.dev

และอีกตัวอย่างหนึ่งของการใช้ไฟล์กำหนดค่า:
{<1>}

โฮสต์ ssh-server-1 ชื่อโฮสต์ 1.2.3.4 ผู้ใช้ dev พอร์ต 1234 โฮสต์ ssh-server-2 ผู้ใช้ root # ชื่อโฮสต์ 192.168.10.20 # nc โดยไม่มี -q0 ถ้าใช้ RHEL & ด้วย -q0 debian ที่ใช้ IdentityFile ~/.ssh/id_rsa.work -pc ProxyCommand ssh -q0 ssh-เซิร์ฟเวอร์-1 nc -q0 192.168.10.20 22

และตอนนี้เมื่อเชื่อมต่อกับ ssh-server-1 เราจะข้ามไปยังโฮสต์ที่เราต้องการทันที (สะดวกในการใช้งาน เช่น มีคีย์ต่างกันบนเซิร์ฟเวอร์)

และยัง ฮิปสเตอร์ตัวเลือกพร็อกซี:

{<2>}

ดาวน์โหลดไคลเอนต์ ngrok ไปยังเซิร์ฟเวอร์ซึ่งอยู่ด้านหลังไฟร์วอลล์ เราเปิดตัวไบนารี่และระบุพอร์ตที่เราต้องส่งต่อ

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

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

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

คู่มือนี้จะช่วยคุณในการติดตั้งและกำหนดค่า failed2ban บนเซิร์ฟเวอร์ Ubuntu 14.04

การติดตั้ง Fail2ban

พื้นที่เก็บข้อมูล Ubuntu มีแพ็คเกจ failed2ban ดังนั้นจึงสามารถติดตั้งได้โดยใช้ตัวจัดการแพ็คเกจมาตรฐาน

อัพเดตดัชนีแพ็กเกจของคุณและติดตั้ง Fail2ban โดยใช้คำสั่งเหล่านี้:

อัปเดต sudo apt-get
sudo apt-get ติดตั้ง failed2ban

ตอนนี้คุณสามารถเริ่มตั้งค่ายูทิลิตี้ได้แล้ว

การกำหนดค่าที่ล้มเหลว 2ban

ไฟล์คอนฟิกูเรชัน Fail2ban จะถูกจัดเก็บไว้ในไดเร็กทอรี /etc/fail2ban การตั้งค่าเริ่มต้นสามารถพบได้ในไฟล์ Jail.conf

เนื่องจากไฟล์นี้สามารถเปลี่ยนแปลงได้ในระหว่างการอัพเดตแพ็คเกจ จึงไม่จำเป็นต้องแก้ไข เป็นการดีกว่าที่จะคัดลอกเนื้อหาไปยังไฟล์อื่นและปรับพารามิเตอร์ที่นั่น เพื่อให้แน่ใจว่าทั้งสองไฟล์ทำงานได้อย่างถูกต้อง วิธีที่ดีที่สุดคือทิ้งเฉพาะการตั้งค่าเหล่านั้นไว้ในไฟล์ใหม่ที่คุณต้องการแทนที่ในไฟล์ Jail.local การตั้งค่าเริ่มต้นทั้งหมดจะถูกอ่านจากไฟล์ Jail.conf

คัดลอก Jail.conf และใช้เป็นพื้นฐานสำหรับไฟล์ Jail.local เมื่อต้องการทำเช่นนี้ ให้ป้อน:

awk "( printf "# "; พิมพ์; )" /etc/fail2ban/jail.conf | sudo tee /etc/fail2ban/jail.local

หลังจากนั้นลองดูที่ Jail.conf:

sudo นาโน /etc/fail2ban/jail.conf

คุณสามารถอัปเดตพารามิเตอร์บางตัวในไฟล์นี้ได้ การตั้งค่าพาร์ติชันจะนำไปใช้กับบริการทั้งหมดที่ Fail2ban รองรับ (เว้นแต่ว่าค่าเหล่านี้จะถูกแทนที่) ไฟล์การกำหนดค่าบริการเหล่านี้)

. . .
เพิกเฉย = 127.0.0.1/8
. . .

พารามิเตอร์ละเลยจะกำหนดค่าที่อยู่ต้นทางที่ failed2ban จะเพิกเฉย ตามค่าเริ่มต้น จะอนุญาตการรับส่งข้อมูลใดๆ ที่มาจากเครื่องภายในเครื่อง คุณสามารถเพิ่มที่อยู่อื่นๆ ที่จะละเว้นได้โดยวางไว้ที่ส่วนท้ายของคำสั่งละเว้น โดยคั่นด้วยช่องว่าง

. . .
แบนไทม์ = 600
. . .

พารามิเตอร์ bantime จะกำหนดเวลาในระหว่างที่ไคลเอนต์จะถูกแบนหากไม่ผ่านการรับรองความถูกต้อง ค่าของมันถูกวัดเป็นวินาที ค่าเริ่มต้นคือ 600 วินาที (10 นาที)

. . .
เวลาค้นหา = 600
แม็กซ์รีทรีท = 3
. . .

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

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

. . .
destemail = root@localhost
ชื่อผู้ส่ง = Fail2Ban
mta = ส่งเมล์
. . .

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

. . .
การกระทำ = $(การกระทำ_)s
. . .

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

หากคุณต้องการกำหนดค่าการแจ้งเตือนทางอีเมล ให้เพิ่มหรือยกเลิกการใส่หมายเหตุองค์ประกอบการดำเนินการลงในไฟล์ Jail.local และเปลี่ยนค่าจาก action_ เป็น action_mw หากคุณต้องการให้อีเมลรวมบรรทัดที่เกี่ยวข้องจากบันทึก คุณสามารถระบุค่า action_mwl ได้ หากคุณตัดสินใจที่จะใช้การแจ้งเตือนทางอีเมล ตรวจสอบให้แน่ใจว่าการตั้งค่าอีเมลของคุณรองรับ

พารามิเตอร์ส่วนบุคคล

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

แต่ละส่วนเหล่านี้สามารถเปิดใช้งานได้โดยยกเลิกการใส่เครื่องหมายความคิดเห็นส่วนหัวของส่วนใน Jail.local และเปลี่ยนบรรทัดที่เปิดใช้งานเป็น "จริง":

. . .
เปิดใช้งาน = จริง
. . .

ตามค่าเริ่มต้น รองรับเฉพาะบริการ SSH และบริการอื่นๆ ทั้งหมดจะถูกปิดใช้งาน

ส่วนเหล่านี้ใช้ค่าที่ตั้งไว้ในส่วนนั้นเป็นพื้นฐานและปรับเปลี่ยนตามความจำเป็น หากต้องการแทนที่ค่าใด ๆ ให้เพิ่มส่วนสำหรับบริการที่เหมาะสมใน Jail.local และเปลี่ยนค่า

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

ค่าของพารามิเตอร์ filter คือลิงก์ไปยังไฟล์ที่มีนามสกุล .conf อยู่ในไดเร็กทอรี /etc/fail2ban/filter.d ไฟล์เหล่านี้ประกอบด้วย การแสดงออกปกติซึ่งกำหนดว่าบรรทัดในบันทึกเป็นข้อความเกี่ยวกับความพยายามตรวจสอบสิทธิ์ที่ล้มเหลว ไฟล์เหล่านี้อยู่นอกเหนือขอบเขตของบทช่วยสอนนี้ เนื่องจากไฟล์เหล่านี้ค่อนข้างซับซ้อนและการตั้งค่าเริ่มต้นก็ใช้ได้ในกรณีส่วนใหญ่

คุณสามารถดูตัวกรองในไดเร็กทอรีนี้:

ls /etc/fail2ban/filter.d

ค้นหาไฟล์ที่เกี่ยวข้องกับบริการที่ต้องการแล้วเปิดด้วย โปรแกรมแก้ไขข้อความ- ไฟล์ส่วนใหญ่ได้รับการแสดงความคิดเห็นค่อนข้างดี และคุณสามารถทำความคุ้นเคยกับสคริปต์การป้องกันบริการได้ ตัวกรองเหล่านี้ส่วนใหญ่มีส่วนที่เกี่ยวข้องในไฟล์ Jail.conf (โดยค่าเริ่มต้นจะถูกปิดใช้งาน) สามารถเปิดใช้งานได้ในไฟล์ Jail.local หากจำเป็น

สมมติว่าคุณมีเว็บไซต์ที่ให้บริการโดยใช้ Nginx บันทึกของเว็บเซิร์ฟเวอร์ได้รับการอัปเดตอย่างต่อเนื่องโดยพยายามเข้าสู่ระบบไม่สำเร็จ ยูทิลิตี failed2ban สามารถใช้ไฟล์ nginx-http-auth.conf เพื่อตรวจสอบ /var/log/nginx/error.log อย่างต่อเนื่อง

พารามิเตอร์เกือบทั้งหมดที่จำเป็นสำหรับสิ่งนี้มีอยู่แล้วในส่วนในไฟล์ /etc/fail2ban/jail.conf คุณเพียงแค่ต้องยกเลิกหมายเหตุส่วนนี้ในไฟล์ Jail.local และตั้งค่าพารามิเตอร์ที่เปิดใช้งานเป็นจริง

. . .
เปิดใช้งาน = จริง
. . .

หลังจากนี้คุณจะต้องรีสตาร์ท Fail2ban

การตั้งค่า Fail2ban

ตอนนี้คุณรู้พื้นฐานการทำงานของ Fail2ban แล้ว ลองตั้งค่านโยบายการบล็อกอัตโนมัติสำหรับบริการ SSH และ Nginx คุณต้องใช้เครื่องมือ Fail2ban เพื่อส่งอีเมลหากที่อยู่ IP ถูกบล็อก

ในการเริ่มต้น ให้ติดตั้งซอฟต์แวร์ที่จำเป็น

คุณจะต้องมี nginx เนื่องจาก failed2ban จะตรวจสอบบันทึกของมัน และ sendmail เพื่อส่งการแจ้งเตือน คุณต้องมีแพ็คเกจ iptables-persistent เพื่อให้เซิร์ฟเวอร์บันทึกและโหลดกฎไฟร์วอลล์โดยอัตโนมัติเมื่อเซิร์ฟเวอร์บูท แพ็คเกจทั้งหมดนี้สามารถดาวน์โหลดได้จากที่เก็บ Ubuntu มาตรฐาน:

อัปเดต sudo apt-get
sudo apt-get ติดตั้ง nginx sendmail iptables-persistent

หยุดบริการ Fail2ban เพื่อตั้งค่าไฟร์วอลล์พื้นฐาน

การตั้งค่าไฟร์วอลล์

ไฟร์วอลล์พื้นฐานต้องรองรับ การเชื่อมต่อที่จัดตั้งขึ้นตลอดจนการรับส่งข้อมูลที่สร้างโดยเซิร์ฟเวอร์เองและการรับส่งข้อมูลที่กำหนดสำหรับพอร์ต SSH และเว็บเซิร์ฟเวอร์ การรับส่งข้อมูลอื่นๆ ทั้งหมดจะถูกบล็อก กฎมีลักษณะดังนี้:

sudo iptables -A INPUT -i lo -j ยอมรับ
sudo iptables -A INPUT -m conntrack --ctstate ก่อตั้งขึ้นที่เกี่ยวข้อง -j ยอมรับ
sudo iptables -A INPUT -p tcp --dport 22 -j ยอมรับ
sudo iptables -A INPUT -p tcp -m multiport --dports 80,443 -j ยอมรับ
sudo iptables -A อินพุต -j DROP

คำสั่งเหล่านี้ใช้นโยบายข้างต้น หากต้องการดูกฎไฟร์วอลล์ปัจจุบันของคุณ ให้พิมพ์:

sudo iptables -S
-P ยอมรับอินพุต
-P ยอมรับไปข้างหน้า
-P เอาท์พุทยอมรับ
-A อินพุต -i lo -j ยอมรับ




-A อินพุต -j ลดลง

บันทึกกฎไฟร์วอลล์ของคุณเพื่อไม่ให้กฎหายไปหลังจากรีบูต

sudo dpkg- กำหนดค่า iptables ใหม่ - ถาวร

รีสตาร์ท Fail2ban:

บริการ sudo ล้มเหลว 2ban เริ่มต้น

กฎไฟร์วอลล์แบบสอบถาม:

sudo iptables -S
-P ยอมรับอินพุต
-P ยอมรับไปข้างหน้า
-P เอาท์พุทยอมรับ
-N failed2ban-ssh

-A อินพุต -i lo -j ยอมรับ
-A INPUT -m conntrack --ctstate ที่เกี่ยวข้อง ก่อตั้งแล้ว -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 22 -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 80 -j ยอมรับ
-A อินพุต -j ลดลง
-A failed2ban-ssh -j ผลตอบแทน

ตอนนี้แต่ละเครือข่ายมีนโยบายเริ่มต้นของตัวเอง นอกจากนี้ยังมีกฎพื้นฐานห้าข้อในไฟร์วอลล์ โครงสร้าง Fail2ban จะถูกเน้นด้วยสีแดง: เครื่องมือนี้บังคับใช้กฎการแบน SSH อยู่แล้ว บางครั้งโครงสร้างนี้ไม่แสดงในตอนแรก เนื่องจาก failed2ban อาจไม่เพิ่มโครงสร้างจนกว่าจะมีการแบนครั้งแรก

การตั้งค่า Fail2ban

ตอนนี้คุณต้องเพิ่มการตั้งค่า failed2ban ให้กับไฟล์ Jail.local:

sudo นาโน /etc/fail2ban/jail.local

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

. . .
แบนไทม์ = 1800
. . .

คุณต้องตั้งค่าการแจ้งเตือนด้วย ขั้นแรก ค้นหาพารามิเตอร์ destemail ซึ่งควรอยู่ในส่วนนี้ด้วย ป้อนที่อยู่อีเมลที่คุณต้องการใช้เพื่อรวบรวมข้อความเหล่านี้:

. . .
ทำลายเมล= [ป้องกันอีเมล]
. . .

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

จากนั้นคุณจะต้องแก้ไขคุณค่าของการกระทำ คุณสามารถตั้งค่า action_mw ให้บล็อกไคลเอนต์แล้วส่งรายงาน "whois" ค่า action_mwl จะทำสิ่งเดียวกัน แต่ยังส่งบรรทัดบันทึกที่เกี่ยวข้องในข้อความด้วย

. . .
การกระทำ = %(action_mwl)s
. . .

ในส่วน SSH ของคำสั่ง maxretry คุณสามารถเปลี่ยนจำนวนครั้งในการพยายามตรวจสอบสิทธิ์ที่ล้มเหลวได้ หากคุณกำลังใช้ พอร์ตที่ไม่ได้มาตรฐาน(ไม่ใช่ 22) ให้ระบุในพารามิเตอร์พอร์ต ตามที่ระบุไว้ก่อนหน้านี้ เซิร์ฟเวอร์นี้เปิดใช้งานอยู่แล้ว

จากนั้นค้นหาส่วน nginx-http-auth ยกเลิกหมายเหตุส่วนหัวและเปลี่ยนพารามิเตอร์ที่เปิดใช้งานเป็น "จริง"

. . .

เปิดใช้งาน = จริง
. . .

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

รีสตาร์ท Fail2ban

บันทึกและปิดไฟล์

จากนั้นรีสตาร์ทบริการ Fail2ban บางครั้งการหยุดแล้วเริ่มต้นใหม่อีกครั้งก็ยังดีกว่า

บริการ sudo failed2ban หยุด
บริการ sudo ล้มเหลว 2ban เริ่มต้น

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

sudo iptables -S
-P ยอมรับอินพุต
-P ยอมรับไปข้างหน้า
-P เอาท์พุทยอมรับ
-N failed2ban-nginx-http-auth

-N failed2ban-ssh

-A อินพุต -p tcp -m มัลติพอร์ต --dports 80,443 -j failed2ban-nginx-http-auth

-A อินพุต -p tcp -m มัลติพอร์ต --dports 22 -j failed2ban-ssh
-A อินพุต -i lo -j ยอมรับ
-A INPUT -m conntrack --ctstate ที่เกี่ยวข้อง ก่อตั้งแล้ว -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 22 -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 80 -j ยอมรับ
-A อินพุต -j ลดลง
-A failed2ban-nginx-http-auth -j ส่งคืน

-A failed2ban-ssh -j ผลตอบแทน

บรรทัดที่สร้างโดยนโยบาย Fail2ban จะถูกเน้นด้วยสีแดง ในตอนนี้ พวกเขาเพียงแค่กำหนดเส้นทางการรับส่งข้อมูลไปยังเครือข่ายใหม่ ซึ่งส่วนใหญ่เป็นเครือข่ายว่าง จากนั้นจึงส่งต่อการไหลของการรับส่งข้อมูลกลับไปยังห่วงโซ่ INPUT

กฎการบล็อกจะถูกเพิ่มในเชนเหล่านี้

การทดสอบนโยบายการบล็อก

ตอนนี้คุณสามารถทดสอบกฎได้โดยการเชื่อมต่อจากเซิร์ฟเวอร์อื่นที่ไม่มีข้อมูลรับรองบนเซิร์ฟเวอร์ Fail2ban

ลองสร้างการเชื่อมต่อ SSH ไปยังเซิร์ฟเวอร์โดยใช้ข้อมูลรับรองที่ไม่มีอยู่จริง:

ssh blah@fail2ban_server_IP

ป้อนชุดอักขระแบบสุ่มเป็นรหัสผ่านของคุณ ทำซ้ำหลายครั้ง เมื่อถึงจุดหนึ่ง failed2ban จะปฏิเสธการเข้าถึงและแสดงข้อความ “Permission ถูกปฏิเสธ”

กลับไปที่เซิร์ฟเวอร์เครื่องแรกและดูกฎ iptables ใหม่:

sudo iptables -S
-P ยอมรับอินพุต
-P ยอมรับไปข้างหน้า
-P เอาท์พุทยอมรับ
-N failed2ban-nginx-http-auth
-N failed2ban-ssh
-A อินพุต -p tcp -m มัลติพอร์ต --dports 80,443 -j failed2ban-nginx-http-auth
-A อินพุต -p tcp -m มัลติพอร์ต --dports 22 -j failed2ban-ssh
-A อินพุต -i lo -j ยอมรับ
-A INPUT -m conntrack --ctstate ที่เกี่ยวข้อง ก่อตั้งแล้ว -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 22 -j ยอมรับ
-A อินพุต -p tcp -m tcp --dport 80 -j ยอมรับ
-A อินพุต -j ลดลง
-A failed2ban-nginx-http-auth -j ส่งคืน
-A failed2ban-ssh -s 203.0.113.14/32 -j ปฏิเสธ --ปฏิเสธด้วย icmp-port-ไม่สามารถเข้าถึงได้
-A failed2ban-ssh -j กลับมา

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

บทสรุป

ตอนนี้คุณคุ้นเคยกับพื้นฐานของ Fail2ban แล้ว และสามารถสร้างการกำหนดค่าพื้นฐานสำหรับเครื่องมือนี้ได้

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

คุณสมบัติหลักของการโจมตีแบบ SSH bruteforce ขนาดใหญ่คือการสแกนช่วง IP อย่างครอบคลุม เปิดพอร์ต 22 และใช้เป็นชื่อผู้ใช้และรหัสผ่านที่ใช้บ่อย (เช่น root:passwd123, admin:server123 เป็นต้น)

หากต้องการดูสถิติจากไฟล์บันทึกของการพยายามอนุญาต SSH ที่ไม่สำเร็จบนเซิร์ฟเวอร์ของคุณ ให้ป้อนคำสั่ง:

Cat /var/log/secure* | grep "รหัสผ่านล้มเหลว" | grep sshd | awk "(พิมพ์ $1,$2)" | การเรียงลำดับ -k 1,1M -k 2n | ยูนิค -ซี

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

1. ถ้าคุณ ไม่ใช้สำหรับการอนุญาตชื่อผู้ใช้ที่ใช้บ่อย เช่น รูท ผู้ดูแลระบบ ผู้ดูแลระบบ ผู้ใช้ ฯลฯ และใช้รหัสผ่านที่ซับซ้อนในการอนุญาต จากนั้นคุณสามารถไปยังจุดที่สองได้ทันที หากต้องการเปลี่ยนรหัสผ่านให้ซับซ้อนยิ่งขึ้น ให้ป้อนคำสั่ง:

รหัสผ่าน #your_login#

ที่ไหน #ของคุณ_เข้าสู่ระบบ#— ชื่อผู้ใช้ของคุณ
เมื่อป้อนรหัสผ่านใหม่ รหัสผ่านจะไม่แสดง เคอร์เซอร์จะยังคงอยู่ในที่เดียว

เข้าสู่เซิร์ฟเวอร์ผ่าน SSH สร้างผู้ใช้ใหม่และให้รหัสผ่านแก่เขาเพื่อดำเนินการนี้ให้ป้อนคำสั่ง:

Adduser #ผู้ใช้ใหม่# passwd #ผู้ใช้ใหม่#

ที่ไหน #ผู้ใช้ใหม่#— ชื่อผู้ใช้ใหม่ของคุณ อย่าใช้ชื่อผู้ใช้ที่ใช้บ่อยเป็นชื่อผู้ใช้ ซึ่งเป็นตัวเลือกที่ดี your_nameadmin(ตัวอย่างเช่น foxadmin, useralex, rootidler)

2. หลังจากนั้นเข้าสู่ระบบผ่าน SSH ด้วยชื่อผู้ใช้และรหัสผ่านใหม่ และเปิดการกำหนดค่า SSH daemon (sshd_config) ด้วยคำสั่ง:

Vi /etc/ssh/sshd_config.vi

หลังจากนั้นคุณควรเห็นสิ่งนี้:

เส้นที่ขึ้นต้นด้วย # ถูกแสดงความคิดเห็น

ถึง ปกป้อง SSH จากความดุร้ายขนาดใหญ่, ไม่แสดงข้อคิดเห็นและเปลี่ยนแปลงหรือเพิ่ม พารามิเตอร์ต่อไปนี้ ไฟล์:
ก) ท่าเรือ- ท่าเรือที่ SSHDยอมรับและเชื่อมต่อบริการ ไม่ใส่ข้อคิดเห็น (ลบก่อนเริ่มบรรทัด # ) และเปลี่ยนค่าเริ่มต้น 22 ไปยังอื่น ๆ ตั้งแต่ 1024 ถึง 65536 ยกเว้นพอร์ตที่สงวนไว้ - รายการพอร์ตที่สงวนไว้เช่น:

พอร์ต 2022

หากต้องการลบ # และเปลี่ยนค่า พอร์ต 22ให้กดบนคีย์บอร์ดของคุณก่อน ฉันหลังจากแก้ไขแล้ว บรรทัดที่ต้องการกดปุ่ม เอสซี

ข) เข้าสู่ระบบ GraceTime— ระยะเวลารอการลงทะเบียนผู้ใช้ในระบบ หากผู้ใช้ล้มเหลวในการเข้าสู่ระบบภายในเวลาที่กำหนดโดยคำสั่งนี้ เซสชันจะสิ้นสุดลง มาลดค่านี้กัน:

เข้าสู่ระบบGraceTime 1น

ค) อนุญาตการรูทเข้าสู่ระบบ- อนุญาตให้ผู้ใช้ รากเข้าสู่ระบบผ่านโปรโตคอล SSH มาเปลี่ยนเป็น เลขที่.

หมายเลข PermitRootLogin

ง) อนุญาตผู้ใช้— ชื่อผู้ใช้ที่อนุญาตให้เข้าสู่ระบบผ่านโปรโตคอล SSH โดยคั่นด้วยช่องว่าง ที่นี่ แทนที่จะเป็น #your_login# เราจะระบุชื่อผู้ใช้ที่สร้างขึ้นใหม่

อนุญาตให้ผู้ใช้ #your_login#

จ) MaxAuthTries— จำนวนความพยายามเข้าสู่ระบบต่อเซสชัน เมื่อถึงจำนวนความพยายามสูงสุดที่อนุญาต เซสชันจะสิ้นสุดลง

MaxAuth ลอง 2

เป็นผลให้เราได้รับ:

พอร์ต 2022 LoginGraceTime 1m PermitRootLogin ไม่ AllowUsers #your_login# MaxAuthTries 2

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

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

หลังจากตั้งค่า SSH เสร็จแล้ว ให้รีสตาร์ท daemon ด้วยคำสั่ง:

บริการ sshd เริ่มต้นใหม่

ตอนนี้เมื่อเชื่อมต่อผ่าน SSH ให้ใช้พอร์ตใหม่ 2022 (หรืออันที่คุณระบุไว้ในการตั้งค่า) แทน พอร์ตมาตรฐาน 22.

ในบทความถัดไปเกี่ยวกับการตั้งค่า SSH ฉันอยากจะบอกคุณว่าเราจะห้ามการตรวจสอบรหัสผ่านและอนุญาตให้มีการอนุญาตโดยใช้คีย์ SSH ส่วนตัวเท่านั้น ดังนั้นจึงปกป้องตัวเราเองจากการเดารหัสผ่านให้มากที่สุด