🥇BPF ສໍາລັບເດັກນ້ອຍ, part zero: classic BPF

Berkeley Packet Filters (BPF) ເປັນເທກໂນໂລຍີ kernel Linux ທີ່ໄດ້ຢູ່ໃນຫນ້າດ້ານຫນ້າຂອງສິ່ງພິມເຕັກໂນໂລຢີພາສາອັງກິດສໍາລັບເວລາຫຼາຍປີແລ້ວ. ກອງປະຊຸມແມ່ນເຕັມໄປດ້ວຍບົດລາຍງານກ່ຽວກັບການນໍາໃຊ້ແລະການພັດທະນາ BPF. David Miller, ຜູ້ຮັກສາລະບົບຍ່ອຍເຄືອຂ່າຍ Linux, ໂທຫາການສົນທະນາຂອງລາວຢູ່ທີ່ Linux Plumbers 2018 "ການສົນທະນານີ້ບໍ່ແມ່ນກ່ຽວກັບ XDP" (XDP ແມ່ນກໍລະນີການນໍາໃຊ້ຫນຶ່ງສໍາລັບ BPF). Brendan Gregg ໃຫ້ການເຈລະຈາທີ່ມີສິດ Linux BPF Superpowers. Toke Høiland-Jørgensen ຫົວວ່າ kernel ໃນປັດຈຸບັນເປັນ microkernel. Thomas Graf ສົ່ງເສີມຄວາມຄິດທີ່ວ່າ BPF ແມ່ນ javascript ສໍາລັບ kernel.

ຍັງບໍ່ທັນມີລາຍລະອຽດທີ່ເປັນລະບົບຂອງ BPF ໃນHabré, ແລະດັ່ງນັ້ນໃນຊຸດຂອງບົດຄວາມຂ້າພະເຈົ້າຈະພະຍາຍາມເວົ້າກ່ຽວກັບປະຫວັດສາດຂອງເຕັກໂນໂລຢີ, ອະທິບາຍກ່ຽວກັບສະຖາປັດຕະຍະກໍາແລະເຄື່ອງມືການພັດທະນາ, ແລະກໍານົດຂອບເຂດຂອງການນໍາໃຊ້ແລະການປະຕິບັດການນໍາໃຊ້ BPF. ບົດຂຽນນີ້, ສູນ, ໃນຊຸດ, ບອກປະຫວັດສາດແລະສະຖາປັດຕະຍະກໍາຂອງ BPF ຄລາສສິກ, ແລະຍັງເປີດເຜີຍຄວາມລັບຂອງຫຼັກການການດໍາເນີນງານຂອງມັນ. tcpdump, seccomp, strace, ແລະອື່ນໆອີກ.

ການພັດທະນາ BPF ແມ່ນຄວບຄຸມໂດຍຊຸມຊົນເຄືອຂ່າຍ Linux, ຄໍາຮ້ອງສະຫມັກທີ່ມີຢູ່ຕົ້ນຕໍຂອງ BPF ແມ່ນກ່ຽວຂ້ອງກັບເຄືອຂ່າຍແລະດັ່ງນັ້ນ, ໄດ້ຮັບການອະນຸຍາດ. @eucariot, ຂ້າພະເຈົ້າໄດ້ເອີ້ນຊຸດ "BPF ສໍາລັບເດັກນ້ອຍ", ເພື່ອກຽດສັກສີຂອງຊຸດທີ່ຍິ່ງໃຫຍ່ "ເຄືອຂ່າຍສໍາລັບເດັກນ້ອຍ".

ຫຼັກສູດໄລຍະສັ້ນໃນປະຫວັດສາດຂອງ BPF (c)

ເຕັກໂນໂລຢີ BPF ທີ່ທັນສະໄຫມແມ່ນການປັບປຸງແລະຂະຫຍາຍຂອງເຕັກໂນໂລຢີເກົ່າທີ່ມີຊື່ດຽວກັນ, ໃນປັດຈຸບັນເອີ້ນວ່າ BPF ຄລາສສິກເພື່ອຫຼີກເວັ້ນການສັບສົນ. ຜົນປະໂຫຍດທີ່ມີຊື່ສຽງໄດ້ຖືກສ້າງຂື້ນໂດຍອີງໃສ່ BPF ຄລາສສິກ tcpdump, ກົນໄກ seccomp, ເຊັ່ນດຽວກັນກັບໂມດູນທີ່ຮູ້ຈັກຫນ້ອຍ xt_bpf ການ iptables ແລະການຈັດປະເພດ cls_bpf. ໃນ Linux ທີ່ທັນສະໄຫມ, ໂຄງການ BPF ຄລາສສິກຖືກແປໂດຍອັດຕະໂນມັດໃນຮູບແບບໃຫມ່, ຢ່າງໃດກໍຕາມ, ຈາກທັດສະນະຂອງຜູ້ໃຊ້, API ຍັງຄົງຢູ່ໃນສະຖານທີ່ແລະການນໍາໃຊ້ໃຫມ່ສໍາລັບ BPF ຄລາສສິກ, ດັ່ງທີ່ພວກເຮົາຈະເຫັນໃນບົດຄວາມນີ້, ຍັງຖືກພົບເຫັນ. ສໍາລັບເຫດຜົນນີ້, ແລະຍ້ອນວ່າປະຕິບັດຕາມປະຫວັດສາດຂອງການພັດທະນາ BPF ຄລາສສິກໃນ Linux, ມັນຈະກາຍເປັນທີ່ຊັດເຈນກວ່າວິທີການແລະເຫດຜົນທີ່ມັນພັດທະນາໄປສູ່ຮູບແບບທີ່ທັນສະໄຫມ, ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈເລີ່ມຕົ້ນດ້ວຍບົດຄວາມກ່ຽວກັບ BPF ຄລາສສິກ.

ໃນຕອນທ້າຍຂອງແປດສິບຂອງສະຕະວັດທີ່ຜ່ານມາ, ວິສະວະກອນຈາກຫ້ອງທົດລອງ Lawrence Berkeley ທີ່ມີຊື່ສຽງໄດ້ມີຄວາມສົນໃຈໃນຄໍາຖາມກ່ຽວກັບວິທີການກັ່ນຕອງແພັກເກັດເຄືອຂ່າຍຢ່າງຖືກຕ້ອງກ່ຽວກັບຮາດແວທີ່ທັນສະໄຫມໃນທ້າຍສະຕະວັດທີ່ແປດສິບຂອງສະຕະວັດທີ່ຜ່ານມາ. ແນວຄວາມຄິດພື້ນຖານຂອງການກັ່ນຕອງ, ໃນເບື້ອງຕົ້ນໄດ້ຖືກປະຕິບັດໃນເຕັກໂນໂລຢີ CSPF (CMU / Stanford Packet Filter), ແມ່ນການກັ່ນຕອງແພັກເກັດທີ່ບໍ່ຈໍາເປັນໄວເທົ່າທີ່ຈະໄວໄດ້, i.e. ໃນພື້ນທີ່ kernel, ເນື່ອງຈາກວ່ານີ້ຫຼີກເວັ້ນການຄັດລອກຂໍ້ມູນທີ່ບໍ່ຈໍາເປັນເຂົ້າໄປໃນພື້ນທີ່ຜູ້ໃຊ້. ເພື່ອສະຫນອງຄວາມປອດໄພ runtime ສໍາລັບການແລ່ນລະຫັດຜູ້ໃຊ້ຢູ່ໃນພື້ນທີ່ແກ່ນ, ເຄື່ອງຈັກ virtual sandboxed ໄດ້ຖືກນໍາໃຊ້.

ຢ່າງໃດກໍຕາມ, ເຄື່ອງຈັກ virtual ສໍາລັບການກັ່ນຕອງທີ່ມີຢູ່ແລ້ວໄດ້ຖືກອອກແບບເພື່ອດໍາເນີນການໃນເຄື່ອງຈັກ stack-based ແລະບໍ່ໄດ້ດໍາເນີນການຢ່າງມີປະສິດທິພາບໃນເຄື່ອງ RISC ຮຸ່ນໃຫມ່. ດັ່ງນັ້ນ, ໂດຍຜ່ານຄວາມພະຍາຍາມຂອງວິສະວະກອນຈາກ Berkeley Labs, ເຕັກໂນໂລຢີ BPF (Berkeley Packet Filters) ໃຫມ່ໄດ້ຖືກພັດທະນາ, ສະຖາປັດຕະຍະກໍາ virtual ຂອງເຄື່ອງຈັກທີ່ຖືກອອກແບບໂດຍອີງໃສ່ໂປເຊດເຊີ Motorola 6502 - workhorse ຂອງຜະລິດຕະພັນທີ່ມີຊື່ສຽງເຊັ່ນ: Apple II ຫຼື NES. ເຄື່ອງ virtual ໃຫມ່ໄດ້ເພີ່ມປະສິດທິພາບການກັ່ນຕອງຫຼາຍສິບເທື່ອເມື່ອທຽບກັບການແກ້ໄຂທີ່ມີຢູ່.

ສະຖາປັດຕະຍະກໍາເຄື່ອງ BPF

ພວກເຮົາຈະໄດ້ຮູ້ຈັກກັບສະຖາປັດຕະໃນວິທີການເຮັດວຽກ, ການວິເຄາະຕົວຢ່າງ. ຢ່າງໃດກໍຕາມ, ເພື່ອເລີ່ມຕົ້ນດ້ວຍ, ໃຫ້ເວົ້າວ່າເຄື່ອງຈັກມີສອງທະບຽນ 32-bit ທີ່ສາມາດເຂົ້າເຖິງຜູ້ໃຊ້ໄດ້, ເຄື່ອງສະສົມ. A ແລະທະບຽນດັດສະນີ X, 64 bytes ຂອງຫນ່ວຍຄວາມຈໍາ (16 ຄໍາ), ມີສໍາລັບການຂຽນແລະການອ່ານຕໍ່ມາ, ແລະລະບົບຂະຫນາດນ້ອຍຂອງຄໍາສັ່ງສໍາລັບການເຮັດວຽກກັບວັດຖຸເຫຼົ່ານີ້. ຄໍາແນະນໍາການໂດດສໍາລັບການປະຕິບັດການສະແດງອອກຕາມເງື່ອນໄຂກໍ່ມີຢູ່ໃນໂຄງການ, ແຕ່ເພື່ອຮັບປະກັນການສໍາເລັດຕາມເວລາຂອງໂຄງການ, ການກະໂດດພຽງແຕ່ສາມາດກ້າວໄປຂ້າງຫນ້າ, i.e. ໂດຍສະເພາະ, ມັນຖືກຫ້າມບໍ່ໃຫ້ສ້າງ loops.

ໂຄງການທົ່ວໄປສໍາລັບການເລີ່ມຕົ້ນເຄື່ອງແມ່ນດັ່ງຕໍ່ໄປນີ້. ຜູ້ໃຊ້ສ້າງໂຄງການສໍາລັບສະຖາປັດຕະຍະກໍາ BPF ແລະ, ການນໍາໃຊ້ ບາງ ກົນໄກ kernel (ເຊັ່ນ: ການໂທຫາລະບົບ), ໂຫຼດແລະເຊື່ອມຕໍ່ໂຄງການກັບ ກັບບາງ ໄປຫາຕົວສ້າງເຫດການໃນ kernel (ຕົວຢ່າງ, ເຫດການແມ່ນການມາຮອດຂອງແພັກເກັດຕໍ່ໄປໃນບັດເຄືອຂ່າຍ). ເມື່ອເຫດການເກີດຂຶ້ນ, kernel ດໍາເນີນໂຄງການ (ຕົວຢ່າງ, ໃນຕົວແປ), ແລະຫນ່ວຍຄວາມຈໍາຂອງເຄື່ອງຈັກຈະກົງກັບ. ກັບບາງ ພາກພື້ນຫນ່ວຍຄວາມຈໍາ kernel (ຕົວຢ່າງ, ຂໍ້ມູນຂອງແພັກເກັດທີ່ເຂົ້າມາ).

