ผู้ใช้รูทและ sudo
ผู้ใช้รูทบนระบบ GNU/Linux คือผู้ใช้ที่มีสิทธิ์การเข้าถึงระดับผู้ดูแลระบบในระบบของคุณ ผู้ใช้ทั่วไปไม่สามารถเข้าถึงสิ่งนี้ได้เนื่องจากขาดการเข้าถึง อย่างไรก็ตามไม่มีใน Kubuntu ผู้ใช้รูท- แต่จะได้รับสิทธิ์การเข้าถึงระดับผู้ดูแลระบบแทน ผู้ใช้แต่ละรายซึ่งสามารถใช้แอปพลิเคชัน "sudo" เพื่อดำเนินงานด้านการดูแลระบบได้ อันดับแรก บัญชีที่สร้างขึ้นระหว่างการติดตั้งระบบ โดยค่าเริ่มต้นจะสามารถเข้าถึงแอปพลิเคชัน sudo ได้ คุณสามารถปฏิเสธการเข้าถึง sudo หรือให้อนุญาตโดยใช้แอปพลิเคชัน ผู้ใช้และกลุ่ม (ดู “ผู้ใช้และกลุ่ม”)
หากคุณเรียกใช้โปรแกรมที่ต้องใช้สิทธิ์ superuser sudo จะต้องให้คุณเข้าสู่โหมดปกติ รหัสผ่านผู้ใช้- สิ่งนี้ทำให้มั่นใจได้ว่า แอปพลิเคชันที่เป็นอันตรายจะไม่สร้างความเสียหายให้กับระบบของคุณ และยังจะเตือนคุณถึงสิ่งที่คุณกำลังจะทำอีกด้วย การดำเนินการด้านการบริหารที่ต้องการการดูแลเป็นพิเศษ!
หากต้องการใช้ sudo บนบรรทัดคำสั่ง เพียงพิมพ์ "sudo" หน้าคำสั่งที่คุณต้องการเรียกใช้ หลังจากนี้ sudo จะขอให้คุณป้อนรหัสผ่าน
Sudo จะจดจำรหัสผ่านของคุณตามระยะเวลาที่กำหนด (ค่าเริ่มต้นคือ 15 นาที) คุณสมบัตินี้ช่วยให้ผู้ใช้ดำเนินการได้ จำนวนมากงานธุรการโดยไม่ต้องใส่รหัสผ่านทุกครั้ง
ความสนใจ
ระมัดระวังในการปฏิบัติงานด้านการดูแลระบบ - คุณอาจทำลายระบบของคุณได้!
เคล็ดลับในการใช้ sudo:
หากต้องการใช้เทอร์มินัลของผู้ใช้รูท ให้พิมพ์ "sudo -i" ที่พร้อมท์คำสั่ง
ยูทิลิตี้การกำหนดค่ากราฟิกทั้งกลุ่มใน Kubuntu ใช้ sudo อยู่แล้ว ดังนั้นหากจำเป็น คุณจะถูกขอรหัสผ่านโดยใช้แอปพลิเคชัน เดสซูซึ่งเป็นเปลือกกราฟิก ซูโดะ .
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับโปรแกรม ซูโดะและไม่มีผู้ใช้รูทใน Kubuntu ดูหน้า sudo บนวิกิ Ubuntu
การรันโปรแกรมด้วยตนเองด้วยสิทธิ์รูท
บางครั้งจำเป็นต้องรันโปรแกรมที่มีสิทธิ์ใช้งานรูท นี่เป็นเรื่องง่ายที่จะทำโดยใช้บทสนทนา เรียกใช้คำสั่ง .
ความสนใจ
โปรดใช้ความระมัดระวังเมื่อใช้งานแอปพลิเคชันที่มีสิทธิ์ใช้งานรูท เนื่องจากอาจทำให้ระบบของคุณเสียหายได้ สำหรับข้อมูลเพิ่มเติม โปรดดูที่ผู้ใช้รูทและ sudo
- อ่าน เขียน และเปลี่ยนแปลงคุณสมบัติของไฟล์ในไดเร็กทอรีของคุณ
- อ่าน เขียน เปลี่ยนแอ็ตทริบิวต์ของไฟล์ในไดเร็กทอรี /tmp
- รันโปรแกรมโดยที่ไม่ได้รับอนุญาตให้ใช้แฟล็ก noexec
- อ่านไฟล์ที่มีการตั้งค่าสถานะการอ่านสำหรับผู้ใช้ทั้งหมด
- -c, --คำสั่ง- ดำเนินการคำสั่ง
- -g, --กลุ่ม- ตั้งค่ากลุ่มผู้ใช้หลัก (สำหรับรูทเท่านั้น)
- -G --supp-กลุ่ม- กลุ่มผู้ใช้เพิ่มเติม (สำหรับรูทเท่านั้น)
- -, -l, --เข้าสู่ระบบ- โหมดเข้าสู่ระบบ ทุกอย่างจะถูกล้างและเริ่มต้นโดยคำนึงถึงผู้ใช้ใหม่ ตัวแปรสภาพแวดล้อมและยังมีการเปลี่ยนแปลงอีกด้วย โฮมไดเร็กทอรี
- -p, --รักษาสิ่งแวดล้อม
- -s, --เชลล์- ตั้งค่าเปลือกเข้าสู่ระบบ
- --รุ่น- แสดงเวอร์ชั่นของโปรแกรม
- -ข- รันยูทิลิตี้ที่เปิดใช้งานในเบื้องหลัง
- -อี- บันทึกตัวแปรสภาพแวดล้อม
- -ก- รันคำสั่งจากกลุ่ม
- -ชม- ใช้โฮมไดเร็กตอรี่
- -ล- แสดงรายการสิทธิ์ sudo สำหรับผู้ใช้ปัจจุบัน
- -ร- ใช้บทบาท SELinux สำหรับคำสั่ง
- -ส- ใช้เปลือก
- -คุณ- รันคำสั่งในฐานะผู้ใช้ หากไม่ได้ระบุ ให้ใช้รูท
- -ฉัน- ห้ามรันคำสั่ง แต่ใส่เชลล์ซึ่งเทียบเท่ากับ su -
- กำหนดเคอร์เนลและเวอร์ชันการแจกจ่าย
- รับรายการเครื่องมือที่มีอยู่สำหรับการสร้างช่องโหว่
- ส่งสปลิตไปยังเครื่องเป้าหมาย
- คอมไพล์ (ถ้าจำเป็น) และรัน
- เพลิดเพลินไปกับรากที่เกิดขึ้น
- เราไม่เคยใช้มัน ในตัวแปร PATH
- ถ้าจุดนั้นยังคงอยู่ ให้วางมันไว้ บรรทัดถัดไปใน .bashrc หรือ .profile:
PATH= เสียงสะท้อน $PATH | sed -e "s/::/:/g; s/:.:/:/g; s/:.$//; s/^://"
เปิดบทสนทนา เรียกใช้คำสั่ง โดยการกด Alt -F2
ป้อนชื่อโปรแกรมที่คุณต้องการเรียกใช้ มีคำนำหน้า เดสซูและกด เข้า- เช่น การวิ่ง ตัวจัดการไฟล์ คอนเคอเรอร์ด้วยสิทธิ์ root ให้พิมพ์
ในคู่มือ Linux จำนวนมาก (และไม่ใช่แค่ Linux) เกี่ยวกับปัญหาด้านความปลอดภัย มีคำแนะนำเป็นประจำให้ดำเนินการที่ไม่ใช่การดูแลระบบทั้งหมดภายใต้ผู้ใช้ที่ไม่มีสิทธิ์ผู้ดูแลระบบ / ผู้ใช้ขั้นสูง พูดง่ายๆ ก็คือ ทุกคนแนะนำว่าอย่าทำงานเป็นรูทตลอดเวลา และหันไปทำงานเป็นรูทเมื่อจำเป็นเท่านั้น
ในความเป็นจริงในหลาย ๆ สถานการณ์จำเป็นต้องเรียกใช้กระบวนการภายใต้ผู้ใช้ที่ไม่เพียง แต่ไม่มีสิทธิ์รูทเท่านั้น แต่ยังไม่สามารถยกระดับสิทธิ์ในการรูทได้อีกด้วย ไม่มีทาง ไม่มีทาง ความต้องการนี้เกิดขึ้น (สมเหตุสมผลที่จะสร้างผู้ใช้ดังกล่าว) สำหรับบริการที่ทำงานบนเซิร์ฟเวอร์ ตัวอย่างเช่น Apache, Asterisk และอื่นๆ นั่นคือเพื่อให้ผู้ที่สามารถรับสิทธิ์ของผู้ใช้ดังกล่าวไม่เพียงแต่ไม่ได้รับสิทธิ์รูทเท่านั้น แต่ถึงแม้จะเรียนรู้รหัสผ่านรูท (ทันใด) ก็ไม่สามารถเข้าสู่ระบบโดยใช้รหัสผ่านนี้ได้ (เพิ่มสิทธิ์ของพวกเขา)
ใน Linux เวอร์ชันเก่า โหมดเริ่มต้นถูกตั้งค่าเป็นโหมดต่อไปนี้: ผู้ใช้ที่อยู่ในกลุ่มวงล้อสามารถรันคำสั่ง su ได้ แต่คนอื่นๆ ไม่สามารถทำได้ นั่นคือทุกคนสามารถเรียกใช้ su ได้ แต่สำหรับผู้ใช้ที่ไม่ได้มาจากกลุ่มวงล้อ คำสั่ง su ก็ยังด้วย รหัสผ่านที่ถูกต้องรูตจะทำให้เกิดข้อผิดพลาด
ใน รุ่นที่ทันสมัย linux เช่น CentOS และ Debian คุณลักษณะนี้จะถูกปิดใช้งานตามค่าเริ่มต้น เช่น ผู้ใช้ทุกคนสามารถยกระดับสิทธิ์ของตนได้ (รู้รหัสผ่านรูท) ในบทความนี้เราจะแสดงวิธีคืนโหมดที่เคยเป็นมาก่อนเพื่อให้เฉพาะผู้ใช้จากกลุ่มล้อเท่านั้นที่สามารถ "เพิ่ม" สิทธิ์ของตนได้
จะเริ่มตรงไหน
ก่อนอื่นคุณต้องป้องกันตัวเองก่อน นั่นคืออย่าลืมเพิ่มผู้ใช้ที่คุณทำงานอยู่ในกลุ่ม ล้อ- หากมีผู้ใช้หลายคนที่ทำงานในระบบซึ่งจำเป็นต้องเพิ่มสิทธิ์ในการรูทเป็นครั้งคราว ทั้งหมดของผู้ใช้เหล่านี้ต้องถูกเพิ่มเข้าในกลุ่มล้อ!
โปรดทราบว่านี่เป็นสิ่งสำคัญที่ต้องทำ ถึงคุณเปลี่ยนไปอย่างไร การตั้งค่าลินุกซ์มิฉะนั้น (เช่น หากคุณเชื่อมต่อกับเซิร์ฟเวอร์ผ่าน SSH ห้ามเข้าถึงผ่าน SSH ภายใต้รูท) หากคุณเข้าสู่ระบบในฐานะผู้ใช้ทั่วไปผ่าน SSH คุณจะไม่สามารถเพิ่มสิทธิ์ของคุณเป็นรูทได้!
สร้างวงล้อกลุ่ม
เป็นไปได้ว่าในตัวคุณ เวอร์ชันลินุกซ์ไม่มีกลุ่มล้อตามค่าเริ่มต้น จากนั้นจะต้องสร้างมันขึ้นมา มีคำสั่งต่อไปนี้สำหรับสิ่งนี้:
ล้อเพิ่มกลุ่ม
อย่ากลัวที่จะป้อนคำสั่งนี้: หากมีวงล้อกลุ่มอยู่ ก็จะแสดงข้อความว่ามีกลุ่มดังกล่าวอยู่แล้ว หากไม่มีกลุ่มดังกล่าวก็จะถูกสร้างขึ้น
วิธีเพิ่มผู้ใช้ในกลุ่มล้อ
มีคำสั่งสำหรับสิ่งนี้:
usermod -a -G ชื่อผู้ใช้ล้อ
ตัวอย่างเช่น:
usermod -a -G ชื่อผู้ใช้ล้อ
คำสั่งนี้จะเพิ่มชื่อผู้ใช้ให้กับกลุ่มล้อ หากผู้ใช้เป็นสมาชิกของกลุ่มอื่นตั้งแต่หนึ่งกลุ่มขึ้นไป ความเป็นสมาชิกในกลุ่มทั้งหมดจะยังคงอยู่ เพียงเพิ่มผู้ใช้ในกลุ่มอื่น (เพิ่มเติม)
ตรวจสอบว่าทุกอย่างถูกต้องแล้ว มีคำสั่งสำหรับสิ่งนี้:
รหัสชื่อผู้ใช้
ตัวอย่างเช่น:
รหัสชื่อผู้ใช้
ID ผู้ใช้ ชื่อผู้ใช้ ID และชื่อของแต่ละกลุ่มที่ผู้ใช้เป็นสมาชิกจะปรากฏขึ้น ตรวจสอบให้แน่ใจทุกอย่าง ผู้ใช้ที่จำเป็นเพิ่มเข้าในกลุ่มล้อแล้ว
เรียกใช้ su โดยผู้ใช้จากกลุ่มล้อเท่านั้น
เปิดในของคุณ โปรแกรมแก้ไขข้อความไฟล์: /etc/pam.d/su
ในไฟล์นี้ ให้มองหาบรรทัดที่คล้ายกับข้อความต่อไปนี้:
ต้องมีการตรวจสอบสิทธิ์ pam_wheel.so
หรือ
ต้องมีการรับรองความถูกต้อง pam_wheel.so use_uid
ตามค่าเริ่มต้น บรรทัดนี้จะขึ้นต้นด้วยเครื่องหมาย "#" ซึ่งเหมือนกับความคิดเห็น ลบเครื่องหมายความคิดเห็นออกจากจุดเริ่มต้นของบรรทัดนี้และบันทึกไฟล์
ทั้งหมด! ขณะนี้มีเพียงผู้ใช้จากกลุ่มล้อเท่านั้นที่สามารถรันคำสั่ง su และเพิ่มสิทธิพิเศษเป็นรูทได้ อย่าลืมตรวจสอบออก!
ดังที่คุณทราบ Linux ให้ความสำคัญกับการจัดการผู้ใช้และให้สิทธิ์ในการใช้ระบบอย่างจริงจัง ผู้ใช้ปกติสามารถเขียนไฟล์ลงในไดเร็กทอรีของตนเองและไดเร็กทอรี /tmp/ เท่านั้น นอกจากนี้ยังสามารถอ่านไฟล์บางไฟล์ในรูทได้อีกด้วย ระบบไฟล์- แต่คุณไม่สามารถติดตั้งโปรแกรมได้ เนื่องจากต้องได้รับอนุญาตในการเขียน คุณไม่สามารถเปลี่ยนคุณสมบัติของไฟล์ คุณไม่สามารถเริ่มบริการได้ คุณไม่สามารถอ่านไฟล์บันทึกบางไฟล์ได้ และอื่นๆ อีกมากมายที่คุณไม่สามารถทำได้
ใน Linux เฉพาะผู้ใช้รูทเท่านั้นที่มีสิทธิ์จัดการระบบไฟล์รูทและสร้างไฟล์ที่นั่น
ในบทความนี้เราจะดูว่าโปรแกรมใดบ้างที่จำเป็นในการรับสิทธิ์รูท ผู้ใช้ลินุกซ์มันทำงานยังไง รันโปรแกรมยังไง สิทธิ์รูทจากผู้ใช้ทั่วไปและวิธีการรัน โปรแกรมกราฟิกด้วยสิทธิ์รูท นอกจากนี้เรายังจะพบว่า sudo คืออะไรและอะไรคือความแตกต่างระหว่าง su และ sudo
จะใช้เวลานานในการแสดงรายการสิ่งที่ผู้ใช้ Linux ทั่วไปไม่สามารถทำได้ จะง่ายกว่าที่จะพูดในสิ่งที่เขามีสิทธิ์ทำคือเมื่อใด การตั้งค่ามาตรฐานการอนุญาตไฟล์ใน Linux ผู้ใช้ทั่วไปสามารถ:
หากเราต้องทำอะไรมากกว่านี้ เราจะต้องมีสิทธิ์ผู้ใช้รูท Linux รูทมีสิทธิ์ทำทุกอย่างบนระบบไฟล์ของคุณ โดยไม่คำนึงถึงสิทธิ์ที่กำหนดไว้ในไฟล์
เข้าสู่ระบบในฐานะ superuser
หากต้องการเข้าสู่ระบบในฐานะผู้ใช้รูท คุณสามารถสลับไปยังคอนโซลเสมือนตัวใดตัวหนึ่งได้ เช่น โดยใช้แป้นพิมพ์ลัด Ctrl+Alt+F1 จากนั้นป้อนล็อกอินรูทและรหัสผ่านผู้ใช้รูท
คุณจะได้รับสภาพแวดล้อมรูทเต็มรูปแบบพร้อมความสามารถในการทำทุกอย่าง แต่วิธีนี้ใช้ไม่ได้ผลมากเนื่องจากคุณจะสูญเสียประโยชน์ทั้งหมดของการใช้ GUI
เราสามารถทำสิ่งที่ตรงกันข้ามได้ทั้งหมด ป้อนข้อมูลล็อกอินรูทและรหัสผ่านในตัวจัดการล็อกอินแบบกราฟิก เพื่อให้สภาพแวดล้อมเดสก์ท็อปทำงานในฐานะรูท และเราได้รับสิทธิ์ทั้งหมด รูทลินุกซ์แต่ไม่แนะนำให้ใช้ตัวเลือกนี้อย่างยิ่ง และอันตรายมากอาจทำให้ระบบทั้งหมดเสียหายโดยไม่ได้ตั้งใจ ดังนั้นวิธีนี้จึงถูกปิดใช้งานในตัวจัดการการเข้าสู่ระบบจำนวนมาก
สลับไปใช้ superuser ในเทอร์มินัล
ตอนนี้เรามาถึงสิ่งที่น่าสนใจและใช้งานได้จริงมากขึ้น เมื่อใช้ยูทิลิตี้พิเศษ คุณสามารถสลับเทอร์มินัลอีมูเลเตอร์ปัจจุบันไปเป็นสภาพแวดล้อม superuser และดำเนินการคำสั่งต่อไปนี้ทั้งหมดไม่ใช่ในนามของคุณ แต่ในนามของเขา จึงให้สิทธิ์รูทโปรแกรม Linux มียูทิลิตี้ชื่อ su เพื่อจุดประสงค์นี้ โดยทั่วไปแล้ว ยูทิลิตี้นี้ช่วยให้คุณไม่เพียงแต่สามารถเปลี่ยนไปใช้ผู้ใช้รูทเท่านั้น แต่ยังรวมถึงผู้ใช้รายอื่นด้วย แต่โดยค่าเริ่มต้นจะเป็นรูทที่ใช้ เรามาดูกันดีกว่า คำสั่ง su linux มีไวยากรณ์ดังต่อไปนี้:
ผู้ใช้ตัวเลือก $su
นี่คือตัวเลือกหลัก:
ตอนนี้เรามาทดลองกันสักหน่อยเพื่อทำความเข้าใจว่าคำสั่ง su linux ทำงานอย่างไร
ขั้นแรก เรามารัน su โดยไม่มีพารามิเตอร์ แต่ก่อนอื่น เราจะสร้างตัวแปรสภาพแวดล้อมเพื่อตรวจสอบว่าคำสั่งนี้จัดการกับพารามิเตอร์เหล่านี้อย่างไร:
ตอนนี้เราทำ:
มาดูกันว่าเกิดอะไรขึ้น:
โฮอามิ
$pwd
$ เอคโค $VAR
$ เสียงสะท้อน $ PATH
$ ออก
จากคำสั่งเหล่านี้เราจะเห็นว่าตอนนี้เราเป็นผู้ใช้รูทแล้ว แต่โฮมไดเร็กทอรีถือเป็นไดเร็กทอรีของเรา ผู้ใช้คนก่อนและตัวแปรของเราไม่ได้รับการบันทึก และตัวแปร PATH ก็เปลี่ยนไปด้วย ตอนนี้เส้นทาง /sbin ได้ถูกเพิ่มไว้ที่นั่น
ตอนนี้เราใช้โหมดเข้าสู่ระบบ:
และลองทำซ้ำชุดค่าผสมเดียวกัน:
โฮอามิ
$pwd
$ เอคโค $VAR
$ เสียงสะท้อน $ PATH
$ ออก
สถานการณ์เดียวกัน เพียงแต่คราวนี้โฮมไดเร็กตอรี่ถูกเปลี่ยนเป็นไดเร็กทอรีรากด้วย แต่เราสามารถบันทึกตัวแปรสภาพแวดล้อมของเราได้หากจำเป็น โดยมีตัวเลือก -p สำหรับสิ่งนี้:
อย่างที่คุณเห็น ตัวแปรของเรายังคงอยู่ คุณสามารถเปลี่ยนไปใช้ผู้ใช้รายอื่นได้ ตัวอย่างเช่น:
การได้รับสิทธิ์ superuser ในลักษณะนี้ถูกนำมาใช้ในหลาย ๆ การแจกแจง เช่น Debian, OpenSUSE, ArchLInux, Gentoo เป็นต้น แต่ใน Ubuntu เป็นการแจกจ่ายสำหรับผู้เริ่มต้น การเข้าสู่ระบบโดยผู้ใช้รูทถูกปิดใช้งาน สิ่งนี้ทำเพราะมันไม่ปลอดภัยเช่นกัน คุณอาจลืมไปว่าคุณกำลังรันคำสั่งในฐานะรูทและทำสิ่งผิดปกติในระบบ เรามาต่อกันที่โปรแกรมต่อไปกันเลย
รับสิทธิ์รูทโดยไม่ต้องเปลี่ยน
เพื่อใช้อินเทอร์เฟซที่ปลอดภัยที่สุดสำหรับการทำงานกับสิทธิ์ผู้ใช้ระดับสูงใน Linux คำสั่ง sudo จึงได้รับการพัฒนา มาดูกันว่า sudo คืออะไร คำสั่งนี้เขียนไว้หน้าแต่ละคำสั่งที่ต้องดำเนินการในฐานะผู้ใช้ระดับสูง และในการดำเนินการคุณจะต้องป้อนรหัสผ่านที่ไม่ใช่ของรูท แต่เป็นเพียงรหัสผ่านของผู้ใช้ของคุณ เช่นเดียวกับก่อนหน้านี้ ยูทิลิตี้นี้มีตัวเลือกของตัวเอง ลองดูที่ไวยากรณ์ก่อน:
คำสั่งตัวเลือก $ sudo
ตัวเลือกโปรแกรม:
คุณสามารถทำการทดลองเดียวกันได้เฉพาะกับคำสั่งนี้เท่านั้น เพื่อทำความเข้าใจวิธีใช้คำสั่ง sudo ตัวอย่างเช่น:
การใช้ sudo เป็นวิธีที่แนะนำในการรันคำสั่งในฐานะรูทบน Linux ด้วยวิธีนี้คุณจะไม่ลืมสิ่งที่คุณกำลังเผชิญอยู่และมีความเสี่ยงน้อยที่สุดที่จะทำให้ระบบเสียหาย แต่ยังมีคำถามหนึ่งข้อที่ยังไม่ได้รับการแก้ไข - จะทำอย่างไร ยูทิลิตี้กราฟิก- ท้ายที่สุดแล้วคำสั่ง sudo จะไม่รัน แต่ทำงานอยู่ เปลือกกราฟิกการรันในฐานะรูทนั้นไม่ปลอดภัย นี่คือสิ่งที่เราจะดูต่อไป
แอปพลิเคชันแบบกราฟิกในฐานะ superuser
เพื่อเริ่มต้น แอปพลิเคชั่นกราฟิกมีอยู่ในนามของ superuser สาธารณูปโภคพิเศษ- โดยจะรักษาตัวแปรสภาพแวดล้อมและการอนุญาตที่จำเป็นทั้งหมดไว้ ใน KDE นี่คือคำสั่ง kdesu และใน Gnome คือคำสั่ง gksu
เพียงพิมพ์ gksu หรือ kdesu ตามด้วยคำสั่งที่คุณต้องการ:
คำสั่งนี้จะเปิดตัวจัดการไฟล์ KDE ด้วยสิทธิ์ผู้ใช้ขั้นสูง ใน Gnome จะมีลักษณะดังนี้:
โปรแกรมจะถามรหัสผ่านในหน้าต่างกราฟิก จากนั้นตัวจัดการไฟล์จะเปิดขึ้น
ข้อสรุป
แค่นั้นแหละ. ตอนนี้คุณรู้วิธีรับสิทธิ์ superuser ใน Linux แล้ว คุณรู้วิธีใช้คำสั่ง sudo และอะไรคือความแตกต่างระหว่าง sudo และ su ตอนนี้โปรแกรมที่ต้องการสิทธิ์เพิ่มเติมบนระบบจะไม่ทำให้คุณเกิดปัญหา หากคุณมีคำถามใด ๆ เขียนในความคิดเห็น!
1. การใช้คำสั่ง: su
คำสั่งหลายคำสั่งสามารถรันได้โดย superuser เท่านั้น ดังนั้นเราจำเป็นต้องรู้วิธีที่จะรูท ในการทำเช่นนี้เราสามารถใช้คำสั่ง: su (สลับผู้ใช้) คำสั่ง su ยอมรับรูปแบบต่อไปนี้:
แต่ส่วนใหญ่แล้วเราจะใช้ ซูเพื่อที่จะได้เป็นผู้ใช้ ราก:
ซู - รูท
หากไม่ได้ระบุชื่อผู้ใช้ในบรรทัด ระบบจะถือว่าผู้ใช้เป็นรูทโดยอัตโนมัติ ดังนั้นคำสั่งจึงสามารถย่อให้สั้นลงได้:
แต่ทั้งสองทีมมีพฤติกรรมที่แตกต่างกัน "su" ให้ตัวตนแก่ผู้ใช้ปัจจุบัน ในขณะที่ "su -" ให้ตัวตนแก่ผู้ใช้ปัจจุบันพร้อมกับสภาพแวดล้อมที่จะได้รับจากการลงทะเบียนเป็น
ผู้ใช้มักจะใช้ "su" เพื่อรูท หากคุณพยายามเรียกใช้คำสั่ง (เช่น - ifconfig) คุณจะได้รับ: "command ไม่พบ" ข้อผิดพลาด.
รหัสผ่าน Su: ifconfig bash: ifconfig: ไม่พบคำสั่ง
เหตุผลก็คือ ผู้ใช้ระบบปกติและผู้ใช้รูทมีตัวแปรสภาพแวดล้อม PATH ที่แตกต่างกัน (คุณสามารถดู PATH ของผู้ใช้ได้โดยใช้ "echo $PATH") หลังจากป้อน คำสั่งลินุกซ์เชลล์จะค้นหา PATH ของผู้ใช้เพื่อพยายามค้นหาคำสั่งที่จะรัน มันเริ่มค้นหาทุกไดเร็กทอรีที่อยู่ใน PATH จนกระทั่งพบเป้าหมาย
ทีม ผู้ใช้ทั่วไปโดยปกติจะอยู่ใน /usr/local/bin, /usr/bin และ /bin และคำสั่งผู้ใช้รูทส่วนใหญ่จะอยู่ใน /usr/local/sbin, /usr/sbin, /sbin และ PATH ของรูทจะสะท้อนถึงสิ่งนี้ ดังนั้นเมื่อคุณกลายเป็น superuser ด้วย "su -" คุณจะใช้ PATH ใหม่สำหรับคำสั่งหลักของคุณด้วย และใช้เพียง "su" เท่านั้นจึงจะถูกบันทึก เส้นทางที่กำหนดเอง PATH เป็นค่าเริ่มต้น ดังนั้น เมื่อพยายามรันโปรแกรมที่อยู่ใน /usr/local/sbin, /usr/sbin, /sbin มันจะให้ผลลัพธ์: ข้อผิดพลาด "ไม่พบคำสั่ง" สำหรับคำอธิบายโดยละเอียดเพิ่มเติม โปรดดูที่หน้า man bash โดยเฉพาะส่วนล็อกอินเชลล์
ดังนั้นคุณหรือควรระบุ เส้นทางเต็มไปที่คำสั่ง (ตัวอย่าง - /sbin/ifconfig) เมื่อใช้ "su" หรือใช้ "su -" เมื่อกลายเป็นรูท
2. การใช้ซูโด้
คุณไม่จำเป็นต้องเป็น superuser ทุกครั้งที่คุณต้องการเรียกใช้ฟังก์ชันการดูแลระบบบางอย่าง ขอบคุณ ซูโดะคุณสามารถรันคำสั่งบางส่วนหรือทั้งหมดในฐานะรูทได้ เมื่อไร ซูโดะติดตั้งแล้ว (แพ็คเกจ: Sudo) คุณสามารถกำหนดค่าได้โดยใช้คำสั่ง "visudo" ในฐานะรูท โดยพื้นฐานแล้วจะแก้ไข (ค่าเริ่มต้นเป็นกลุ่ม) /etc/sudoers แต่ไม่แนะนำให้ทำด้วยตนเอง
อเล็กซ์ ออล=(ทั้งหมด)ทั้งหมด
อเล็กซ์คือชื่อผู้ใช้ บันทึก (กด Escape แล้วพิมพ์ wq) เท่านี้ก็เสร็จเรียบร้อย เข้าสู่ระบบด้วย alex และเรียกใช้ตัวอย่าง:
อัปเดต $sudo yum
Sudo จะขอรหัสผ่าน นี่คือรหัสผ่านของ Alex ไม่ใช่ของผู้ใช้รูท ดังนั้นควรระมัดระวังเมื่อคุณให้สิทธิ์ผู้ใช้กับ Sudo
แต่ Sudo สามารถทำได้มากกว่านั้น เราสามารถอนุญาตให้ผู้ใช้หรือกลุ่มผู้ใช้สามารถรันคำสั่งหรือกลุ่มคำสั่งได้เพียงคำสั่งเดียวเท่านั้น กลับไปที่ไฟล์ sudoers ของเรากัน เริ่มจาก alex และ alisa สมาชิกของกลุ่มผู้ดูแลระบบกันก่อน หากเราต้องการให้ผู้ใช้ทั้งหมดในกลุ่ม "ผู้ดูแลระบบ" สามารถรันทุกคำสั่งในฐานะ superuser ได้ เราจะต้องแก้ไขตัวอย่างของเรา:
%ผู้ดูแลระบบทั้งหมด=(ทั้งหมด)ทั้งหมด
อเล็กซ์ยังสามารถดำเนินการคำสั่ง superuser และ Alisa มีสิทธิ์เรียกใช้ Sudo โดยมีสิทธิ์และรหัสผ่านเดียวกัน หาก alex และ alisa ไม่ใช่สมาชิกของกลุ่มเดียวกัน เราสามารถกำหนดนามแฝงของผู้ใช้ในไฟล์ sudoers ได้:
User_Alias ADMINS = อลิสา,อเล็กซ์
ที่นี่เราได้กำหนดนามแฝงที่เรียกว่า ADMINS โดยมีสมาชิก alisa และ alex
อย่างไรก็ตาม เราไม่ต้องการให้ Alex และ Alisa สามารถรันโปรแกรมใดๆ ในฐานะ root ได้ เราต้องการให้พวกเขาสามารถเรียกใช้ "updatedb" เท่านั้น มากำหนดนามแฝงของคำสั่ง:
Cmnd_Alias LOCATE = /usr/sbin/updatedb
แต่นี่ยังไม่เพียงพอ! เราจำเป็นต้องบอก Sudo ว่าผู้ใช้ที่กำหนดเป็น ADMINS สามารถเรียกใช้คำสั่งที่ระบุใน LOCATE ได้ เมื่อต้องการทำเช่นนี้ เราจะแทนที่บรรทัดด้วย "%admin" ด้วย:
ผู้ดูแลระบบทั้งหมด = ค้นหา
ซึ่งหมายความว่าผู้ใช้ในนามแฝง ADMINS สามารถเรียกใช้คำสั่งทั้งหมดในนามแฝง LOCATE
คราวนี้ /etc/sudoers มีลักษณะดังนี้:
User_Alias ADMINS = alisa, alex Cmnd_Alias LOCATE = /usr/bin/updatedb ADMINS ทั้งหมด = LOCATE
เป็นผลให้ alex และ alisa สามารถรัน addeddb ในฐานะ root ได้โดยการป้อนรหัสผ่าน
หากบรรทัดสุดท้ายในไฟล์มีการเปลี่ยนแปลง:
ผู้ดูแลระบบทั้งหมด = NOPASSWD:LOCATE
จากนั้น alex และ alisa จะสามารถดำเนินการ "sudo addedb" ได้โดยไม่ต้องป้อนรหัสผ่าน
คุณสามารถเพิ่มคำสั่งเพิ่มเติมให้กับนามแฝงของคำสั่งและเพิ่มนามแฝงให้กับกฎได้ ตัวอย่างเช่น เราสามารถสร้างนามแฝง NETWORKING ที่มีบางส่วนได้ คำสั่งเครือข่ายประเภท: ifconfig, เส้นทางหรือ iwconfig:
Cmnd_Alias NETWORKING = /sbin/route, /sbin/ifconfig, /bin/ping, /sbin/dhcclient, /usr/bin/net, sbin/iptables, /usr/bin/rfcom, /usr/bin/wvdial, /sbin /iwconfig, /sbin/mii-tool
มาเพิ่มทั้งหมดนี้ลงในไฟล์ /etc/sudoers ของเรา (โดยใช้ visudo!) นอกจากนี้เรายังให้สิทธิ์แก่กลุ่ม ADMINS ในการรันโปรแกรมจากนามแฝง NETWORKING:
User_Alias ADMINS = alice, bob Cmnd_Alias LOCATE = /usr/bin/updatedb Cmnd_Alias NETWORKING = /sbin/route, /sbin/ifconfig, /bin/ping, /sbin/dhclient, /usr/bin/net ,/sbin/iptables, /usr/bin/rfcomm, /usr/bin/wvdial, /sbin/iwconfig, /sbin/mii-tool ADMINS ทั้งหมด = ตำแหน่ง, ระบบเครือข่าย
การทดสอบอย่างรวดเร็ว: เข้าสู่ระบบด้วยชื่อ alisa (หรือ alex) และพิมพ์:
$ping -c 10 -i localhost
คำตอบควรกลับมาอย่างรวดเร็ว:
PING localhost.localdomain (127.0.0.1) ข้อมูล 56(84) ไบต์ ปิง: ไม่สามารถน้ำท่วม; ช่วงเวลาขั้นต่ำที่อนุญาตสำหรับผู้ใช้คือ 200ms
ตอนนี้สิ่งเดียวกัน แต่กับ Sudo:
$sudo ping -c 10 -i 0 localhost PING localhost.localdomain (127.0.0.1) ข้อมูล 56(84) ไบต์ 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=1 ttl=64 time=0.049 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=2 ttl=64 time=0.034 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=3 ttl=64 เวลา=0.021 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=4 ttl=64 เวลา=0.030 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=5 ttl=64 เวลา=0.017 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=6 ttl=64 เวลา=0.016 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=7 ttl=64 เวลา=0.016 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=8 ttl=64 เวลา=0.016 ms 64 ไบต์จาก localhost.localdomain (127.0.0.1): icmp_seq=9 ttl=64 เวลา=0.016 ms 64 ไบต์ จาก localhost.localdomain (127.0.0.1): icmp_seq=10 ttl=64 time=0.016 ms --- สถิติการ ping ของ localhost.localdomain --- ส่ง 10 แพ็กเก็ต, ได้รับ 10 ครั้ง, สูญเสียแพ็กเก็ต 0%, เวลา 1ms rtt min/avg/ สูงสุด/mdev = 0.016/0.023/0.049/0.010 ms, ipg/ewma 0.187/0.028 ms
ซูโดะมักใช้เพื่อให้ผู้ใช้บางรายเข้าถึงคำสั่งพิเศษบางส่วนเพื่อให้สามารถทำหน้าที่การดูแลระบบที่จำกัดได้ หนึ่งในสิ่งอำนวยความสะดวก ซูโดะคือคำสั่งทั้งหมดถูกเขียนไปที่ /var/log/secure ตัวอย่างข้างต้นจะอธิบายไว้ในบรรทัดในบันทึก:
18 เม.ย. 11:23:17 น. localhost sudo: alex: TTY=pts/0 ; PWD=/home/อเล็กซ์ ; ผู้ใช้=รูท ; คำสั่ง=/bin/ping -c 10 -i 0 localhost
แค่นั้นแหละ. ตอนนี้ฉันจะไม่มีวันลืมเมื่อฉันใช้ Sudo: "ด้วยพลังอันยิ่งใหญ่มาพร้อมกับความรับผิดชอบที่ยิ่งใหญ่"
2.1 เชลล์ Sudo
หากคุณมีสิทธิ์เพียงพอที่กำหนดค่าใน sudoers คุณสามารถเปิดรูทได้ เปลือกโดยใช้:
ใน เวอร์ชันล่าสุดบน CentOS 5 เท่านั้น หากต้องการรันเชลล์ในฐานะรูท ให้ใช้ sudo -s โปรดใช้ความระมัดระวังเนื่องจากอาจเปลี่ยนแปลงหรือสร้างไฟล์ใหม่ได้ โฮมไดเร็กทอรีรูทและติดตั้งในโฮมไดเร็กทอรีของผู้ใช้ที่โทร
3.ผู้ช่วยคอนโซล
Consolehelper เป็นเชลล์สำหรับเรียกใช้แอปพลิเคชัน GUI เมื่อเริ่มทำงาน ระบบจะตรวจสอบการกำหนดค่า PAM สำหรับแอปพลิเคชันที่จำเป็น ซึ่งหมายความว่าเราสามารถตรวจสอบผู้ใช้โดยใช้ทั้งหมดได้ โมดูลที่ติดตั้งแพม. วิธีการหลักคือการขอรหัสผ่านแต่ถ้าเรามีอุปกรณ์ที่เหมาะสม เราสามารถรับรองความถูกต้องโดยใช้สมาร์ทการ์ด โทเค็น ลายนิ้วมือ ฯลฯ การกำหนดค่า PAM อยู่นอกเหนือขอบเขตของเอกสารนี้ (ดูคู่มือผู้ดูแลระบบ PAM) ดังนั้นเราจะดูขั้นตอนการกำหนดค่า consolehelper ที่จำเป็นในการรันแอปพลิเคชันในฐานะรูทและต้องใช้รหัสผ่านรูท
ตามตัวอย่าง กำหนดค่า /usr/bin/xterm ให้รันในฐานะ root
Ln -s /usr/sbin/consolehelper /usr/bin/xterm-root
ตอนนี้เพื่อกำหนดค่า PAM ให้สร้างไฟล์ /etc/pam.d/xterm-root:
#% PAM-1.0 การตรวจสอบสิทธิ์รวมบัญชี config-util รวมถึงเซสชัน config-util รวมถึง config-util
สุดท้าย กำหนดค่า consolehelper ให้รัน /usr/bin/xterm ในฐานะ root ด้วยคำสั่ง "xterm-root" สร้างไฟล์ /etc/security/console.apps/xterm-root:
USER=root โปรแกรม=/usr/bin/xterm
แค่นั้นแหละ. เรียกใช้ "xterm-root" (จาก บรรทัดคำสั่งหรือไฟล์ Shortcut.desktop) ใส่รหัสผ่านแล้วไป หากคุณได้รับข้อผิดพลาด: "Xlib: การเชื่อมต่อกับ ":0.0" ถูกปฏิเสธโดยเซิร์ฟเวอร์" ให้เรียกใช้ "xhost local:root" ก่อน
ฉันจะเพิ่มสิทธิ์ของฉันเป็นสิทธิ์ของระบบได้อย่างไร? โลกของวินโดวส์- ปรากฎว่ามีตัวเลือกมากเกินพอสำหรับสิ่งนี้ สิ่งที่ต้องเลือกขึ้นอยู่กับทั้งสถานการณ์และความชอบของคุณ อย่างไรก็ตาม อย่างที่คุณเข้าใจ คุณจะต้องขยายพลังของคุณไม่เพียงแต่สำหรับหน้าต่างเท่านั้น แต่ยังสำหรับนกเพนกวินด้วย มีโอกาสอะไรบ้าง? มาดูกัน...
คำนำ
ดังที่คุณจำได้ (และตามที่ผู้ดูแลระบบทุกคนควรจำไว้) ไม่แนะนำให้ทำงานใน Linux ภายใต้รูทโดยเด็ดขาด ในโลกอุดมคติ คุณจะใช้สำหรับการกำหนดค่าเซิร์ฟเวอร์ การติดตั้งและอัปเดตซอฟต์แวร์ และงานการดูแลระบบอื่นๆ เท่านั้น ปัญหาคือเราอาศัยอยู่ในโลกธรรมดาซึ่งยังห่างไกลจากอุดมคติมาก ดังนั้นบางครั้งสถานการณ์ดังกล่าวก็ยังคงเกิดขึ้น จริงอยู่ ในกรณีส่วนใหญ่ เกิดจากความประมาทเลินเล่อล้วนๆ เพราะมันเกิดขึ้นในอดีตที่ผู้ใช้ Linux ต้องเข้าใจว่าพวกเขา ระบบปฏิบัติการ- และแม้ว่าคุณจะเข้าใจระบบและกลไกด้านความปลอดภัยเพียงเล็กน้อย แต่คุณก็จะไม่สามารถนั่งอยู่ใต้รูทได้ ดังนั้นวันนี้ไม่เหมือนกับ Windows ที่เราพูดถึงการได้รับสิทธิพิเศษของระบบในฐานะผู้ดูแลระบบเราจะพิจารณาเฉพาะตัวเลือกในการเพิ่มสิทธิ์จากผู้ใช้ที่ไม่มีสิทธิ์ไปจนถึงรูทเท่านั้น มาเริ่มกันเลย
การใช้ประโยชน์
วิธีการรับสิทธิ์ superuser ใน Linux ทั้งหมดสามารถแบ่งออกเป็นสองประเภท ประการแรกคือการใช้ช่องโหว่อย่างแม่นยำ ต่างจาก Windows ที่มีกลไกของมัน การติดตั้งอัตโนมัติการอัปเดต ผู้ติดตาม Penguin จะต้องติดตามการเปิดตัวแพตช์และการติดตั้งด้วยตนเองเป็นส่วนใหญ่ ทั้งนี้โอกาสที่จะเจอระบบที่ไม่ได้รับการแพตช์เต็มในเครื่อง Linux นั้นสูงกว่ามาก มีข้อดีอะไรบ้าง วิธีนี้คุณเน้นได้ไหม? ประการแรก ช่องโหว่ส่วนใหญ่ใช้ช่องโหว่ในเคอร์เนลระบบปฏิบัติการ ซึ่งช่วยให้พวกเขาได้รับสิทธิพิเศษสูงสุด การค้นหาโค้ดช่องโหว่ที่เหมาะสมนั้นไม่ใช่เรื่องยาก และคุณอาจรู้จักแหล่งข้อมูลสองสามอย่าง นอกจากนี้ เพื่อใช้ประโยชน์จากช่องโหว่ บางครั้งคุณไม่จำเป็นต้องเข้าใจความซับซ้อนทั้งหมดของช่องโหว่ที่ใช้ - คุณเพียงแค่ต้องคอมไพล์อย่างถูกต้องและเรียกใช้ (อย่างไรก็ตามบางครั้งคุณต้องปรับแต่งมันเล็กน้อย แต่ บ่อยครั้งที่ทุกอย่างจะทำงานได้โดยไม่ต้องปรับแต่งไฟล์) ใน มุมมองทั่วไปอัลกอริธึมของการกระทำมีดังนี้:
ตอนนี้เกี่ยวกับรายละเอียดเพิ่มเติมเกี่ยวกับแต่ละขั้นตอน
บัตรประจำตัว
เมื่อพิจารณาจากแผน ก่อนอื่นเราต้องค้นหาว่าสุดท้ายแล้วเราอยู่ที่ไหน เราใช้ distro ประเภทใด และเวอร์ชันของเคอร์เนลคืออะไร เวอร์ชันเคอร์เนลสามารถเรียกค้นได้โดยใช้คำสั่ง uname -a ที่รู้จักกันดีหรือแอนะล็อก ในการรับข้อมูลเกี่ยวกับการแจกจ่ายที่คุณใช้ คุณต้องดูไฟล์ *-release ที่อยู่ในไดเร็กทอรี etc (อาจเรียกต่างกันออกไปได้: lsb-release ใน Ubuntu, redhat-release in หมวกแดง/ CentOS และอื่นๆ):
cat /etc/*-release
เมื่อทราบเวอร์ชันการแจกจ่ายและเคอร์เนลแล้ว คุณสามารถไปยังขั้นตอนที่สองได้ - ค้นหา "คีย์หลัก" ที่เหมาะสม
ค้นหาช่องโหว่
เมื่อข้อมูลที่จำเป็นทั้งหมดอยู่ในมือแล้ว ก็ถึงเวลาค้นหาช่องโหว่ที่เหมาะสม สิ่งแรกที่นึกถึงคือ Exploit-db.com แต่ก็มีทางเลือกอื่นด้วย: 1337day, SecuriTeam, ExploitSearch, Metasploit, เหตุผลด้านความปลอดภัย, seclists ท้ายที่สุดแล้ว มี Google ซึ่งรู้เรื่องเกี่ยวกับการหาประโยชน์มากกว่าใครๆ อย่างแน่นอน เมื่อมองไปข้างหน้าเล็กน้อยฉันจะพูดว่า: บางครั้ง "คีย์หลัก" ด้วยเหตุผลบางอย่างอาจไม่ทำงานหรือคุณจำเป็นต้องปรับให้เข้ากับเงื่อนไขบางประการหรือความต้องการของคุณเล็กน้อยนั่นคือดำเนินการผ่านไฟล์ ในกรณีนี้ การหาข้อมูลเกี่ยวกับเธอไม่ใช่เรื่องเสียหาย ข้อมูลเพิ่มเติมซึ่งสามารถหาได้จากแหล่งข้อมูลอย่างใดอย่างหนึ่งต่อไปนี้:
www.cvedetails.com
packetstormsecurity.org
cve.mitre.org
สมมติว่าคุณพบช่องโหว่ที่เหมาะสมที่ช่วยให้คุณเข้าสู่โลกแห่งรูตได้ สิ่งที่เหลืออยู่ก็คือการขนส่งมันไปที่รถ
จัดส่งถึงบ้าน
ในการส่งสเปรดเดอร์ไปยังที่ตั้ง มีหลายวิธี ตั้งแต่ cURL/wget, Netcat, FTP, SCP/SFTP, SMB ไปจนถึงการใช้ DNS บันทึก TXT- หากต้องการทราบว่าเรามีเครื่องมือใดบ้าง ให้เรียกใช้:
ค้นหา / -name wget find / -name nc* find / -name netcat* find / -name tftp* find / -name ftp
สมมติว่าเราพบ Netcat หากต้องการถ่ายโอนไฟล์โดยใช้ให้รันด้านรับ:
nc -l -p 1234 > out.file
นั่นคือเราฟังพอร์ต 1234 ในอันที่ส่งเราทำสิ่งต่อไปนี้:
nc -w 3 1234< out.file
หากการถ่ายโอนเกิดขึ้นจาก *nix — บนระบบ *nix นั่นคือ ตรงนั้นและตรงนั้น สาธารณูปโภคมาตรฐานจากนั้นคุณสามารถใช้การบีบอัดเพื่อเร่งกระบวนการถ่ายโอนได้ ในกรณีนี้ คำสั่งจะมีลักษณะดังนี้:
เอ็นซี -l -p 1234 | คลายการบีบอัด -c | tar xvfp - // เพื่อรับ tar cfp - /some/dir | บีบอัด -c | nc -w 3 1234 // เพื่อส่ง
ตัวเลือกอื่นๆ นั้นง่ายกว่าอีก ดังนั้นเราจะไม่พิจารณาใช้ wget, FTP และวิธีการอื่นๆ ที่รู้จักกันดี
ซ่อนหา
โอเค เราหาวิธีส่งมันได้แล้ว แต่คุณจะหลีกเลี่ยงการถูกไฟไหม้ได้อย่างไร? หากค้นพบช่องโหว่ของคุณ มั่นใจได้ว่าช่องโหว่จะถูกปิดอย่างรวดเร็ว ดังนั้นคุณต้องโฮสต์ คอมไพล์ และรันมันจากที่ที่ไม่เด่นสะดุดตา ใน Linux ไดเร็กทอรีที่ขึ้นต้นด้วยจุด (เช่น .secret_folder) จะถูกซ่อนไว้ ดังนั้นจึงสมเหตุสมผลที่จะใช้พวกมันเพื่อซ่อนกิจกรรมของพวกเขา ตัวอย่างเช่น ใส่โค้ดช่องโหว่ลงไป: /tmp/.nothingthere/exploit.c อย่างไรก็ตาม ในกรณีนี้ คุณต้องตรวจสอบให้แน่ใจก่อนว่า tmp ถูกเมาท์โดยไม่มีตัวเลือก noexec และคุณสามารถเรียกใช้ช่องโหว่ที่ประกอบเข้าด้วยกันได้ (ในการดำเนินการนี้ ให้ใช้คำสั่ง mount)
การสร้างและดำเนินการหาประโยชน์
เมื่อเราส่งมอบและวาง Sploit แล้ว มันจะต้องประกอบ/กำหนดค่า ตามกฎแล้วการหาประโยชน์จะถูกเขียนด้วยภาษา C หรือภาษาสคริปต์ Python/Perl/PHP ภาษาใดภาษาหนึ่ง ผู้อ่านทั่วไป ][ รู้ว่าการทิ้งคอมไพเลอร์ไว้บนเซิร์ฟเวอร์ของคุณนั้นไม่ใช่วิธีที่ดีที่สุด ทางออกที่ดีที่สุดดังนั้นจึงมักจะถูกตัดออก หากคุณมีคำถามเกี่ยวกับเวอร์ชัน คอมไพเลอร์ gcc-v bash จะสาบานว่า gcc: command not found ซึ่งหมายความว่าคุณ "โชคดี" และจะต้องดำเนินการต่อไป นั่นคือ ค้นหาสเปรดชีตใน Python, Perl หรืออย่างอื่น หรือคอมไพล์ในนั้น เครื่องเสมือนด้วยระบบปฏิบัติการและเวอร์ชันเคอร์เนลที่คล้ายกัน จากนั้นย้ายไฟล์ปฏิบัติการที่เป็นผลลัพธ์ไปยังโฮสต์เป้าหมาย (อย่างไรก็ตาม วิธีการนี้ไม่รับประกันการทำงาน 100% การใช้ประโยชน์อาจล้มเหลวและทำให้ระบบเสียหาย ดังนั้น โปรดใช้ความระมัดระวังที่นี่) อย่างไรก็ตาม ตามที่แสดงในทางปฏิบัติ ต้องมีล่ามสำหรับภาษาใดภาษาหนึ่งที่กล่าวถึงไว้ในระบบ ดังนั้นคุณไม่ควรยอมแพ้ทันที มาตรวจสอบตัวเลือกทั้งหมดกันดีกว่า:
ค้นหา / -name perl* find / -name python* find / -name gcc* find / -name cc
หากประสบความสำเร็จ สิ่งที่คุณต้องทำคือเรียกใช้ช่องโหว่ที่คอมไพล์แล้วและเพลิดเพลินกับโปรโมชัน หรือคิดออกว่าทำไมมันถึงใช้งานไม่ได้ทั้งนี้ขึ้นอยู่กับโชคของคุณ
การตอบโต้การแตกแยก
เป็นการยากที่จะคิดสูตรใหม่ๆ ที่นี่ ทุกอย่างรู้มานานแล้ว คุณเพียงแค่ต้องติดตั้งแพตช์ให้ตรงเวลา นี่เป็นครั้งแรก ประการที่สองคือการ จำกัด ตำแหน่งที่สามารถเรียกใช้ไฟล์ได้ (โฟลเดอร์ tmp ควรจะปราศจากความสามารถนี้อย่างแน่นอน) เลยสมัครบ้าง โซลูชันด้านความปลอดภัยเช่น ความปลอดภัยสูง
สิทธิ์ ไฟล์ เส้นทาง และการกำหนดค่า
หมวดหมู่ที่สองที่สามารถแยกแยะความแตกต่างในการเพิ่มสิทธิ์คือวิธีการที่ไม่เกี่ยวข้องกับการใช้ช่องโหว่ แต่ขึ้นอยู่กับการค้นหาไฟล์ที่มีสิทธิ์ที่ตั้งค่าไม่ถูกต้อง เช่นเดียวกับในกรณีของ Windows มีลูกเล่นบางอย่าง แต่โดยพื้นฐานแล้วมันยังคงเป็นงานเดียวกันในการรวบรวมและวิเคราะห์ข้อมูล โดยปกติแล้ว สิ่งแรกที่ต้องมองหาคือไฟล์ที่ทุกคนสามารถอ่านและเขียนได้:
ค้นหา / - ดัดผม 2 ! -พิมพ์ l -ls
สิ่งเหล่านี้อาจจะเพียงพอแล้ว จำนวนมากและในหมู่พวกเขาคุณจะพบสิ่งที่น่าสนใจ: ไฟล์การกำหนดค่า, แหล่งที่มาของไซต์/แอปพลิเคชัน, สคริปต์ที่เรียกใช้โดย init หรือ cron โดยหลักการแล้ว สถานการณ์ที่ทุกคนสามารถอ่านและเขียนไฟล์ได้ถือเป็นเรื่องปกติ ปัญหาเกิดขึ้นเมื่อผู้ใช้/ผู้ดูแลระบบ/สคริปต์เริ่มเปลี่ยนแปลงการอนุญาตโดยไม่ได้ตั้งใจ ดังนั้นเมื่อคุณเปลี่ยนการอนุญาต ให้พยายามหลีกเลี่ยง ใช้ chmod 777. ดำเนินการตรวจสอบเป็นระยะเพื่อ ไฟล์สำคัญไม่สามารถใช้ได้กับทุกคน
เซตุอิด + เซทกิด
ตามที่ระบุไว้ในเอกสารประกอบ setuid และ setgid เป็นแฟล็กการอนุญาตที่อนุญาตให้รันไฟล์เรียกทำงานด้วยสิทธิ์ของเจ้าของหรือกลุ่มของไฟล์เรียกทำงาน (โดยปกติคือรูท) ไฟล์ปฏิบัติการดังกล่าว เมื่อทำงานด้วยสิทธิ์ระดับสูง จะสามารถเข้าถึงข้อมูลที่มีสิทธิพิเศษมากขึ้นได้ ตัวอย่างเช่น หากคุณตั้งค่า setuid เป็นคำสั่ง ls คุณจะสามารถดูเนื้อหาของไดเร็กทอรีที่คุณถูกปฏิเสธการเข้าถึงในตอนแรก และในกรณีของ vim ฉันสามารถแก้ไขไฟล์การกำหนดค่าที่ฉันไม่เคยมีสิทธิ์ตรวจสอบมาก่อน
ดังนั้น หากแอปพลิเคชันที่มีชุดแฟล็ก setuid/setgid มีช่องโหว่ เช่น บัฟเฟอร์ล้นหรือการฉีดคำสั่ง ผู้โจมตีสามารถรันโค้ดที่กำหนดเองด้วยสิทธิ์ระดับสูงได้ ดังนั้นตัวเลือกถัดไปมักจะค้นหาไฟล์ปฏิบัติการที่มีแฟล็กเหล่านี้
sudo find / -xdev \(-perm 4000\) - พิมพ์ f -print0 -exec ls -s () \;
โดยหลักการแล้ว คุณสามารถทำได้โดยไม่ต้องใช้ sudo ซึ่งจำเป็นสำหรับการตรวจสอบไดเร็กทอรีที่คุณไม่สามารถเข้าถึงได้เท่านั้น
โดยปกติจะมีสามตัวเลือกสำหรับการใช้งานดังกล่าวต่อไป ไฟล์ปฏิบัติการ- ประการแรกคือการพยายามเพิ่มสิทธิพิเศษตามฟังก์ชันการทำงานของแอปพลิเคชันนี้ (หรือคิดหาวิธีใช้ฟังก์ชันนี้ในลักษณะที่ผิดปกติของคุณเอง) ตัวเลือกที่สองคือการหาประโยชน์สาธารณะหรือดำเนินการคลุมเครืออย่างอิสระเพื่อระบุจุดบกพร่อง ประการที่สามคือการฉีดคำสั่ง ไม่มีสูตรสากล ทุกอย่างขึ้นอยู่กับสถานการณ์
ซูโดะ
คำสั่ง sudo (ทดแทน) ผู้ใช้และทำ) ซึ่งหมายถึง "แทนที่ผู้ใช้และดำเนินการ" อย่างแท้จริง ช่วยให้คุณสามารถมอบหมายทรัพยากรที่ได้รับสิทธิพิเศษบางอย่างให้กับผู้ใช้ในขณะที่ยังคงรักษาบันทึกของงานไว้ นั่นคือให้ผู้ใช้สามารถดำเนินการคำสั่งในฐานะรูท (หรือผู้ใช้รายอื่น) ได้โดยใช้ รหัสผ่านของตัวเองไม่ใช่รหัสผ่านรูท กฎสำหรับการตัดสินใจในการเข้าถึงอยู่ในไฟล์ /etc/sudoers รายละเอียดเพิ่มเติมเกี่ยวกับรูปแบบของไฟล์นี้และการตั้งค่ากฎสามารถพบได้ในคู่มืออย่างเป็นทางการหรือ Wikipedia ฉันจะบอกว่าไฟล์นี้ต้องได้รับการตรวจสอบอย่างรอบคอบด้วย เนื่องจากมักเกิดขึ้นที่แอปพลิเคชันบางตัวเปลี่ยนแปลงระหว่างการติดตั้งและยิ่งกว่านั้นไม่ใช่ใน ด้านที่ดีกว่า- เป็นผลให้ผู้ใช้มีโอกาสเพิ่มสิทธิพิเศษ (โพสต์เกี่ยวกับการรักษาความปลอดภัยที่น่ารังเกียจที่บอกเกี่ยวกับกรณีดังกล่าว)
เส้นทาง
เช่นเดียวกับ Windows เส้นทางที่กำหนดค่าไม่ถูกต้องใน Linux จะช่วยเพิ่มสิทธิพิเศษของคุณด้วย สิ่งนี้มักจะเกิดขึ้นกับตัวแปรสภาพแวดล้อม PATH (ใช้ printenv เพื่อดู) คุณได้ดู? เยี่ยมมาก บอกฉันหน่อยว่า จะเกิดอะไรขึ้นถ้าตัวแปรสภาพแวดล้อม PATH เริ่มต้นด้วย (.:/bin:/usr/sbin ....)? โดยปกติจะทำโดยผู้ใช้ที่ไม่ต้องการพิมพ์อักขระพิเศษสองตัวนั่นคือพวกเขาต้องการเรียกคำสั่งดังนี้: $ program แทน $ ./program ส่วนที่เพิ่มเข้าไป. ใน PATH หมายถึงความสามารถในการรันไฟล์/สคริปต์จากไดเร็กทอรีการทำงาน คุณสามารถเพิ่มได้ดังนี้:
PATH=.:$(PATH) ส่งออก PATH
ลองจินตนาการถึงสถานการณ์ที่เรามีผู้ใช้สองคน: โจ (ฝ่ายรุก) และบ็อบ โจรู้ว่าบ็อบมีสิทธิ์ sudo ในการเปลี่ยนรหัสผ่านผู้ใช้ รวมถึงรูทด้วย นอกจากนี้บ๊อบยังขี้เกียจและเสริมว่า ไปยังตัวแปรสภาพแวดล้อม PATH Wile Joe เขียนโปรแกรมที่จะเปลี่ยนรหัสผ่านรูท เรียกมันว่า ls แล้วนำไปไว้ในโฟลเดอร์ที่ Bob ชอบดู ตอนนี้เมื่ออันหลังเข้าไปในโฟลเดอร์และต้องการดูเนื้อหา โปรแกรมที่ Joe เขียนจะถูกดำเนินการและรหัสผ่านรูทจะถูกเปลี่ยน ดังนั้นเราจึงตรวจสอบตัวแปรสภาพแวดล้อมเพื่อดูสิ่งที่น่าสนใจอยู่เสมอและสำหรับตัวเราเองเราได้ข้อสรุปดังต่อไปนี้:
เครื่องมือ
เพื่อทำการค้นหาอัตโนมัติ จุดอ่อนคุณสามารถใช้เครื่องมือต่อไปนี้:
1. LinEnum เป็นสคริปต์ทุบตีที่จะทำงานสกปรกทั้งหมดให้กับคุณ โดยดำเนินการตรวจสอบทั้งหมดที่อธิบายไว้ในสูตรโกงนี้ โดยรวมแล้วมีประมาณ 65 คนในคลังแสงของเขา เช็คต่างๆเริ่มต้นจากการได้รับข้อมูลเกี่ยวกับเวอร์ชันเคอร์เนลและสิ้นสุดด้วยการค้นหาไฟล์ SUID/GUID ที่น่าสนใจ นอกจากนี้คุณสามารถส่งสคริปต์ได้ คำหลักซึ่งจะค้นหาในไฟล์การกำหนดค่าและบันทึกทั้งหมด การตรวจสอบเริ่มต้นดังนี้: ./LinEnum.sh -k keyword -r report -e /tmp/ -t หลังจากการสแกนเสร็จสิ้น คุณจะเห็นรายงานที่มีรายละเอียดพอสมควร ส่วนที่น่าสนใจที่สุดจะถูกเน้นด้วยสีเหลือง
2. LinuxPrivChecker - สคริปต์ Python ที่มีประโยชน์ในการค้นหาตัวเลือกที่เป็นไปได้สำหรับการเพิ่มสิทธิ์ โดยทั่วไปแล้วมันจะทำสิ่งมาตรฐานเดียวกันทั้งหมด: การตรวจสอบสิทธิ์, รับข้อมูลเกี่ยวกับระบบ... แต่คุณสมบัติหลักของมันคือหลังจากการตรวจสอบเสร็จสิ้น มันจะเสนอรายการการหาประโยชน์ให้คุณซึ่งตามความเห็นของมัน จะช่วยได้ ยกระดับสิทธิพิเศษ เป็นคนดีจังเลย :).
3. unix-privesc-ตรวจสอบ - สคริปต์นี้ช่วยให้คุณค้นหาตัวเลือกในการยกระดับสิทธิพิเศษไม่เพียงแต่ใน Linux แต่ยังรวมถึงใน Solaris, HPUX, FreeBSD มันพยายามตรวจจับข้อผิดพลาดในการกำหนดค่าที่จะทำให้ผู้ใช้ที่ไม่มีสิทธิ์เพิ่มขึ้นในระบบ
4. บล็อกของ g0tmi1k - และนี่คือบล็อกที่มีการอธิบายการตรวจสอบทั้งหมดที่ดำเนินการโดยเครื่องมือทั้งสามที่มีชื่อไว้อย่างดี ดังนั้นฉันขอแนะนำอย่างยิ่งให้คุณดูที่นั่นและทำความคุ้นเคยกับมันเพื่อที่คุณจะได้จินตนาการว่าเครื่องมือเหล่านี้ทำงานจากภายในอย่างไร
LinuxPrivChecker ประกอบด้วย รายการใหญ่ Exploit ซึ่งได้รับการอัพเดตอย่างต่อเนื่องจากฐานข้อมูล Exploit คำหลัง
อย่างที่คุณเห็นในโลก Linux การเพิ่มสิทธิพิเศษก็เป็นเรื่องปกติเช่นกัน เคล็ดลับแห่งความสำเร็จนั้นเรียบง่าย: เพื่อให้บรรลุเป้าหมาย คุณต้องอดทนและรู้ว่าจะต้องมองหาที่ไหนและควรมองหาอะไร จะดูจากที่ใด ตอนนี้คุณรู้แล้วว่ายูทิลิตี้ใดที่จะใช้สำหรับระบบอัตโนมัติเช่นกัน ดังนั้นตอนนี้คุณจึงสามารถพิชิตได้ไม่เพียงแต่ระบบ win-system เท่านั้น แต่ยังรวมถึงระบบ nix อีกด้วย ไปเลย!
