ฉันต้องการโอนไฟล์บางไฟล์จากเซิร์ฟเวอร์ A ไปยังเซิร์ฟเวอร์ B ทุกวัน (เพื่อวัตถุประสงค์ในการสำรองข้อมูล) อย่างไรก็ตาม ฉันไม่สามารถหาวิธีที่ไม่สร้างการละเมิดความปลอดภัยได้ เป้าหมายของฉันคือคนที่มีสิทธิ์ sudo บนเซิร์ฟเวอร์ A ไม่สามารถใช้ประโยชน์จากการถ่ายโอนนี้เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ B
แนวคิดพื้นฐานของฉันคือการทำ cronjob ด้วยไฟล์ scp (หรือคล้ายกัน) คำสั่งในนั้น เห็นได้ชัดว่า การใช้การเชื่อมต่อ SSH แบบใช้รหัสผ่านระหว่าง A และ B ไม่ทำงาน และการใช้การเชื่อมต่อ SSH แบบใช้คีย์ เท่าที่ฉันทราบจะอนุญาตให้ผู้ใช้เซิร์ฟเวอร์ A เชื่อมต่อกับ B ผ่าน A ได้โดยตรง
ฉันไม่ใช่ผู้เชี่ยวชาญด้านความปลอดภัย ฉันอาจพลาดข้อมูลที่ชัดเจนที่นี่ มีวิธีที่จะบรรลุสิ่งที่ฉันต้องการหรือไม่?
ฉันไม่ต้องการให้ผู้ใช้เซิร์ฟเวอร์ B สามารถเชื่อมต่อกับเซิร์ฟเวอร์ A ได้เช่นกัน
คุณไม่สามารถซ่อนอะไรในระบบจากผู้ที่มีสิทธิ์เข้าถึงรูทได้ แม้ว่าคุณจะใช้โฮมไดเร็กทอรีที่เข้ารหัสในขณะที่คุณเข้าสู่ระบบ มันถูกถอดรหัสและผู้ใช้รูทสามารถเข้าถึงข้อมูลได้
วิธีที่ง่ายที่สุดในการทำงานนี้ให้สำเร็จคือการตั้งค่าอินสแตนซ์ที่สามที่สามารถเข้าสู่ระบบผ่าน SSH ทั้งเซิร์ฟเวอร์ A และเซิร์ฟเวอร์ B จากนั้นคุณสามารถใช้ scp คำสั่ง (ในอินสแตนซ์ที่สามนั้น) เพื่อคัดลอกไฟล์จาก A ไป B ด้วยวิธีการต่อไปนี้
scp -3 serverA:/path/to/the/file serverB:/path/to/store/
เซิร์ฟเวอร์A และ เซิร์ฟเวอร์B ได้รับการกำหนดค่าใน ~/.ssh/config ในตัวอย่างที่สามหมายเหตุตัวเลือก -3มันทำให้อินสแตนซ์ที่สามทำงานเป็นเซิร์ฟเวอร์ระดับกลาง ในกรณีที่ไม่มีตัวเลือกนี้ เซิร์ฟเวอร์ A จะได้รับคำสั่งให้เชื่อมต่อกับเซิร์ฟเวอร์ B แต่จะต้องมีข้อมูลประจำตัว ตัวเลือกนี้จะปิดใช้งานเครื่องวัดความคืบหน้า
คำตอบฉบับยาวมีให้ที่ ประวัติศาสตร์.
ใช้ รีซิงค์ ใน cronjob ตามปกติ
บนไคลเอนต์ rsync ผู้ใช้ที่มีสิทธิ์ "sudo" จะสามารถเห็นชื่อผู้ใช้และรหัสผ่านที่จำเป็นในการเข้าถึง โฟลเดอร์เฉพาะที่แชร์โดยเซิร์ฟเวอร์ rsync.
แต่ข้อมูลประจำตัวเหล่านี้แยกจากข้อมูลประจำตัวของผู้ใช้ และจะไม่ให้สิทธิ์การเข้าถึง SSH กับเซิร์ฟเวอร์ ดังนั้นหากกำหนดค่าต่างๆ อย่างถูกต้อง สิ่งที่พวกเขาเข้าถึงได้ทั้งหมดบนเซิร์ฟเวอร์คือการสำรองข้อมูลจากเครื่องของตนเอง
บนเซิร์ฟเวอร์ rsync ไม่มีอะไรที่จะให้สิทธิ์การเข้าถึงแก่ไคลเอ็นต์ rsync
เพียงแค่ส่งไฟล์ ถึง serverA แทนที่จะมีผู้ใช้บน serverA คัดลอกจาก serverB ถ้าคุณต้องการคัดลอก ฟู.txt จาก เซิร์ฟเวอร์B ถึง เซิร์ฟเวอร์Aคุณสามารถทำได้สองวิธีพื้นฐาน:
เซิร์ฟเวอร์A เพื่อนำไฟล์จาก เซิร์ฟเวอร์B.เซิร์ฟเวอร์B เพื่อส่งไฟล์ไปที่ เซิร์ฟเวอร์A.ในกรณีที่สองไม่มีใครอยู่ เซิร์ฟเวอร์A ต้องการเข้าถึง เซิร์ฟเวอร์B. ดังนั้น ตั้งค่า ssh ตามคีย์จาก serverB ถึง serverA แล้วเพิ่มบรรทัด cron ของคุณให้กับผู้ใช้ที่เกี่ยวข้อง บนเซิร์ฟเวอร์ ข.
ตัวอย่างเช่น หากต้องการทำด้วยตนเอง คุณจะทำ:
user1@serverB $scp /path/to/foo.txt user1@serverA:/path/to/foo.txt
ทางนี้ไม่มีใครอยู่ เซิร์ฟเวอร์A ได้รับการเข้าถึงใด ๆ เซิร์ฟเวอร์B และคุณต้องมีผู้ใช้เท่านั้น เซิร์ฟเวอร์B ที่สามารถเข้าสู่ระบบ เซิร์ฟเวอร์A.
วิธีทั่วไปในการทำเช่นนี้คือการใช้ sftp และ chroot
บนเซิร์ฟเวอร์ B คุณต้องกำหนดค่า ssh เพื่อ chroot ผู้ใช้จากเซิร์ฟเวอร์ A และจำกัด sftp เช่น. เพิ่ม /etc/ssh/sshd_config
ระบบย่อย sftp /usr/lib/openssh/sftp-server
การสำรองข้อมูลกลุ่มแมตช์
ChrootDirectory /สำรองข้อมูล/%u
AuthorizedKeysFile %h/.ssh/authorized_keys
ForceCommand ภายใน-sftp
อนุญาตให้ Tcp ส่งต่อหมายเลข
จากนั้น คุณสร้างผู้ใช้สำหรับเซิร์ฟเวอร์ A บนเซิร์ฟเวอร์ B เช่น ผู้ใช้กพร้อมไดเร็กทอรี /backups/userA (เป็นเจ้าของโดยรูท) จากนั้นคุณจะต้องมี การสำรองข้อมูล กลุ่มซึ่ง ผู้ใช้ก ถูกเพิ่มเข้าไปใน. กฎในการกำหนดค่า ssh ใช้กับผู้ใช้ในกลุ่มนี้ และจะจำกัดผู้ใช้จาก A ไว้เฉพาะข้อมูลที่ใส่ใน 'ดรอปบ็อกซ์' ของ sftp นี้ และไม่อนุญาตให้ใช้ ssh
สำหรับการสำรองข้อมูล ฉันขอแนะนำวิธีนี้ ร่วมกับเครื่องมือเช่น duply สำหรับจัดการข้อมูลสำรองจริง เพื่อให้ข้อมูลสำรองสามารถเข้ารหัส เพิ่ม กู้คืนได้ง่าย ฯลฯ
ssh และ rsync (และ SFTP) จะให้ล็อกอินบนเซิร์ฟเวอร์ที่คุณกำลังเชื่อมต่อเสมอ ซึ่งคุณอาจควบคุมหรือไม่ก็ได้
ทำไมไม่ใช้ HTTPS?
คุณอาจจะ
เพื่อปกป้องข้อมูลจากบุคคลที่สามที่ไม่เกี่ยวข้อง คุณจะต้องเข้ารหัสการเชื่อมต่อ (ใช้ HTTPS ไม่ใช่ HTTP ธรรมดา) และ ใช้อย่างน้อย การรับรองความถูกต้องขั้นพื้นฐาน.
สิ่งนี้จะไม่ปกป้องข้อมูลจากผู้ใช้รูทในทั้งสองระบบ: ทั้งคู่อาจ อ่าน ข้อมูลและ แก้ไข ในด้านของพวกเขาและไม่มีอะไรที่คุณสามารถทำได้เกี่ยวกับเรื่องนี้
เซิร์ฟเวอร์ HTTP อย่างง่ายสามารถเริ่มต้นได้หลายวิธี เช่น:
หลาม -m SimpleHTTPServer 8080
การเข้ารหัสการเชื่อมต่อจำเป็นต้องสร้างใบรับรอง SSL และโค้ด Python สองสามบรรทัด:
#!/usr/bin/python
นำเข้า BaseHTTPServer, SimpleHTTPServer
นำเข้า ssl
httpd = BaseHTTPServer.HTTPServer(('0.0.0.0', 8443), SimpleHTTPServer.SimpleHTTPRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket, certfile='./certs_and_key.pem', server_side=True)
httpd.serve_forever()
การรับรองความถูกต้องขั้นพื้นฐานต้องการรหัสเพิ่มเติมเล็กน้อย แต่นั่น ยังสามารถ จะเสร็จแล้ว
มีปัญหากับสมมติฐานที่อยู่เบื้องหลังคำถามของคุณ SSH ได้รับการออกแบบเพื่อให้เข้าถึงระบบได้ แต่คุณต้องการใช้ SSH และไม่ให้สิทธิ์เข้าถึงระบบ บางที SSH อาจไม่ใช่เครื่องมือที่เหมาะสมสำหรับข้อกำหนดเหล่านี้
ตัวเลือกที่ 1
การถ่ายโอนไฟล์เกิดขึ้นกับเว็บไซต์ตลอดเวลาโดยที่ผู้อัปโหลดไม่สามารถเข้าถึงระบบพื้นฐานได้ สร้างหรือค้นหาเว็บแอปง่ายๆ ที่สามารถรับการอัปโหลดไฟล์และเขียนไปยังไดเร็กทอรีที่ต้องการ ต้องการความลับของแอปหรือรหัสผ่านหากจำเป็น ผู้ใช้รูททุกคนบนระบบ A จะสามารถเห็นไฟล์ที่เก็บความลับของแอพ ดังนั้นพวกเขาจะสามารถอัปโหลดไฟล์ในลักษณะเดียวกันได้ แต่ตราบใดที่เว็บแอปที่รับการอัปโหลดไม่ได้ให้สิทธิ์ในการอ่านข้อมูลใดๆ ก็ตาม ข้อกำหนดในการกันผู้ใช้รูทออกจากระบบ B นั้นเป็นไปตามข้อกำหนด
ตัวเลือก 2
คุณยังสามารถใช้ SSH เพื่อส่งไฟล์ได้ เพียงแค่จำกัดสิทธิ์ สำหรับผู้ใช้ระบบ B ที่ใช้สำหรับการถ่ายโอน SCP ให้สิทธิ์ในการเขียนไปยังไดเร็กทอรีที่ระบุและสิทธิ์ในการอ่านเท่านั้น ไม่มีที่ไหนเลยบนระบบ B คุณสามารถส่งคำสั่งถ่ายโอนไฟล์จากระบบ A เพื่อเขียนไปยังไดเร็กทอรีนั้น คุณจะไม่มีวัน สามารถอ่านได้อีกครั้ง ผู้ใช้รูทบนระบบ A จะสามารถเข้าถึงคีย์ SSH และอัปโหลดไฟล์ของตนเองไปยังที่เดียวกันได้ แต่ถ้าผู้ใช้ระบบ B ไม่มีสิทธิ์อ่านบนระบบไฟล์ สิ่งที่พวกเขาสามารถทำได้จะถูกจำกัด เทคนิคนี้อาจพูดง่ายกว่าทำ ผู้ใช้รูทระบบ A ยังสามารถรับเชลล์บนระบบ B ได้ ดังนั้น เว้นแต่คุณจะจำกัดสิทธิ์ทั่วทั้งระบบ รวมถึงคำสั่งปฏิบัติการของระบบ ผู้ใช้อาจยังสามารถเรียกใช้คำสั่งจำนวนมากโดยไม่ต้องอ่านไฟล์ข้อมูล ดังนั้นขึ้นอยู่กับว่าคุณหมายถึงใครที่เข้าถึงระบบได้ อีกครั้ง การไม่ใช้ SSH น่าจะเป็นทางออกที่ดีกว่าที่นี่
ในขณะที่ไม่ จุ๊ๆคุณอาจพบว่า กำลังซิงค์ เป็นที่สนใจ:
นอกจากนี้ยังสามารถใช้ได้ผ่านทาง ฉลาดพร้อมด้วยแพ็คเกจที่เกี่ยวข้อง:
$ apt ค้นหา -q ซิงค์
กำลังจัดเรียง...
ค้นหาข้อความแบบเต็ม...
golang-github-syncthing-notify-dev/focal,focal 0.0~git20180806.b76b458-1 ทั้งหมด
ไลบรารีการแจ้งเตือนเหตุการณ์ระบบไฟล์บนสเตอรอยด์
golang-github-syncthing-syncthing-dev/focal,focal 1.1.4~ds1-4ubuntu1 ทั้งหมด
การซิงโครไนซ์ไฟล์แบบกระจายอำนาจ - แพ็คเกจ dev
การซิงโครไนซ์/โฟกัส 1.1.4~ds1-4ubuntu1 amd64
การซิงโครไนซ์ไฟล์แบบกระจายอำนาจ
syncthing-discosrv/โฟกัส 1.1.4~ds1-4ubuntu1 amd64
การซิงโครไนซ์ไฟล์แบบกระจายอำนาจ - เซิร์ฟเวอร์การค้นพบ
syncthing-gtk/focal,focal 0.9.4.4-1 ทั้งหมด
GUI ที่ใช้ GTK3 และไอคอนพื้นที่แจ้งเตือนสำหรับการซิงค์
syncthing-relaysrv/focal 1.1.4~ds1-4ubuntu1 amd64
การซิงโครไนซ์ไฟล์แบบกระจายอำนาจ - เซิร์ฟเวอร์รีเลย์
สำหรับ SSH ขึ้นอยู่กับความถี่ของช่วงเวลาและปัจจัยรบกวนดังกล่าว คุณสามารถนำไปใช้ได้ การรับรองความถูกต้องของ Duo ทาง แพมซึ่งหมายความว่าจะต้องมีการอนุมัติสำหรับการเชื่อมต่อ
คนส่วนใหญ่ไม่เข้าใจว่าการถามคำถามมากมายจะปลดล็อกการเรียนรู้และปรับปรุงความสัมพันธ์ระหว่างบุคคล ตัวอย่างเช่น ในการศึกษาของ Alison แม้ว่าผู้คนจะจำได้อย่างแม่นยำว่ามีคำถามกี่ข้อที่ถูกถามในการสนทนา แต่พวกเขาไม่เข้าใจความเชื่อมโยงระหว่างคำถามและความชอบ จากการศึกษาทั้ง 4 เรื่องที่ผู้เข้าร่วมมีส่วนร่วมในการสนทนาด้วยตนเองหรืออ่านบันทึกการสนทนาของผู้อื่น ผู้คนมักไม่ตระหนักว่าการถามคำถามจะมีอิทธิพลหรือมีอิทธิพลต่อระดับมิตรภาพระหว่างผู้สนทนา