ຂ້າງເທິງຈະພຽງພໍສໍາລັບພວກເຮົາທີ່ຈະເລີ່ມຕົ້ນເບິ່ງຕົວຢ່າງ: ພວກເຮົາຈະຮູ້ຈັກກັບລະບົບແລະຮູບແບບຄໍາສັ່ງຕາມຄວາມຈໍາເປັນ. ຖ້າທ່ານຕ້ອງການສຶກສາລະບົບຄໍາສັ່ງຂອງເຄື່ອງ virtual ທັນທີແລະຮຽນຮູ້ກ່ຽວກັບຄວາມສາມາດຂອງມັນທັງຫມົດ, ຫຼັງຈາກນັ້ນທ່ານສາມາດອ່ານບົດຄວາມຕົ້ນສະບັບ. BSD Packet Filter ແລະ/ຫຼືເຄິ່ງທຳອິດຂອງໄຟລ໌ Documentation/networking/filter.txt ຈາກເອກະສານ kernel. ນອກຈາກນັ້ນ, ທ່ານສາມາດສຶກສາການນໍາສະເຫນີ libpcap: ເປັນສະຖາປັດຕະຍະກໍາ ແລະວິທີການເພີ່ມປະສິດທິພາບສໍາລັບການຈັບແພັກເກັດ, ໃນທີ່ McCanne, ຫນຶ່ງໃນຜູ້ຂຽນຂອງ BPF, ເວົ້າກ່ຽວກັບປະຫວັດສາດຂອງການສ້າງ libpcap.

ພວກເຮົາສືບຕໍ່ພິຈາລະນາຕົວຢ່າງທີ່ສໍາຄັນທັງຫມົດຂອງການນໍາໃຊ້ BPF ຄລາສສິກໃນ Linux: tcpdump (libpcap), seccomp, xt_bpf, cls_bpf.

tcpdump

ການພັດທະນາຂອງ BPF ໄດ້ຖືກປະຕິບັດໃນຂະຫນານກັບການພັດທະນາຂອງ frontend ສໍາລັບການກັ່ນຕອງຊອງ - ຜົນປະໂຫຍດທີ່ມີຊື່ສຽງ. tcpdump. ແລະ, ເນື່ອງຈາກວ່ານີ້ແມ່ນຕົວຢ່າງທີ່ເກົ່າແກ່ທີ່ສຸດແລະມີຊື່ສຽງທີ່ສຸດຂອງການນໍາໃຊ້ BPF ຄລາສສິກ, ທີ່ມີຢູ່ໃນຫຼາຍໆລະບົບປະຕິບັດການ, ພວກເຮົາຈະເລີ່ມຕົ້ນການສຶກສາເຕັກໂນໂລຢີຂອງພວກເຮົາກັບມັນ.

(ຂ້າພະເຈົ້າໄດ້ແລ່ນຕົວຢ່າງທັງຫມົດໃນບົດຄວາມນີ້ກ່ຽວກັບ Linux 5.6.0-rc6. ຜົນໄດ້ຮັບຂອງບາງຄໍາສັ່ງໄດ້ຖືກດັດແກ້ເພື່ອໃຫ້ສາມາດອ່ານໄດ້ດີຂຶ້ນ.)

ຕົວຢ່າງ: ການສັງເກດແພັກເກັດ IPv6

ໃຫ້ຈິນຕະນາການວ່າພວກເຮົາຕ້ອງການເບິ່ງຊຸດ IPv6 ທັງຫມົດໃນການໂຕ້ຕອບ eth0. ເພື່ອເຮັດສິ່ງນີ້, ພວກເຮົາສາມາດດໍາເນີນການໂຄງການ tcpdump ດ້ວຍຕົວກອງທີ່ງ່າຍດາຍ ip6:

$ sudo tcpdump -i eth0 ip6

ດັ່ງນັ້ນຈຶ່ງ tcpdump ລວບລວມຕົວກອງ ip6 ເຂົ້າໄປໃນ bytecode ສະຖາປັດຕະ BPF ແລະສົ່ງມັນໄປຫາ kernel (ເບິ່ງລາຍລະອຽດໃນພາກ Tcpdump: ກຳລັງໂຫຼດ). ການກັ່ນຕອງທີ່ໂຫລດຈະຖືກດໍາເນີນການສໍາລັບທຸກໆແພັກເກັດທີ່ຜ່ານອິນເຕີເຟດ eth0. ຖ້າຕົວກອງສົ່ງຄືນຄ່າທີ່ບໍ່ແມ່ນສູນ n, ຫຼັງຈາກນັ້ນເຖິງ n bytes ຂອງແພັກເກັດຈະຖືກຄັດລອກໃສ່ພື້ນທີ່ຜູ້ໃຊ້ແລະພວກເຮົາຈະເຫັນມັນຢູ່ໃນຜົນຜະລິດ tcpdump.

ມັນ turns ໃຫ້ ເຫັນ ວ່າ ພວກ ເຮົາ ໄດ້ ຢ່າງ ງ່າຍ ດາຍ ສາ ມາດ ຊອກ ຫາ ທີ່ bytecode ຖືກ ສົ່ງ ໄປ ຫາ kernel tcpdump ດ້ວຍການຊ່ວຍເຫຼືອຂອງ tcpdump, ຖ້າພວກເຮົາດໍາເນີນການກັບທາງເລືອກ -d:

$ sudo tcpdump -i eth0 -d ip6
(000) ldh      [12]
(001) jeq      #0x86dd          jt 2    jf 3
(002) ret      #262144
(003) ret      #0

ໃນເສັ້ນສູນພວກເຮົາດໍາເນີນການຄໍາສັ່ງ ldh [12], ເຊິ່ງຫຍໍ້ມາຈາກ "ໂຫຼດເຂົ້າໃນການລົງທະບຽນ A ເຄິ່ງຫນຶ່ງຂອງຄໍາ (16 ບິດ) ທີ່ຢູ່ 12” ແລະຄໍາຖາມດຽວແມ່ນພວກເຮົາກໍານົດຄວາມຊົງຈໍາປະເພດໃດ? ຄໍາຕອບແມ່ນຢູ່ທີ່ x ເລີ່ມຕົ້ນ (x+1)th byte ຂອງແພັກເກັດເຄືອຂ່າຍວິເຄາະ. ພວກເຮົາອ່ານແພັກເກັດຈາກອິນເຕີເຟດອີເທີເນັດ eth0ແລະນີ້ ຫມາຍຄວາມວ່າpacket ເບິ່ງຄືວ່ານີ້ (ສໍາລັບຄວາມງ່າຍດາຍ, ພວກເຮົາສົມມຸດວ່າບໍ່ມີແທັກ VLAN ໃນແພັກເກັດ):

       6              6          2
|Destination MAC|Source MAC|Ether Type|...|

ດັ່ງນັ້ນຫຼັງຈາກປະຕິບັດຄໍາສັ່ງ ldh [12] ຢູ່ໃນທະບຽນ A ຈະມີພາກສະຫນາມ Ether Type — ປະເພດຂອງຊອງສົ່ງໃນກອບ Ethernet ນີ້. ໃນແຖວທີ 1 ພວກເຮົາປຽບທຽບເນື້ອໃນຂອງທະບຽນ A (ປະເພດຊຸດ) ຄ 0x86ddແລະນີ້ ແລະມີ ປະເພດທີ່ພວກເຮົາສົນໃຈແມ່ນ IPv6. ໃນແຖວທີ 1, ນອກເຫນືອຈາກຄໍາສັ່ງປຽບທຽບ, ຍັງມີສອງຖັນຕື່ມອີກ - jt 2 и jf 3 — ເຄື່ອງຫມາຍທີ່ທ່ານຈໍາເປັນຕ້ອງໄປຖ້າຫາກວ່າການປຽບທຽບສົບຜົນສໍາເລັດ (A == 0x86dd) ແລະບໍ່ສໍາເລັດ. ດັ່ງນັ້ນ, ໃນກໍລະນີທີ່ສໍາເລັດຜົນ (IPv6) ພວກເຮົາໄປແຖວ 2, ແລະໃນກໍລະນີທີ່ບໍ່ສໍາເລັດ - ໄປແຖວ 3. ໃນແຖວທີ 3 ໂປຣແກຣມສິ້ນສຸດລົງດ້ວຍລະຫັດ 0 (ຢ່າຄັດລອກແພັກເກັດ), ໃນແຖວທີ 2 ໂປຣແກຣມຈະສິ້ນສຸດດ້ວຍລະຫັດ. 262144 (ຄັດລອກຂ້ອຍສູງສຸດຂອງແພັກເກັດ 256 ກິໂລໄບ).

ຕົວຢ່າງທີ່ສັບສົນກວ່າ: ພວກເຮົາເບິ່ງແພັກເກັດ TCP ໂດຍພອດປາຍທາງ

ຂໍໃຫ້ເບິ່ງວ່າຕົວກອງມີລັກສະນະໃດທີ່ຄັດລອກຊຸດ TCP ທັງຫມົດທີ່ມີພອດປາຍທາງ 666. ພວກເຮົາຈະພິຈາລະນາກໍລະນີ IPv4, ເນື່ອງຈາກວ່າກໍລະນີ IPv6 ແມ່ນງ່າຍດາຍກວ່າ. ຫຼັງຈາກການສຶກສາຕົວຢ່າງນີ້, ທ່ານສາມາດຄົ້ນຫາຕົວກອງ IPv6 ຕົວທ່ານເອງເປັນການອອກກໍາລັງກາຍ (ip6 and tcp dst port 666) ແລະການກັ່ນຕອງສໍາລັບກໍລະນີທົ່ວໄປ (tcp dst port 666). ດັ່ງນັ້ນ, ການກັ່ນຕອງທີ່ພວກເຮົາສົນໃຈເບິ່ງຄືດັ່ງນີ້:

$ sudo tcpdump -i eth0 -d ip and tcp dst port 666
(000) ldh      [12]
(001) jeq      #0x800           jt 2    jf 10
(002) ldb      [23]
(003) jeq      #0x6             jt 4    jf 10
(004) ldh      [20]
(005) jset     #0x1fff          jt 10   jf 6
(006) ldxb     4*([14]&0xf)
(007) ldh      [x + 16]
(008) jeq      #0x29a           jt 9    jf 10
(009) ret      #262144
(010) ret      #0

ພວກເຮົາຮູ້ແລ້ວວ່າສາຍ 0 ແລະ 1 ເຮັດຫຍັງແດ່. ໃນແຖວທີ 2 ພວກເຮົາໄດ້ກວດເບິ່ງແລ້ວວ່ານີ້ແມ່ນຊຸດ IPv4 (Ether Type = 0x800) ແລະໂຫຼດມັນເຂົ້າໄປໃນການຈົດທະບຽນ A 24 byte ຂອງແພັກເກັດ. ຊຸດຂອງພວກເຮົາເບິ່ງຄືວ່າ

       14            8      1     1
|ethernet header|ip fields|ttl|protocol|...|

ຊຶ່ງຫມາຍຄວາມວ່າພວກເຮົາໂຫລດເຂົ້າໄປໃນທະບຽນ A ພາກສະຫນາມ Protocol ຂອງຫົວ IP, ທີ່ມີເຫດຜົນ, ເພາະວ່າພວກເຮົາຕ້ອງການຄັດລອກພຽງແຕ່ແພັກເກັດ TCP. ພວກເຮົາປຽບທຽບອະນຸສັນຍາກັບ 0x6 (IPPROTO_TCP) ໃນເສັ້ນ 3.

ໃນແຖວທີ 4 ແລະ 5 ພວກເຮົາໂຫລດ halfwords ທີ່ຕັ້ງຢູ່ທີ່ຢູ່ 20 ແລະໃຊ້ຄໍາສັ່ງ jset ກວດເບິ່ງວ່າຫນຶ່ງໃນສາມແມ່ນຖືກກໍານົດ ທຸງ - ໃສ່ໜ້າກາກອອກ jset ສາມ bits ທີ່ສໍາຄັນທີ່ສຸດແມ່ນໄດ້ຖືກເກັບກູ້. ສອງໃນສາມບິດບອກພວກເຮົາວ່າແພັກເກັດແມ່ນສ່ວນຫນຶ່ງຂອງຊຸດ IP ທີ່ແຕກແຍກ, ແລະຖ້າເປັນດັ່ງນັ້ນ, ບໍ່ວ່າຈະເປັນຊິ້ນສຸດທ້າຍ. ບິດທີສາມຖືກສະຫງວນໄວ້ ແລະຕ້ອງເປັນສູນ. ພວກເຮົາບໍ່ຕ້ອງການທີ່ຈະກວດສອບທັງຫມົດບໍ່ຄົບຖ້ວນຫຼືແຕກ, ດັ່ງນັ້ນພວກເຮົາກວດສອບທັງສາມ bits.

ແຖວທີ 6 ແມ່ນຫນ້າສົນໃຈທີ່ສຸດໃນບັນຊີລາຍຊື່ນີ້. ການສະແດງອອກ ldxb 4*([14]&0xf) ຫມາຍຄວາມວ່າພວກເຮົາໂຫລດເຂົ້າໄປໃນທະບຽນ X ສີ່ບິດທີ່ສຳຄັນໜ້ອຍສຸດຂອງສິບຫ້າໄບຕ໌ຂອງແພັກເກັດຄູນດ້ວຍ 4. ສີ່ບິດທີ່ສຳຄັນໜ້ອຍສຸດຂອງໄບສິບຫ້າແມ່ນຊ່ອງຂໍ້ມູນ ຄວາມຍາວສ່ວນຫົວອິນເຕີເນັດ IPv4 header, ເຊິ່ງເກັບຮັກສາຄວາມຍາວຂອງ header ໃນຄໍາສັບຕ່າງໆ, ດັ່ງນັ້ນທ່ານຈໍາເປັນຕ້ອງຄູນດ້ວຍ 4. ຫນ້າສົນໃຈ, ການສະແດງອອກ. 4*([14]&0xf) ແມ່ນການກໍານົດສໍາລັບໂຄງການທີ່ຢູ່ພິເສດທີ່ສາມາດນໍາໃຊ້ໄດ້ໃນຮູບແບບນີ້ແລະພຽງແຕ່ສໍາລັບການລົງທະບຽນ X, i.e. ພວກເຮົາບໍ່ສາມາດເວົ້າໄດ້ ldb 4*([14]&0xf) neither ldxb 5*([14]&0xf) (ພວກເຮົາພຽງແຕ່ສາມາດກໍານົດການຊົດເຊີຍທີ່ແຕກຕ່າງກັນ, ສໍາລັບການຍົກຕົວຢ່າງ, ldxb 4*([16]&0xf)). ມັນເປັນທີ່ຊັດເຈນວ່າໂຄງການທີ່ຢູ່ນີ້ຖືກເພີ່ມໃສ່ BPF ຢ່າງແນ່ນອນເພື່ອຈະໄດ້ຮັບ X (ລົງທະບຽນດັດສະນີ) ຄວາມຍາວສ່ວນຫົວ IPv4.

ດັ່ງນັ້ນໃນແຖວທີ 7 ພວກເຮົາພະຍາຍາມໂຫລດເຄິ່ງຫນຶ່ງຂອງຄໍາທີ່ (X+16). ຈື່ໄວ້ວ່າ 14 ໄບຕ໌ຖືກຄອບຄອງໂດຍຫົວອີເທີເນັດ, ແລະ X ມີຄວາມຍາວຂອງຫົວຂໍ້ IPv4, ພວກເຮົາເຂົ້າໃຈວ່າໃນ A ຜອດປາຍທາງ TCP ຖືກໂຫລດແລ້ວ:

       14           X           2             2
|ethernet header|ip header|source port|destination port|

ສຸດທ້າຍ, ໃນເສັ້ນ 8 ພວກເຮົາປຽບທຽບພອດປາຍທາງກັບຄ່າທີ່ຕ້ອງການແລະໃນສາຍ 9 ຫຼື 10 ພວກເຮົາສົ່ງຜົນໄດ້ຮັບ - ວ່າຈະຄັດລອກແພັກເກັດຫຼືບໍ່.

Tcpdump: ກຳລັງໂຫຼດ

ໃນຕົວຢ່າງທີ່ຜ່ານມາ, ພວກເຮົາໂດຍສະເພາະບໍ່ໄດ້ຢູ່ໃນລາຍລະອຽດຢ່າງແນ່ນອນວ່າພວກເຮົາໂຫລດ BPF bytecode ເຂົ້າໄປໃນ kernel ສໍາລັບການກັ່ນຕອງ packet. ເວົ້າໂດຍທົ່ວໄປ, tcpdump ported ກັບຫຼາຍລະບົບແລະສໍາລັບການເຮັດວຽກກັບການກັ່ນຕອງ tcpdump ໃຊ້ຫ້ອງສະຫມຸດ libpcap. ໂດຍຫຍໍ້, ເພື່ອວາງຕົວກອງໃນການໂຕ້ຕອບໂດຍໃຊ້ libpcap, ທ່ານຈໍາເປັນຕ້ອງເຮັດດັ່ງຕໍ່ໄປນີ້:

ສ້າງຕົວອະທິບາຍປະເພດ pcap_t ຈາກຊື່ການໂຕ້ຕອບ: pcap_create,
ກະຕຸ້ນການໂຕ້ຕອບ: pcap_activate,
ລວບລວມຕົວກອງ: pcap_compile,
ເຊື່ອມຕໍ່ຕົວກອງ: pcap_setfilter.

ເພື່ອເບິ່ງວິທີການປະຕິບັດຫນ້າ pcap_setfilter ປະຕິບັດໃນ Linux, ພວກເຮົາໃຊ້ strace (ບາງສາຍໄດ້ຖືກໂຍກຍ້າຍອອກ):

$ sudo strace -f -e trace=%network tcpdump -p -i eth0 ip
socket(AF_PACKET, SOCK_RAW, 768)        = 3
bind(3, {sa_family=AF_PACKET, sll_protocol=htons(ETH_P_ALL), sll_ifindex=if_nametoindex("eth0"), sll_hatype=ARPHRD_NETROM, sll_pkttype=PACKET_HOST, sll_halen=0}, 20) = 0
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=4, filter=0xb00bb00bb00b}, 16) = 0
...

ໃນສອງແຖວທໍາອິດຂອງຜົນຜະລິດທີ່ພວກເຮົາສ້າງ ເຕົ້າຮັບວັດຖຸດິບ ເພື່ອອ່ານທຸກເຟຣມ Ethernet ແລະຜູກມັດມັນໃສ່ໃນການໂຕ້ຕອບ eth0... ຂອງ ຕົວຢ່າງທໍາອິດຂອງພວກເຮົາ ພວກເຮົາຮູ້ວ່າການກັ່ນຕອງ ip ຈະປະກອບດ້ວຍສີ່ຄໍາແນະນໍາ BPF, ແລະໃນແຖວທີສາມພວກເຮົາເບິ່ງວິທີການນໍາໃຊ້ທາງເລືອກ SO_ATTACH_FILTER ໂທລະບົບ setsockopt ພວກເຮົາໂຫຼດແລະເຊື່ອມຕໍ່ຕົວກອງທີ່ມີຄວາມຍາວ 4. ນີ້ແມ່ນຕົວກອງຂອງພວກເຮົາ.

ມັນເປັນມູນຄ່າທີ່ສັງເກດວ່າໃນ BPF ຄລາສສິກ, ການໂຫຼດແລະເຊື່ອມຕໍ່ຕົວກອງສະເຫມີເກີດຂຶ້ນເປັນການປະຕິບັດປະລໍາມະນູ, ແລະໃນຮຸ່ນໃຫມ່ຂອງ BPF, ການໂຫຼດໂປລແກລມແລະການຜູກມັດມັນກັບເຄື່ອງກໍາເນີດເຫດການຖືກແຍກອອກຈາກເວລາ.

ຄວາມຈິງທີ່ເຊື່ອງໄວ້

ຮຸ່ນທີ່ສົມບູນກວ່າເລັກນ້ອຍຂອງຜົນຜະລິດເບິ່ງຄືວ່ານີ້:

$ sudo strace -f -e trace=%network tcpdump -p -i eth0 ip
socket(AF_PACKET, SOCK_RAW, 768)        = 3
bind(3, {sa_family=AF_PACKET, sll_protocol=htons(ETH_P_ALL), sll_ifindex=if_nametoindex("eth0"), sll_hatype=ARPHRD_NETROM, sll_pkttype=PACKET_HOST, sll_halen=0}, 20) = 0
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=1, filter=0xbeefbeefbeef}, 16) = 0
recvfrom(3, 0x7ffcad394257, 1, MSG_TRUNC, NULL, NULL) = -1 EAGAIN (Resource temporarily unavailable)
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, {len=4, filter=0xb00bb00bb00b}, 16) = 0
...

ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ພວກເຮົາໂຫລດແລະຄັດຕິດຕົວກອງຂອງພວກເຮົາກັບເຕົ້າຮັບໃນສາຍ 5, ແຕ່ສິ່ງທີ່ເກີດຂື້ນໃນສາຍ 3 ແລະ 4? ມັນ turns ໃຫ້ ເຫັນ ວ່າ ນີ້ libpcap ເບິ່ງແຍງພວກເຮົາ - ເພື່ອໃຫ້ຜົນຜະລິດຂອງການກັ່ນຕອງຂອງພວກເຮົາບໍ່ລວມເອົາຊຸດທີ່ບໍ່ພໍໃຈກັບມັນ, ຫ້ອງສະຫມຸດ ເຊື່ອມຕໍ່ ຕົວກອງ dummy ret #0 (ຖິ້ມແພັກເກັດທັງໝົດ), ສະຫຼັບຊັອກເກັດເປັນໂໝດບໍ່ປິດກັ້ນ ແລະພະຍາຍາມລົບແພັກເກັດທັງໝົດທີ່ສາມາດຄົງຢູ່ຈາກຕົວກອງກ່ອນໜ້າ.

ໃນຈໍານວນທັງຫມົດ, ເພື່ອການກັ່ນຕອງຊຸດໃນ Linux ໂດຍໃຊ້ BPF ຄລາສສິກ, ທ່ານຈໍາເປັນຕ້ອງມີການກັ່ນຕອງໃນຮູບແບບຂອງໂຄງສ້າງເຊັ່ນ: struct sock_fprog ແລະເຕົ້າສຽບເປີດ, ຫຼັງຈາກນັ້ນຕົວກອງສາມາດຕິດກັບເຕົ້າຮັບໂດຍໃຊ້ການໂທລະບົບ setsockopt.

ຫນ້າສົນໃຈ, ການກັ່ນຕອງສາມາດຕິດກັບເຕົ້າສຽບໃດໆ, ບໍ່ພຽງແຕ່ວັດຖຸດິບ. ທີ່ນີ້ ຕົວຢ່າງ ໂຄງການທີ່ຕັດອອກທັງຫມົດແຕ່ສອງ bytes ທໍາອິດຈາກຂໍ້ມູນ UDP ຂາເຂົ້າທັງຫມົດ. (ຂ້າພະເຈົ້າໄດ້ເພີ່ມຄໍາເຫັນໃນລະຫັດເພື່ອບໍ່ໃຫ້ clutter ບົດຄວາມ.)

ລາຍລະອຽດເພີ່ມເຕີມກ່ຽວກັບການນໍາໃຊ້ setsockopt ສໍາລັບການເຊື່ອມຕໍ່ຕົວກອງ, ເບິ່ງ ເຕົ້າສຽບ (7), ແຕ່ກ່ຽວກັບການຂຽນຕົວກອງຂອງທ່ານເອງເຊັ່ນ struct sock_fprog ໂດຍບໍ່ມີການຊ່ວຍເຫຼືອ tcpdump ພວກເຮົາຈະສົນທະນາໃນພາກ ການຂຽນໂປລແກລມ BPF ດ້ວຍມືຂອງພວກເຮົາເອງ.

BPF ຄລາສສິກແລະສະຕະວັດທີ 21st

BPF ໄດ້ລວມຢູ່ໃນ Linux ໃນປີ 1997 ແລະຍັງຄົງເປັນ workhorse ເປັນເວລາດົນ libpcap ໂດຍບໍ່ມີການປ່ຽນແປງພິເສດໃດໆ (ການປ່ຽນແປງສະເພາະ Linux, ແນ່ນອນ, ມັນແມ່ນ, ແຕ່ພວກເຂົາບໍ່ໄດ້ປ່ຽນແປງຮູບພາບທົ່ວໂລກ). ສັນຍານທີ່ຮ້າຍແຮງທໍາອິດທີ່ BPF ຈະພັດທະນາແມ່ນເກີດຂື້ນໃນປີ 2011, ເມື່ອ Eric Dumazet ສະເຫນີ. patch, ເຊິ່ງເພີ່ມ Just In Time Compiler ກັບ kernel - ຕົວແປສໍາລັບການປ່ຽນ BPF bytecode ເປັນ native x86_64 ລະຫັດ.

JIT compiler ແມ່ນຄັ້ງທໍາອິດໃນລະບົບຕ່ອງໂສ້ການປ່ຽນແປງ: ໃນປີ 2012 ປາກົດວ່າ ຄວາມສາມາດໃນການຂຽນຕົວກອງ seccomp, ການນໍາໃຊ້ BPF, ໃນເດືອນມັງກອນ 2013 ມີ ເພີ່ມ ໂມດູນ xt_bpf, ເຊິ່ງອະນຸຍາດໃຫ້ທ່ານຂຽນກົດລະບຽບສໍາລັບ iptables ດ້ວຍການຊ່ວຍເຫຼືອຂອງ BPF, ແລະໃນເດືອນຕຸລາ 2013 ແມ່ນ ເພີ່ມ ເປັນໂມດູນ cls_bpf, ເຊິ່ງອະນຸຍາດໃຫ້ທ່ານຂຽນການຈັດປະເພດການຈະລາຈອນໂດຍໃຊ້ BPF.

ພວກເຮົາຈະເບິ່ງຕົວຢ່າງທັງຫມົດເຫຼົ່ານີ້ໃນລາຍລະອຽດເພີ່ມເຕີມໃນໄວໆນີ້, ແຕ່ທໍາອິດມັນຈະເປັນປະໂຫຍດສໍາລັບພວກເຮົາທີ່ຈະຮຽນຮູ້ວິທີການຂຽນແລະລວບລວມບັນດາໂຄງການ arbitrary ສໍາລັບ BPF, ເນື່ອງຈາກວ່າຄວາມສາມາດສະຫນອງໃຫ້ໂດຍຫ້ອງສະຫມຸດ. libpcap ຈໍາກັດ (ຕົວຢ່າງງ່າຍໆ: ການກັ່ນຕອງທີ່ສ້າງຂຶ້ນ libpcap ສາມາດສົ່ງຄືນພຽງແຕ່ສອງຄ່າ - 0 ຫຼື 0x40000) ຫຼືໂດຍທົ່ວໄປ, ເຊັ່ນດຽວກັບກໍລະນີຂອງ seccomp, ແມ່ນບໍ່ສາມາດໃຊ້ໄດ້.

ການຂຽນໂປລແກລມ BPF ດ້ວຍມືຂອງພວກເຮົາເອງ

ໃຫ້ພວກເຮົາຮູ້ຈັກກັບຮູບແບບຄູ່ຂອງຄໍາແນະນໍາ BPF, ມັນງ່າຍດາຍຫຼາຍ:

   16    8    8     32
| code | jt | jf |  k  |

ແຕ່ລະຄໍາແນະນໍາຄອບຄອງ 64 ບິດ, ເຊິ່ງ 16 ບິດທໍາອິດແມ່ນລະຫັດຄໍາແນະນໍາ, ຫຼັງຈາກນັ້ນມີສອງຫຍໍ້ຫນ້າແປດບິດ, jt и jf, ແລະ 32 bits ສໍາລັບການໂຕ້ຖຽງ K, ຈຸດປະສົງທີ່ແຕກຕ່າງຈາກຄໍາສັ່ງໄປຫາຄໍາສັ່ງ. ສໍາລັບຕົວຢ່າງ, ຄໍາສັ່ງ ret, ເຊິ່ງສິ້ນສຸດໂຄງການມີລະຫັດ 6, ແລະຄ່າກັບຄືນແມ່ນເອົາມາຈາກຄ່າຄົງທີ່ K. ໃນ C, ຄໍາແນະນໍາ BPF ດຽວແມ່ນເປັນຕົວແທນເປັນໂຄງສ້າງ

struct sock_filter {
        __u16   code;
        __u8    jt;
        __u8    jf;
        __u32   k;
}

ແລະໂຄງການທັງຫມົດແມ່ນຢູ່ໃນຮູບແບບຂອງໂຄງສ້າງ

struct sock_fprog {
        unsigned short len;
        struct sock_filter *filter;
}

ດັ່ງນັ້ນ, ພວກເຮົາສາມາດຂຽນໂປຼແກຼມໄດ້ແລ້ວ (ຕົວຢ່າງ, ພວກເຮົາຮູ້ລະຫັດຄໍາແນະນໍາຈາກ [1]). ນີ້ແມ່ນສິ່ງທີ່ການກັ່ນຕອງຈະມີລັກສະນະ ip6 ຈາກນັ້ນ ຕົວຢ່າງທໍາອິດຂອງພວກເຮົາ:

struct sock_filter code[] = {
        { 0x28, 0, 0, 0x0000000c },
        { 0x15, 0, 1, 0x000086dd },
        { 0x06, 0, 0, 0x00040000 },
        { 0x06, 0, 0, 0x00000000 },
};
struct sock_fprog prog = {
        .len = ARRAY_SIZE(code),
        .filter = code,
};

ໂຄງການ prog ພວກເຮົາສາມາດນຳໃຊ້ຢ່າງຖືກກົດໝາຍໃນການໂທ

setsockopt(sk, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))

ການຂຽນໂປລແກລມໃນຮູບແບບຂອງລະຫັດເຄື່ອງຈັກແມ່ນບໍ່ສະດວກຫຼາຍ, ແຕ່ບາງຄັ້ງມັນເປັນສິ່ງຈໍາເປັນ (ຕົວຢ່າງເຊັ່ນ: ສໍາລັບ debugging, ການສ້າງການທົດສອບຫນ່ວຍງານ, ການຂຽນບົດຄວາມກ່ຽວກັບHabre, ແລະອື່ນໆ). ເພື່ອຄວາມສະດວກ, ໃນໄຟລ໌ <linux/filter.h> macro ຜູ້ຊ່ວຍແມ່ນຖືກກໍານົດ - ຕົວຢ່າງດຽວກັນກັບຂ້າງເທິງສາມາດຖືກຂຽນຄືນໃຫມ່ເປັນ

struct sock_filter code[] = {
        BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 12),
        BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ETH_P_IPV6, 0, 1),
        BPF_STMT(BPF_RET|BPF_K, 0x00040000),
        BPF_STMT(BPF_RET|BPF_K, 0),
}

ຢ່າງໃດກໍຕາມ, ທາງເລືອກນີ້ແມ່ນບໍ່ສະດວກຫຼາຍ. ນີ້ແມ່ນສິ່ງທີ່ນັກຂຽນໂປລແກລມ Linux kernel ສົມເຫດສົມຜົນ, ແລະດັ່ງນັ້ນຢູ່ໃນໄດເລກະທໍລີ tools/bpf kernels ທ່ານສາມາດຊອກຫາ assembler ແລະ debugger ສໍາລັບການເຮັດວຽກກັບຄລາສສິກ BPF.

ພາສາສະພາແຫ່ງແມ່ນຄ້າຍຄືກັນຫຼາຍກັບ debug output tcpdump, ແຕ່ນອກຈາກນັ້ນພວກເຮົາສາມາດລະບຸປ້າຍສັນຍາລັກ. ຕົວຢ່າງ, ນີ້ແມ່ນໂປຣແກຣມທີ່ຖິ້ມແພັກເກັດທັງໝົດຍົກເວັ້ນ TCP/IPv4:

$ cat /tmp/tcp-over-ipv4.bpf
ldh [12]
jne #0x800, drop
ldb [23]
jneq #6, drop
ret #-1
drop: ret #0

ໂດຍຄ່າເລີ່ມຕົ້ນ, ຕົວປະກອບສ້າງລະຫັດໃນຮູບແບບ <количество инструкций>,<code1> <jt1> <jf1> <k1>,..., ສໍາລັບຕົວຢ່າງຂອງພວກເຮົາກັບ TCP ມັນຈະເປັນ

$ tools/bpf/bpf_asm /tmp/tcp-over-ipv4.bpf
6,40 0 0 12,21 0 3 2048,48 0 0 23,21 0 1 6,6 0 0 4294967295,6 0 0 0,

ເພື່ອຄວາມສະດວກສະບາຍຂອງນັກຂຽນໂປລແກລມ C, ຮູບແບບຜົນຜະລິດທີ່ແຕກຕ່າງກັນສາມາດຖືກນໍາໃຊ້:

$ tools/bpf/bpf_asm -c /tmp/tcp-over-ipv4.bpf
{ 0x28,  0,  0, 0x0000000c },
{ 0x15,  0,  3, 0x00000800 },
{ 0x30,  0,  0, 0x00000017 },
{ 0x15,  0,  1, 0x00000006 },
{ 0x06,  0,  0, 0xffffffff },
{ 0x06,  0,  0, 0000000000 },

ຂໍ້ຄວາມນີ້ສາມາດຖືກຄັດລອກເຂົ້າໄປໃນຄໍານິຍາມໂຄງສ້າງປະເພດ struct sock_filterດັ່ງທີ່ພວກເຮົາໄດ້ເຮັດໃນຕອນຕົ້ນຂອງພາກນີ້.

ສ່ວນຂະຫຍາຍ Linux ແລະ netsniff-ng

ນອກເຫນືອໄປຈາກມາດຕະຖານ BPF, Linux ແລະ tools/bpf/bpf_asm ສະຫນັບສະຫນູນແລະ ຊຸດທີ່ບໍ່ໄດ້ມາດຕະຖານ. ໂດຍພື້ນຖານແລ້ວ, ຄໍາແນະນໍາແມ່ນຖືກນໍາໃຊ້ເພື່ອເຂົ້າເຖິງຂົງເຂດຂອງໂຄງສ້າງ struct sk_buff, ເຊິ່ງອະທິບາຍຊຸດເຄືອຂ່າຍໃນ kernel. ຢ່າງໃດກໍຕາມ, ຍັງມີຄໍາແນະນໍາຂອງຜູ້ຊ່ວຍປະເພດອື່ນໆ, ສໍາລັບການຍົກຕົວຢ່າງ ldw cpu ຈະໂຫລດເຂົ້າໄປໃນທະບຽນ A ຜົນໄດ້ຮັບຂອງການເຮັດວຽກຂອງ kernel raw_smp_processor_id(). (ໃນສະບັບໃຫມ່ຂອງ BPF, ການຂະຫຍາຍທີ່ບໍ່ແມ່ນມາດຕະຖານເຫຼົ່ານີ້ໄດ້ຖືກຂະຫຍາຍອອກເພື່ອໃຫ້ໂຄງການທີ່ມີຊຸດຂອງຕົວຊ່ວຍ kernel ສໍາລັບການເຂົ້າເຖິງຫນ່ວຍຄວາມຈໍາ, ໂຄງສ້າງ, ແລະການສ້າງເຫດການ.) ນີ້ແມ່ນຕົວຢ່າງທີ່ຫນ້າສົນໃຈຂອງຕົວກອງທີ່ພວກເຮົາຄັດລອກພຽງແຕ່ຕົວກອງ packet headers ເຂົ້າໄປໃນພື້ນທີ່ຜູ້ໃຊ້ໂດຍໃຊ້ສ່ວນຂະຫຍາຍ poff, ຄ່າຊົດເຊີຍ payload:

ld poff
ret a

ການຂະຫຍາຍ BPF ບໍ່ສາມາດໃຊ້ໃນ tcpdump, ແຕ່ນີ້ແມ່ນເຫດຜົນທີ່ດີທີ່ຈະຮູ້ຈັກກັບຊຸດຜົນປະໂຫຍດ netsniff-ng, ເຊິ່ງ, ໃນບັນດາສິ່ງອື່ນໆ, ປະກອບດ້ວຍໂຄງການຂັ້ນສູງ netsniff-ng, ເຊິ່ງ, ນອກເຫນືອຈາກການກັ່ນຕອງໂດຍໃຊ້ BPF, ຍັງມີເຄື່ອງກໍາເນີດການຈະລາຈອນທີ່ມີປະສິດທິພາບ, ແລະມີຄວາມກ້າວຫນ້າກວ່າ. tools/bpf/bpf_asm, ຜູ້ປະກອບ BPF ເອີ້ນວ່າ bpfc. ຊຸດປະກອບດ້ວຍເອກະສານທີ່ຂ້ອນຂ້າງລະອຽດ, ເບິ່ງການເຊື່ອມຕໍ່ໃນຕອນທ້າຍຂອງບົດຄວາມ.

seccomp

ດັ່ງນັ້ນ, ພວກເຮົາຮູ້ວິທີການຂຽນໂປຼແກຼມ BPF ຂອງຄວາມສັບສົນທີ່ຕົນເອງມັກແລະພ້ອມທີ່ຈະເບິ່ງຕົວຢ່າງໃຫມ່, ທໍາອິດແມ່ນເຕັກໂນໂລຢີ seccomp, ເຊິ່ງອະນຸຍາດໃຫ້, ການນໍາໃຊ້ຕົວກອງ BPF, ເພື່ອຈັດການຊຸດແລະຊຸດຂອງການໂຕ້ຖຽງການໂທລະບົບທີ່ມີຢູ່. ຂະບວນການທີ່ໄດ້ຮັບແລະລູກຫລານຂອງຕົນ.

ຮຸ່ນທໍາອິດຂອງ seccomp ໄດ້ຖືກເພີ່ມເຂົ້າໃນ kernel ໃນປີ 2005 ແລະບໍ່ເປັນທີ່ນິຍົມຫຼາຍ, ເນື່ອງຈາກວ່າມັນສະຫນອງທາງເລືອກດຽວ - ເພື່ອຈໍາກັດຊຸດຂອງການໂທລະບົບທີ່ມີຢູ່ໃນຂະບວນການຕໍ່ໄປນີ້: read, write, exit и sigreturn, ແລະຂະບວນການທີ່ລະເມີດກົດລະບຽບໄດ້ຖືກຂ້າຕາຍໂດຍໃຊ້ SIGKILL. ຢ່າງໃດກໍຕາມ, ໃນປີ 2012, seccomp ໄດ້ເພີ່ມຄວາມສາມາດໃນການນໍາໃຊ້ຕົວກອງ BPF, ຊ່ວຍໃຫ້ທ່ານສາມາດກໍານົດຊຸດຂອງການໂທລະບົບທີ່ໄດ້ຮັບອະນຸຍາດແລະແມ້ກະທັ້ງປະຕິບັດການກວດສອບການໂຕ້ຖຽງຂອງພວກເຂົາ. (ໜ້າສົນໃຈ, Chrome ແມ່ນຫນຶ່ງໃນບັນດາຜູ້ໃຊ້ທໍາອິດທີ່ເຮັດວຽກນີ້, ແລະປະຊາຊົນ Chrome ກໍາລັງພັດທະນາກົນໄກ KRSI ໂດຍອີງໃສ່ BPF ຮຸ່ນໃຫມ່ແລະອະນຸຍາດໃຫ້ປັບແຕ່ງ Linux Security Modules.) ການເຊື່ອມຕໍ່ກັບເອກະສານເພີ່ມເຕີມສາມາດພົບໄດ້ໃນທ້າຍ. ຂອງບົດຄວາມ.

ໃຫ້ສັງເກດວ່າມີບົດຄວາມຢູ່ໃນສູນກ່ຽວກັບການໃຊ້ seccomp ແລ້ວ, ບາງທີຄົນອາດຈະຕ້ອງການອ່ານມັນກ່ອນ (ຫຼືແທນທີ່ຈະ) ອ່ານສ່ວນຍ່ອຍຕໍ່ໄປນີ້. ໃນບົດຄວາມ ບັນຈຸແລະຄວາມປອດໄພ: seccomp ສະຫນອງຕົວຢ່າງຂອງການນໍາໃຊ້ seccomp, ທັງສະບັບ 2007 ແລະສະບັບທີ່ໃຊ້ BPF (ການກັ່ນຕອງແມ່ນສ້າງຂຶ້ນໂດຍໃຊ້ libseccomp), ເວົ້າກ່ຽວກັບການເຊື່ອມຕໍ່ຂອງ seccomp ກັບ Docker, ແລະຍັງສະຫນອງການເຊື່ອມຕໍ່ທີ່ເປັນປະໂຫຍດຫຼາຍ. ໃນບົດຄວາມ ການແຍກ daemons ດ້ວຍ systemd ຫຼື "ທ່ານບໍ່ຕ້ອງການ Docker ສໍາລັບສິ່ງນີ້!" ມັນກວມເອົາ, ໂດຍສະເພາະ, ວິທີການເພີ່ມບັນຊີດໍາຫຼືບັນຊີຂາວຂອງລະບົບການໂທສໍາລັບ daemons ແລ່ນ systemd.

ຕໍ່ໄປພວກເຮົາຈະເບິ່ງວິທີການຂຽນແລະການໂຫຼດຕົວກອງສໍາລັບ seccomp ໃນ C ເປົ່າແລະການນໍາໃຊ້ຫ້ອງສະຫມຸດ libseccomp ແລະຂໍ້ດີແລະຂໍ້ເສຍຂອງແຕ່ລະທາງເລືອກແມ່ນຫຍັງ, ແລະສຸດທ້າຍ, ໃຫ້ເບິ່ງວ່າ seccomp ຖືກໃຊ້ໂດຍໂຄງການແນວໃດ strace.

ການຂຽນແລະການໂຫຼດຕົວກອງສໍາລັບ seccomp

ພວກເຮົາຮູ້ວິທີການຂຽນໂປລແກລມ BPF ແລ້ວ, ດັ່ງນັ້ນທໍາອິດໃຫ້ເບິ່ງການໂຕ້ຕອບການຂຽນໂປລແກລມ seccomp. ທ່ານສາມາດກໍານົດການກັ່ນຕອງໃນລະດັບຂະບວນການ, ແລະຂະບວນການເດັກນ້ອຍທັງຫມົດຈະສືບທອດຂໍ້ຈໍາກັດ. ນີ້ແມ່ນເຮັດໄດ້ໂດຍໃຊ້ການໂທລະບົບ seccomp(2):

seccomp(SECCOMP_SET_MODE_FILTER, flags, &filter)

ບ່ອນທີ່ &filter - ນີ້ແມ່ນຕົວຊີ້ເຖິງໂຄງສ້າງທີ່ຄຸ້ນເຄີຍກັບພວກເຮົາ struct sock_fprog, i.e. ໂຄງການ BPF.

ໂປລແກລມສໍາລັບ seccomp ແຕກຕ່າງຈາກໂປຼແກຼມສໍາລັບ sockets ແນວໃດ? ສະພາບການຖ່າຍທອດ. ໃນກໍລະນີຂອງ sockets, ພວກເຮົາໄດ້ຮັບພື້ນທີ່ຄວາມຊົງຈໍາທີ່ປະກອບດ້ວຍ packet, ແລະໃນກໍລະນີຂອງ seccomp ພວກເຮົາໄດ້ຮັບໂຄງສ້າງເຊັ່ນ:

struct seccomp_data {
    int   nr;
    __u32 arch;
    __u64 instruction_pointer;
    __u64 args[6];
};

ມັນເປັນ nr ແມ່ນຕົວເລກຂອງການໂທລະບົບທີ່ຈະເປີດຕົວ, arch - ສະຖາປັດຕະປັດຈຸບັນ (ເພີ່ມເຕີມກ່ຽວກັບການຂ້າງລຸ່ມນີ້), args - ເຖິງຫົກການໂຕ້ຖຽງການໂທລະບົບ, ແລະ instruction_pointer ແມ່ນຕົວຊີ້ໄປຫາຄໍາແນະນໍາພື້ນທີ່ຂອງຜູ້ໃຊ້ທີ່ເຮັດໃຫ້ລະບົບການໂທ. ດັ່ງນັ້ນ, ສໍາລັບການຍົກຕົວຢ່າງ, ການໂຫຼດຈໍານວນການໂທລະບົບເຂົ້າໄປໃນທະບຽນ A ພວກເຮົາຕ້ອງເວົ້າ

ldw [0]

ມີລັກສະນະອື່ນໆສໍາລັບໂຄງການ seccomp, ສໍາລັບການຍົກຕົວຢ່າງ, ສະພາບການສາມາດເຂົ້າເຖິງໄດ້ໂດຍການວາງ 32-bit ແລະທ່ານບໍ່ສາມາດໂຫລດເຄິ່ງຫນຶ່ງຄໍາຫຼື byte - ໃນເວລາທີ່ພະຍາຍາມໂຫຼດການກັ່ນຕອງ. ldh [0] ໂທລະບົບ seccomp ຈະກັບຄືນມາ EINVAL. ຟັງຊັນກວດສອບການກັ່ນຕອງທີ່ໂຫລດ seccomp_check_filter() ແກ່ນ. (ສິ່ງທີ່ຕະຫລົກແມ່ນ, ໃນຄໍາຫມັ້ນສັນຍາຕົ້ນສະບັບທີ່ເພີ່ມການເຮັດວຽກຂອງ seccomp, ພວກເຂົາລືມເພີ່ມການອະນຸຍາດໃຫ້ນໍາໃຊ້ຄໍາແນະນໍາໃນຫນ້າທີ່ນີ້. mod (ການແບ່ງສ່ວນທີ່ຍັງເຫຼືອ) ແລະຕອນນີ້ບໍ່ສາມາດໃຊ້ໄດ້ສຳລັບໂຄງການ BPF seccomp, ນັບຕັ້ງແຕ່ການເພີ່ມຂອງມັນ ຈະແຕກ ABI.)

ໂດຍພື້ນຖານແລ້ວ, ພວກເຮົາຮູ້ທຸກສິ່ງທຸກຢ່າງເພື່ອຂຽນແລະອ່ານໂຄງການ seccomp. ປົກກະຕິແລ້ວເຫດຜົນຂອງໂປລແກລມຖືກຈັດເປັນບັນຊີລາຍຊື່ສີຂາວຫຼືສີດໍາຂອງການໂທລະບົບ, ຕົວຢ່າງເຊັ່ນໂຄງການ

ld [0]
jeq #304, bad
jeq #176, bad
jeq #239, bad
jeq #279, bad
good: ret #0x7fff0000 /* SECCOMP_RET_ALLOW */
bad: ret #0

ກວດເບິ່ງບັນຊີດໍາຂອງສີ່ລະບົບການໂທເລກ 304, 176, 239, 279. ການໂທລະບົບເຫຼົ່ານີ້ແມ່ນຫຍັງ? ພວກເຮົາບໍ່ສາມາດເວົ້າໄດ້ແນ່ນອນ, ເພາະວ່າພວກເຮົາບໍ່ຮູ້ວ່າສະຖາປັດຕະຍະກໍາໃດທີ່ໂຄງການໄດ້ຖືກຂຽນ. ເພາະສະນັ້ນ, ຜູ້ຂຽນຂອງ seccomp ສະເຫນີ ເລີ່ມໂຄງການທັງໝົດດ້ວຍການກວດສອບສະຖາປັດຕະຍະກຳ (ສະຖາປັດຕະຍະກຳປະຈຸບັນແມ່ນສະແດງຢູ່ໃນບໍລິບົດເປັນຊ່ອງຂໍ້ມູນ arch ກະດານສົນທະນາ struct seccomp_data). ດ້ວຍການກວດກາສະຖາປັດຕະຍະກໍາ, ຈຸດເລີ່ມຕົ້ນຂອງຕົວຢ່າງຈະເບິ່ງຄືວ່າ:

ld [4]
jne #0xc000003e, bad_arch ; SCMP_ARCH_X86_64

ແລະຫຼັງຈາກນັ້ນຈໍານວນການໂທລະບົບຂອງພວກເຮົາຈະໄດ້ຮັບຄ່າທີ່ແນ່ນອນ.

ພວກເຮົາຂຽນແລະໂຫລດຕົວກອງສໍາລັບ seccomp ໂດຍໃຊ້ `libseccomp`

ການຂຽນຕົວກອງໃນລະຫັດພື້ນເມືອງຫຼືໃນສະພາແຫ່ງ BPF ຊ່ວຍໃຫ້ທ່ານສາມາດຄວບຄຸມຜົນໄດ້ຮັບໄດ້ຢ່າງເຕັມທີ່, ແຕ່ໃນເວລາດຽວກັນ, ບາງຄັ້ງມັນກໍ່ດີກວ່າທີ່ຈະມີລະຫັດແບບເຄື່ອນທີ່ແລະ / ຫຼືສາມາດອ່ານໄດ້. ຫ້ອງສະຫມຸດຈະຊ່ວຍພວກເຮົາໃນເລື່ອງນີ້ libseccomp, ເຊິ່ງສະຫນອງການໂຕ້ຕອບມາດຕະຖານສໍາລັບການຂຽນຕົວກອງສີດໍາຫຼືສີຂາວ.

ຕົວຢ່າງ, ໃຫ້ຂຽນໂປຼແກຼມທີ່ດໍາເນີນການໄຟລ໌ຄູ່ຂອງການເລືອກຂອງຜູ້ໃຊ້, ໂດຍໄດ້ຕິດຕັ້ງບັນຊີດໍາຂອງລະບົບການໂທຈາກ. ບົດຄວາມຂ້າງເທິງ (ໂປລແກລມໄດ້ຖືກປັບປຸງໃຫ້ງ່າຍຂຶ້ນເພື່ອໃຫ້ສາມາດອ່ານໄດ້ຫຼາຍຂຶ້ນ, ສະບັບເຕັມສາມາດພົບໄດ້ ທີ່ນີ້):

#include <seccomp.h>
#include <unistd.h>
#include <err.h>

static int sys_numbers[] = {
        __NR_mount,
        __NR_umount2,
       // ... еще 40 системных вызовов ...
        __NR_vmsplice,
        __NR_perf_event_open,
};

int main(int argc, char **argv)
{
        scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ALLOW);

        for (size_t i = 0; i < sizeof(sys_numbers)/sizeof(sys_numbers[0]); i++)
                seccomp_rule_add(ctx, SCMP_ACT_TRAP, sys_numbers[i], 0);

        seccomp_load(ctx);

        execvp(argv[1], &argv[1]);
        err(1, "execlp: %s", argv[1]);
}

ກ່ອນອື່ນ ໝົດ ພວກເຮົາ ກຳ ນົດ array sys_numbers ຂອງ 40+ ຈໍານວນການໂທລະບົບທີ່ຈະຕັນ. ຫຼັງຈາກນັ້ນ, ເລີ່ມຕົ້ນສະພາບການ ctx ແລະບອກຫ້ອງສະໝຸດສິ່ງທີ່ພວກເຮົາຕ້ອງການອະນຸຍາດໃຫ້ (SCMP_ACT_ALLOW) ການໂທລະບົບທັງຫມົດເປັນຄ່າເລີ່ມຕົ້ນ (ມັນງ່າຍຂຶ້ນທີ່ຈະສ້າງບັນຊີດໍາ). ຫຼັງຈາກນັ້ນ, ຫນຶ່ງໂດຍຫນຶ່ງ, ພວກເຮົາເພີ່ມການໂທລະບົບທັງຫມົດຈາກບັນຊີດໍາ. ໃນການຕອບສະຫນອງຕໍ່ການໂທລະບົບຈາກບັນຊີລາຍຊື່, ພວກເຮົາຮ້ອງຂໍ SCMP_ACT_TRAP, ໃນກໍລະນີນີ້ seccomp ຈະສົ່ງສັນຍານກັບຂະບວນການ SIGSYS ມີລາຍລະອຽດຂອງການໂທລະບົບໃດລະເມີດກົດລະບຽບ. ສຸດທ້າຍ, ພວກເຮົາໂຫລດໂຄງການເຂົ້າໄປໃນ kernel ໂດຍໃຊ້ seccomp_load, ເຊິ່ງຈະລວບລວມໂຄງການແລະຄັດຕິດມັນກັບຂະບວນການໂດຍໃຊ້ການໂທລະບົບ seccomp(2).

ສໍາລັບການລວບລວມສົບຜົນສໍາເລັດ, ໂຄງການຕ້ອງໄດ້ຮັບການເຊື່ອມຕໍ່ກັບຫ້ອງສະຫມຸດ libseccompຕົວຢ່າງ:

cc -std=c17 -Wall -Wextra -c -o seccomp_lib.o seccomp_lib.c
cc -o seccomp_lib seccomp_lib.o -lseccomp

ຕົວຢ່າງຂອງການເປີດຕົວສົບຜົນສໍາເລັດ:

$ ./seccomp_lib echo ok
ok

ຕົວຢ່າງຂອງການໂທລະບົບທີ່ຖືກບລັອກ:

$ sudo ./seccomp_lib mount -t bpf bpf /tmp
Bad system call

ພວກເຮົາໃຊ້ straceສໍາລັບລາຍລະອຽດ:

$ sudo strace -e seccomp ./seccomp_lib mount -t bpf bpf /tmp
seccomp(SECCOMP_SET_MODE_FILTER, 0, {len=50, filter=0x55d8e78428e0}) = 0
--- SIGSYS {si_signo=SIGSYS, si_code=SYS_SECCOMP, si_call_addr=0xboobdeadbeef, si_syscall=__NR_mount, si_arch=AUDIT_ARCH_X86_64} ---
+++ killed by SIGSYS (core dumped) +++
Bad system call

ພວກເຮົາສາມາດຮູ້ໄດ້ແນວໃດວ່າໂປລແກລມຖືກຢຸດເຊົາຍ້ອນການໃຊ້ການໂທລະບົບທີ່ຜິດກົດຫມາຍ mount(2).

ດັ່ງນັ້ນ, ພວກເຮົາຂຽນການກັ່ນຕອງໂດຍໃຊ້ຫ້ອງສະຫມຸດ libseccomp, fitting ລະຫັດທີ່ບໍ່ແມ່ນ trivial ເປັນສີ່ແຖວ. ໃນຕົວຢ່າງຂ້າງເທິງ, ຖ້າມີຈໍານວນຫລາຍຂອງການໂທລະບົບ, ເວລາປະຕິບັດສາມາດຫຼຸດລົງຢ່າງເຫັນໄດ້ຊັດ, ເພາະວ່າການກວດສອບແມ່ນພຽງແຕ່ບັນຊີລາຍຊື່ຂອງການປຽບທຽບ. ສໍາລັບການເພີ່ມປະສິດທິພາບ, libseccomp ບໍ່ດົນມານີ້ມີ ລວມ patch, ເຊິ່ງເພີ່ມການສະຫນັບສະຫນູນສໍາລັບຄຸນລັກສະນະການກັ່ນຕອງ SCMP_FLTATR_CTL_OPTIMIZE. ການຕັ້ງຄ່າຄຸນລັກສະນະນີ້ເປັນ 2 ຈະປ່ຽນຕົວກອງເຂົ້າໄປໃນໂຄງການຄົ້ນຫາຖານສອງ.

ຖ້າທ່ານຕ້ອງການເບິ່ງວ່າຕົວກອງການຄົ້ນຫາຄູ່ເຮັດວຽກແນວໃດ, ໃຫ້ເບິ່ງ script ງ່າຍດາຍ, ເຊິ່ງສ້າງໂຄງການດັ່ງກ່າວໃນຕົວປະກອບ BPF ໂດຍການໂທຫາຈໍານວນການໂທຂອງລະບົບ, ສໍາລັບການຍົກຕົວຢ່າງ:

$ echo 1 3 6 8 13 | ./generate_bin_search_bpf.py
ld [0]
jeq #6, bad
jgt #6, check8
jeq #1, bad
jeq #3, bad
ret #0x7fff0000
check8:
jeq #8, bad
jeq #13, bad
ret #0x7fff0000
bad: ret #0

ທ່ານຈະບໍ່ສາມາດຂຽນອັນໃດໄວຂຶ້ນໄດ້, ເພາະວ່າໂປຣແກມ BPF ບໍ່ສາມາດດຳເນີນການ indentation jumps ໄດ້ (ຕົວຢ່າງ, ພວກເຮົາບໍ່ສາມາດເຮັດໄດ້. jmp A ຫຼື jmp [label+X]) ແລະດັ່ງນັ້ນການຫັນປ່ຽນທັງຫມົດແມ່ນຄົງທີ່.

seccomp ແລະ strace

ທຸກຄົນຮູ້ຈັກປະໂຫຍດ strace ເປັນເຄື່ອງມືທີ່ຂາດບໍ່ໄດ້ສໍາລັບການສຶກສາພຶດຕິກໍາຂອງຂະບວນການໃນ Linux. ຢ່າງໃດກໍຕາມ, ຫຼາຍຄົນຍັງໄດ້ຍິນກ່ຽວກັບ ບັນຫາການປະຕິບັດ ເມື່ອໃຊ້ປະໂຫຍດນີ້. ຄວາມຈິງແລ້ວແມ່ນວ່າ strace ປະຕິບັດໂດຍນໍາໃຊ້ ptrace(2), ແລະໃນກົນໄກນີ້ພວກເຮົາບໍ່ສາມາດລະບຸໄດ້ວ່າຊຸດຂອງລະບົບການໂທຫາພວກເຮົາຈໍາເປັນຕ້ອງຢຸດຂະບວນການ, i.e., ສໍາລັບການຍົກຕົວຢ່າງ, ຄໍາສັ່ງ.

$ time strace du /usr/share/ >/dev/null 2>&1

real    0m3.081s
user    0m0.531s
sys     0m2.073s

$ time strace -e open du /usr/share/ >/dev/null 2>&1

real    0m2.404s
user    0m0.193s
sys     0m1.800s

ຖືກປຸງແຕ່ງໃນເວລາປະມານດຽວກັນ, ເຖິງແມ່ນວ່າໃນກໍລະນີທີສອງພວກເຮົາຕ້ອງການທີ່ຈະຕິດຕາມພຽງແຕ່ຫນຶ່ງການໂທລະບົບ.

ທາງເລືອກໃຫມ່ --seccomp-bpf, ເພີ່ມໃສ່ strace ຮຸ່ນ 5.3, ຊ່ວຍໃຫ້ທ່ານເລັ່ງຂະບວນການຫຼາຍຄັ້ງແລະເວລາເລີ່ມຕົ້ນພາຍໃຕ້ການຕິດຕາມຂອງການໂທລະບົບຫນຶ່ງແມ່ນທຽບກັບເວລາຂອງການເລີ່ມຕົ້ນປົກກະຕິ:

$ time strace --seccomp-bpf -e open du /usr/share/ >/dev/null 2>&1

real    0m0.148s
user    0m0.017s
sys     0m0.131s

$ time du /usr/share/ >/dev/null 2>&1

real    0m0.140s
user    0m0.024s
sys     0m0.116s

(ໃນທີ່ນີ້, ແນ່ນອນ, ມີການຫຼອກລວງເລັກນ້ອຍທີ່ພວກເຮົາບໍ່ໄດ້ຕິດຕາມການເອີ້ນລະບົບຫຼັກຂອງຄໍາສັ່ງນີ້. ຖ້າພວກເຮົາຕິດຕາມ, ສໍາລັບຕົວຢ່າງ, newfsstat, ຫຼັງຈາກນັ້ນ, strace ຈະຫ້າມລໍ້ພຽງແຕ່ຍາກເປັນໂດຍບໍ່ມີການ --seccomp-bpf.)

ທາງເລືອກນີ້ເຮັດວຽກແນວໃດ? ໂດຍບໍ່ມີການຂອງນາງ strace ເຊື່ອມຕໍ່ກັບຂະບວນການແລະເລີ່ມໃຊ້ມັນ PTRACE_SYSCALL. ເມື່ອຂະບວນການທີ່ມີການຄຸ້ມຄອງອອກການໂທລະບົບ (ໃດໆ), ການຄວບຄຸມຈະຖືກໂອນໄປຫາ strace, ເຊິ່ງເບິ່ງການໂຕ້ຖຽງຂອງການໂທລະບົບແລະດໍາເນີນການກັບ PTRACE_SYSCALL. ຫຼັງຈາກເວລາໃດຫນຶ່ງ, ຂະບວນການສໍາເລັດການໂທລະບົບແລະເມື່ອອອກຈາກມັນ, ການຄວບຄຸມໄດ້ຖືກໂອນອີກເທື່ອຫນຶ່ງ strace, ເຊິ່ງເບິ່ງຄ່າກັບຄືນແລະເລີ່ມຕົ້ນຂະບວນການໂດຍໃຊ້ PTRACE_SYSCALL, ແລະອື່ນໆ.

ດ້ວຍ seccomp, ແນວໃດກໍ່ຕາມ, ຂະບວນການນີ້ສາມາດຖືກປັບແຕ່ງໄດ້ຕາມທີ່ພວກເຮົາຕ້ອງການ. ຄື, ຖ້າພວກເຮົາຕ້ອງການເບິ່ງພຽງແຕ່ຢູ່ໃນການໂທລະບົບ X, ຫຼັງຈາກນັ້ນພວກເຮົາສາມາດຂຽນການກັ່ນຕອງ BPF ວ່າສໍາລັບ X ຕອບຄ່າ SECCOMP_RET_TRACE, ແລະສໍາລັບການໂທທີ່ບໍ່ມີຄວາມສົນໃຈກັບພວກເຮົາ - SECCOMP_RET_ALLOW:

ld [0]
jneq #X, ignore
trace: ret #0x7ff00000
ignore: ret #0x7fff0000

ໃນກໍລະນີນີ້ strace ໃນເບື້ອງຕົ້ນເລີ່ມຕົ້ນຂະບວນການເປັນ PTRACE_CONT, ການກັ່ນຕອງຂອງພວກເຮົາຖືກປຸງແຕ່ງສໍາລັບການໂທຫາລະບົບແຕ່ລະຄົນ, ຖ້າການໂທລະບົບບໍ່ແມ່ນ X, ຫຼັງຈາກນັ້ນຂະບວນການຍັງສືບຕໍ່ດໍາເນີນການ, ແຕ່ຖ້າຫາກວ່ານີ້ X, ຫຼັງຈາກນັ້ນ seccomp ຈະໂອນການຄວບຄຸມ straceເຊິ່ງຈະເບິ່ງການໂຕ້ຖຽງແລະເລີ່ມຕົ້ນຂະບວນການເຊັ່ນ: PTRACE_SYSCALL (ເນື່ອງຈາກ seccomp ບໍ່ມີຄວາມສາມາດທີ່ຈະດໍາເນີນການໂຄງການກ່ຽວກັບການອອກຈາກການໂທລະບົບ). ເມື່ອການໂທລະບົບກັບຄືນມາ, strace ຈະເລີ່ມຂະບວນການຄືນໃໝ່ໂດຍໃຊ້ PTRACE_CONT ແລະຈະລໍຖ້າຂໍ້ຄວາມໃໝ່ຈາກ seccomp.

ເມື່ອໃຊ້ທາງເລືອກ --seccomp-bpf ມີສອງຂໍ້ຈໍາກັດ. ກ່ອນອື່ນ ໝົດ, ມັນຈະບໍ່ສາມາດເຂົ້າຮ່ວມຂະບວນການທີ່ມີຢູ່ແລ້ວໄດ້ (ທາງເລືອກ -p ບັນດາໂຄງການ strace), ເນື່ອງຈາກວ່ານີ້ບໍ່ໄດ້ຮັບການສະຫນັບສະຫນູນໂດຍ seccomp. ອັນທີສອງ, ບໍ່ມີຄວາມເປັນໄປໄດ້ ບໍ່ ເບິ່ງຂະບວນການຂອງເດັກນ້ອຍ, ນັບຕັ້ງແຕ່ຕົວກອງ seccomp ແມ່ນສືບທອດໂດຍຂະບວນການເດັກນ້ອຍທັງຫມົດໂດຍບໍ່ມີຄວາມສາມາດໃນການປິດການໃຊ້ງານນີ້.

ລາຍລະອຽດເລັກນ້ອຍກ່ຽວກັບວິທີແນ່ນອນ strace ເຮັດວຽກກັບ seccomp ສາມາດພົບໄດ້ຈາກ ບົດລາຍງານທີ່ຜ່ານມາ. ສໍາລັບພວກເຮົາ, ຄວາມຈິງທີ່ຫນ້າສົນໃຈຫຼາຍທີ່ສຸດແມ່ນວ່າ BPF ຄລາສສິກທີ່ເປັນຕົວແທນໂດຍ seccomp ຍັງຖືກນໍາໃຊ້ໃນມື້ນີ້.

`xt_bpf`

ຕອນນີ້ໃຫ້ກັບຄືນສູ່ໂລກຂອງເຄືອຂ່າຍ.

ຄວາມເປັນມາ: ເປັນເວລາດົນນານກ່ອນຫນ້ານີ້, ໃນປີ 2007, ຫຼັກການແມ່ນ ເພີ່ມ ໂມດູນ xt_u32 ສໍາລັບ netfilter. ມັນຖືກຂຽນໂດຍການປຽບທຽບກັບຕົວຈັດປະເພດການຈະລາຈອນທີ່ເກົ່າແກ່ກວ່າ cls_u32 ແລະອະນຸຍາດໃຫ້ທ່ານຂຽນກົດລະບຽບ binary arbitrary ສໍາລັບ iptables ໂດຍໃຊ້ການດໍາເນີນງານງ່າຍໆຕໍ່ໄປນີ້: ໂຫລດ 32 bits ຈາກຊຸດແລະປະຕິບັດຊຸດຂອງການປະຕິບັດເລກຄະນິດສາດ. ຍົກຕົວຢ່າງ,

sudo iptables -A INPUT -m u32 --u32 "6&0xFF=1" -j LOG --log-prefix "seen-by-xt_u32"

ໂຫລດ 32 bits ຂອງຫົວ IP, ເລີ່ມຈາກ padding 6, ແລະນໍາໃຊ້ຫນ້າກາກໃຫ້ເຂົາເຈົ້າ. 0xFF (ເອົາ byte ຕ່ໍາ). ພາກສະຫນາມນີ້ protocol ຫົວ IP ແລະພວກເຮົາປຽບທຽບມັນກັບ 1 (ICMP). ທ່ານສາມາດສົມທົບການກວດສອບຈໍານວນຫຼາຍໃນຫນຶ່ງກົດລະບຽບ, ແລະທ່ານຍັງສາມາດປະຕິບັດຕົວປະຕິບັດການ @ — ຍ້າຍ X bytes ໄປທາງຂວາ. ສໍາລັບຕົວຢ່າງ, ກົດລະບຽບ

iptables -m u32 --u32 "6&0xFF=0x6 && 0>>22&0x3C@4=0x29"

ກວດເບິ່ງວ່າ TCP Sequence Number ບໍ່ເທົ່າກັນ 0x29. ຂ້າພະເຈົ້າຈະບໍ່ເຂົ້າໄປໃນລາຍລະອຽດຕື່ມອີກ, ເພາະວ່າມັນເປັນທີ່ຊັດເຈນແລ້ວວ່າການຂຽນກົດລະບຽບດັ່ງກ່າວດ້ວຍມືແມ່ນບໍ່ສະດວກຫຼາຍ. ໃນບົດຄວາມ BPF - ລະຫັດ byte ລືມ, ມີການເຊື່ອມໂຍງຫຼາຍໆຢ່າງທີ່ມີຕົວຢ່າງຂອງການນໍາໃຊ້ແລະການສ້າງກົດລະບຽບສໍາລັບ xt_u32. ເບິ່ງການເຊື່ອມຕໍ່ໃນຕອນທ້າຍຂອງບົດຄວາມນີ້.

ນັບຕັ້ງແຕ່ 2013 ໂມດູນແທນທີ່ຈະເປັນໂມດູນ xt_u32 ທ່ານສາມາດນໍາໃຊ້ໂມດູນ BPF xt_bpf. ໃຜກໍ່ຕາມທີ່ໄດ້ອ່ານມານີ້ແລ້ວຄວນຈະມີຄວາມຊັດເຈນກ່ຽວກັບຫຼັກການຂອງການດໍາເນີນງານຂອງມັນ: ດໍາເນີນການ BPF bytecode ເປັນກົດລະບຽບ iptables. ທ່ານສາມາດສ້າງກົດລະບຽບໃຫມ່, ຕົວຢ່າງເຊັ່ນນີ້:

iptables -A INPUT -m bpf --bytecode <байткод> -j LOG

ທີ່ນີ້ <байткод> - ນີ້ແມ່ນລະຫັດໃນຮູບແບບຜົນຜະລິດຂອງ assembler bpf_asm ໂດຍຄ່າເລີ່ມຕົ້ນ, ສໍາລັບການຍົກຕົວຢ່າງ,

$ cat /tmp/test.bpf
ldb [9]
jneq #17, ignore
ret #1
ignore: ret #0

$ bpf_asm /tmp/test.bpf
4,48 0 0 9,21 0 1 17,6 0 0 1,6 0 0 0,

# iptables -A INPUT -m bpf --bytecode "$(bpf_asm /tmp/test.bpf)" -j LOG

ໃນຕົວຢ່າງນີ້ພວກເຮົາກໍາລັງກັ່ນຕອງແພັກເກັດ UDP ທັງຫມົດ. ເນື້ອໃນສໍາລັບໂຄງການ BPF ໃນໂມດູນ xt_bpfແນ່ນອນ, ຊີ້ໃຫ້ເຫັນເຖິງຂໍ້ມູນແພັກເກັດ, ໃນກໍລະນີຂອງ iptables, ໄປຫາຈຸດເລີ່ມຕົ້ນຂອງຫົວ IPv4. ກັບຄືນມູນຄ່າຈາກໂຄງການ BPF ບູລີນບ່ອນທີ່ false ໝາຍຄວາມວ່າແພັກເກັດບໍ່ກົງກັນ.

ມັນເປັນທີ່ຊັດເຈນວ່າໂມດູນ xt_bpf ສະຫນັບສະຫນູນການກັ່ນຕອງທີ່ສັບສົນຫຼາຍກ່ວາຕົວຢ່າງຂ້າງເທິງ. ໃຫ້ເບິ່ງຕົວຢ່າງທີ່ແທ້ຈິງຈາກ Cloudfare. ຈົນກ່ວາບໍ່ດົນມານີ້ພວກເຂົາເຈົ້າໄດ້ນໍາໃຊ້ໂມດູນ xt_bpf ເພື່ອປ້ອງກັນການໂຈມຕີ DDoS. ໃນບົດຄວາມ ແນະນຳເຄື່ອງມື BPF ພວກເຂົາເຈົ້າອະທິບາຍວິທີການ (ແລະເປັນຫຍັງ) ພວກເຂົາເຈົ້າສ້າງຕົວກອງ BPF ແລະເຜີຍແຜ່ການເຊື່ອມຕໍ່ກັບຊຸດຂອງຜົນປະໂຫຍດສໍາລັບການສ້າງຕົວກອງດັ່ງກ່າວ. ສໍາລັບຕົວຢ່າງ, ການນໍາໃຊ້ປະໂຫຍດ bpfgen ທ່ານສາມາດສ້າງໂຄງການ BPF ທີ່ກົງກັບຄໍາຖາມ DNS ສໍາລັບຊື່ habr.com:

$ ./bpfgen --assembly dns -- habr.com
ldx 4*([0]&0xf)
ld #20
add x
tax

lb_0:
    ld [x + 0]
    jneq #0x04686162, lb_1
    ld [x + 4]
    jneq #0x7203636f, lb_1
    ldh [x + 8]
    jneq #0x6d00, lb_1
    ret #65535

lb_1:
    ret #0

ໃນໂຄງການພວກເຮົາທໍາອິດໂຫລດເຂົ້າໄປໃນທະບຽນ X ທີ່ຢູ່ເລີ່ມຕົ້ນຂອງແຖວ x04habrx03comx00 ພາຍໃນ UDP datagram ແລະຫຼັງຈາກນັ້ນກວດເບິ່ງຄໍາຮ້ອງຂໍ: 0x04686162 <-> "x04hab" ແລະອື່ນໆ.

ເລັກນ້ອຍຕໍ່ມາ, Cloudfare ເຜີຍແຜ່ລະຫັດ p0f -> BPF compiler. ໃນບົດຄວາມ ຂໍແນະນໍາ p0f BPF compiler ພວກເຂົາເວົ້າກ່ຽວກັບສິ່ງທີ່ p0f ແລະວິທີການປ່ຽນລາຍເຊັນ p0f ເປັນ BPF:

$ ./bpfgen p0f -- 4:64:0:0:*,0::ack+:0
39,0 0 0 0,48 0 0 8,37 35 0 64,37 0 34 29,48 0 0 0,
84 0 0 15,21 0 31 5,48 0 0 9,21 0 29 6,40 0 0 6,
...

ໃນປັດຈຸບັນບໍ່ໄດ້ໃຊ້ Cloudfare ອີກຕໍ່ໄປ xt_bpf, ນັບຕັ້ງແຕ່ພວກເຂົາຍ້າຍໄປ XDP - ຫນຶ່ງໃນທາງເລືອກສໍາລັບການນໍາໃຊ້ສະບັບໃຫມ່ຂອງ BPF, ເບິ່ງ. L4Drop: XDP DDoS Mitigations.

`cls_bpf`

ຕົວຢ່າງສຸດທ້າຍຂອງການໃຊ້ BPF ຄລາສສິກໃນ kernel ແມ່ນຕົວຈັດປະເພດ cls_bpf ສໍາລັບລະບົບຍ່ອຍການຄວບຄຸມການຈະລາຈອນໃນ Linux, ເພີ່ມໃສ່ Linux ໃນທ້າຍປີ 2013 ແລະປ່ຽນແນວຄວາມຄິດຂອງວັດຖຸບູຮານ. cls_u32.

ຢ່າງໃດກໍຕາມ, ໃນປັດຈຸບັນພວກເຮົາຈະບໍ່ອະທິບາຍການເຮັດວຽກ cls_bpf, ເນື່ອງຈາກວ່າຈາກທັດສະນະຂອງຄວາມຮູ້ກ່ຽວກັບ BPF ຄລາສສິກນີ້ຈະບໍ່ໃຫ້ພວກເຮົາຫຍັງ - ພວກເຮົາໄດ້ກາຍເປັນຄວາມຄຸ້ນເຄີຍກັບການເຮັດວຽກທັງຫມົດ. ນອກຈາກນັ້ນ, ໃນບົດຄວາມຕໍ່ໄປທີ່ເວົ້າກ່ຽວກັບ Extended BPF, ພວກເຮົາຈະພົບກັບຕົວຈັດປະເພດນີ້ຫຼາຍກວ່າຫນຶ່ງຄັ້ງ.

ເຫດຜົນອື່ນທີ່ຈະບໍ່ເວົ້າກ່ຽວກັບການໃຊ້ BPF ຄລາສສິກ c cls_bpf ບັນຫາແມ່ນວ່າ, ເມື່ອປຽບທຽບກັບ Extended BPF, ຂອບເຂດຂອງການນໍາໃຊ້ໃນກໍລະນີນີ້ແມ່ນແຄບລົງຫຼາຍ: ໂຄງການຄລາສສິກບໍ່ສາມາດປ່ຽນເນື້ອໃນຂອງແພັກເກັດແລະບໍ່ສາມາດບັນທຶກສະຖານະລະຫວ່າງການໂທ.

ສະນັ້ນມັນເຖິງເວລາທີ່ຈະບອກລາກັບ BPF ຄລາສສິກແລະເບິ່ງອະນາຄົດ.

ອຳລາ BPF ຄລາສສິກ

ພວກເຮົາໄດ້ເບິ່ງວິທີການເທກໂນໂລຍີ BPF, ພັດທະນາໃນຕົ້ນ nineties, ປະສົບຜົນສໍາເລັດໃນຫນຶ່ງສ່ວນສີ່ຂອງສະຕະວັດແລະຈົນກ່ວາໃນຕອນທ້າຍຂອງການຄົ້ນພົບຄໍາຮ້ອງສະຫມັກໃຫມ່. ຢ່າງໃດກໍຕາມ, ຄ້າຍຄືກັນກັບການຫັນປ່ຽນຈາກເຄື່ອງຈັກ stack ກັບ RISC, ເຊິ່ງໄດ້ຮັບຜິດຊອບເປັນແຮງກະຕຸ້ນສໍາລັບການພັດທະນາຂອງ BPF ຄລາສສິກ, ໃນຊຸມປີ 32 ມີການຫັນປ່ຽນຈາກເຄື່ອງຈັກ 64-bit ກັບ XNUMX-bit ແລະ BPF ຄລາສສິກໄດ້ເລີ່ມຕົ້ນທີ່ຈະລ້າສະໄຫມ. ນອກຈາກນັ້ນ, ຄວາມສາມາດຂອງ BPF ຄລາສສິກແມ່ນຈໍາກັດຫຼາຍ, ແລະນອກເຫນືອຈາກສະຖາປັດຕະຍະກໍາທີ່ລ້າສະໄຫມ - ພວກເຮົາບໍ່ມີຄວາມສາມາດໃນການຊ່ວຍປະຢັດລັດລະຫວ່າງການໂທກັບໂຄງການ BPF, ບໍ່ມີຄວາມເປັນໄປໄດ້ຂອງການໂຕ້ຕອບຜູ້ໃຊ້ໂດຍກົງ, ບໍ່ມີຄວາມເປັນໄປໄດ້ຂອງການໂຕ້ຕອບ. ກັບ kernel, ຍົກເວັ້ນສໍາລັບການອ່ານຈໍານວນຈໍາກັດຂອງຊ່ອງໂຄງສ້າງ sk_buff ແລະການເປີດຕົວຫນ້າທີ່ຜູ້ຊ່ວຍທີ່ງ່າຍດາຍທີ່ສຸດ, ທ່ານບໍ່ສາມາດປ່ຽນເນື້ອໃນຂອງແພັກເກັດແລະປ່ຽນເສັ້ນທາງໃຫ້ເຂົາເຈົ້າ.

ໃນຄວາມເປັນຈິງ, ປະຈຸບັນທັງຫມົດທີ່ຍັງເຫຼືອຂອງ BPF ຄລາສສິກໃນ Linux ແມ່ນການໂຕ້ຕອບ API, ແລະພາຍໃນ kernel ບັນດາໂຄງການຄລາສສິກ, ບໍ່ວ່າຈະເປັນຕົວກອງ socket ຫຼືຕົວກອງ seccomp, ຈະຖືກແປອັດຕະໂນມັດໃນຮູບແບບໃຫມ່, Extended BPF. (ພວກເຮົາຈະເວົ້າກ່ຽວກັບເລື່ອງນີ້ຢ່າງແນ່ນອນໃນບົດຄວາມຕໍ່ໄປ.)

ການຫັນປ່ຽນໄປສູ່ສະຖາປັດຕະຍະກໍາໃຫມ່ໄດ້ເລີ່ມຕົ້ນໃນ 2013, ໃນເວລາທີ່ Alexey Starovoitov ສະເຫນີໂຄງການປັບປຸງ BPF. ໃນປີ 2014 ການແກ້ໄຂທີ່ສອດຄ້ອງກັນ ເລີ່ມປາກົດ ໃນຫຼັກ. ເທົ່າທີ່ຂ້າພະເຈົ້າເຂົ້າໃຈ, ແຜນການເບື້ອງຕົ້ນແມ່ນພຽງແຕ່ການເພີ່ມປະສິດທິພາບຂອງສະຖາປັດຕະຍະກໍາແລະ JIT compiler ເພື່ອເຮັດວຽກທີ່ມີປະສິດທິພາບຫຼາຍຂຶ້ນໃນເຄື່ອງຈັກ 64-bit, ແຕ່ການເພີ່ມປະສິດທິພາບເຫຼົ່ານີ້ເປັນການເລີ່ມຕົ້ນຂອງບົດໃຫມ່ໃນການພັດທະນາ Linux.

ບົດຄວາມເພີ່ມເຕີມໃນຊຸດນີ້ຈະກວມເອົາສະຖາປັດຕະຍະກໍາແລະການນໍາໃຊ້ເຕັກໂນໂລຢີໃຫມ່, ໃນເບື້ອງຕົ້ນເອີ້ນວ່າ BPF ພາຍໃນ, ຫຼັງຈາກນັ້ນຂະຫຍາຍ BPF, ແລະໃນປັດຈຸບັນພຽງແຕ່ BPF.

ເອກະສານ

Steven McCanne ແລະ Van Jacobson, "BSD Packet Filter: ສະຖາປັດຕະຍະກໍາໃຫມ່ສໍາລັບການຈັບ Packet ລະດັບຜູ້ໃຊ້", https://www.tcpdump.org/papers/bpf-usenix93.pdf
Steven McCanne, "libpcap: ສະຖາປັດຕະຍະກໍາ ແລະວິທີການເພີ່ມປະສິດທິພາບສໍາລັບການຈັບແພັກເກັດ", https://sharkfestus.wireshark.org/sharkfest.11/presentations/McCanne-Sharkfest'11_Keynote_Address.pdf
tcpdump, libpcap: https://www.tcpdump.org/
ການສອນການຈັບຄູ່ IPtable U32.
BPF - ລະຫັດ byte ລືມ: https://blog.cloudflare.com/bpf-the-forgotten-bytecode/
ການນໍາສະເຫນີເຄື່ອງມື BPF: https://blog.cloudflare.com/introducing-the-bpf-tools/
bpf_cls: http://man7.org/linux/man-pages/man8/tc-bpf.8.html
ພາບລວມ seccomp: https://lwn.net/Articles/656307/
https://github.com/torvalds/linux/blob/master/Documentation/userspace-api/seccomp_filter.rst
habr: ບັນຈຸແລະຄວາມປອດໄພ: seccomp
habr: ການແຍກ daemons ກັບ systemd ຫຼື "ທ່ານບໍ່ຕ້ອງການ Docker ສໍາລັບສິ່ງນີ້!"
Paul Chaignon, "strace --seccomp-bpf: a look under the hood", https://fosdem.org/2020/schedule/event/debugging_strace_bpf/
netsniff-ng: http://netsniff-ng.org/

ແຫຼ່ງຂໍ້ມູນ: www.habr.com

BPF ສໍາລັບເດັກນ້ອຍ, ສ່ວນສູນ: BPF ຄລາສສິກ

ຫຼັກສູດໄລຍະສັ້ນໃນປະຫວັດສາດຂອງ BPF (c)

ສະຖາປັດຕະຍະກໍາເຄື່ອງ BPF

tcpdump

ຕົວຢ່າງ: ການສັງເກດແພັກເກັດ IPv6

ຕົວຢ່າງທີ່ສັບສົນກວ່າ: ພວກເຮົາເບິ່ງແພັກເກັດ TCP ໂດຍພອດປາຍທາງ

Tcpdump: ກຳລັງໂຫຼດ

BPF ຄລາສສິກແລະສະຕະວັດທີ 21st

ການຂຽນໂປລແກລມ BPF ດ້ວຍມືຂອງພວກເຮົາເອງ

ສ່ວນຂະຫຍາຍ Linux ແລະ netsniff-ng

seccomp

ການຂຽນແລະການໂຫຼດຕົວກອງສໍາລັບ seccomp

ພວກເຮົາຂຽນແລະໂຫລດຕົວກອງສໍາລັບ seccomp ໂດຍໃຊ້ `libseccomp`

seccomp ແລະ strace

`xt_bpf`

`cls_bpf`

ອຳລາ BPF ຄລາສສິກ

ເອກະສານ

ເພີ່ມຄວາມຄິດເຫັນ Отменитьответ

BPF ສໍາລັບເດັກນ້ອຍ, ສ່ວນສູນ: BPF ຄລາສສິກ

ຫຼັກສູດໄລຍະສັ້ນໃນປະຫວັດສາດຂອງ BPF (c)

ສະຖາປັດຕະຍະກໍາເຄື່ອງ BPF

tcpdump

ຕົວຢ່າງ: ການສັງເກດແພັກເກັດ IPv6

ຕົວຢ່າງທີ່ສັບສົນກວ່າ: ພວກເຮົາເບິ່ງແພັກເກັດ TCP ໂດຍພອດປາຍທາງ

Tcpdump: ກຳລັງໂຫຼດ

BPF ຄລາສສິກແລະສະຕະວັດທີ 21st

ການຂຽນໂປລແກລມ BPF ດ້ວຍມືຂອງພວກເຮົາເອງ

ສ່ວນຂະຫຍາຍ Linux ແລະ netsniff-ng

seccomp

ການຂຽນແລະການໂຫຼດຕົວກອງສໍາລັບ seccomp

ພວກເຮົາຂຽນແລະໂຫລດຕົວກອງສໍາລັບ seccomp ໂດຍໃຊ້ libseccomp

seccomp ແລະ strace

xt_bpf

cls_bpf

ອຳລາ BPF ຄລາສສິກ

ເອກະສານ

ເພີ່ມຄວາມຄິດເຫັນ Отменитьответ

ພວກເຮົາຂຽນແລະໂຫລດຕົວກອງສໍາລັບ seccomp ໂດຍໃຊ້ `libseccomp`

`xt_bpf`

`cls_bpf`