ചെറിയ കുട്ടികൾക്കുള്ള ബിപിഎഫ്, ഭാഗം പൂജ്യം: ക്ലാസിക് ബിപിഎഫ്

ബെർക്ക്‌ലി പാക്കറ്റ് ഫിൽട്ടറുകൾ (ബിപിഎഫ്) ഒരു ലിനക്സ് കേർണൽ സാങ്കേതികവിദ്യയാണ്, അത് ഇപ്പോൾ വർഷങ്ങളായി ഇംഗ്ലീഷ് ഭാഷാ സാങ്കേതിക പ്രസിദ്ധീകരണങ്ങളുടെ മുൻ പേജുകളിൽ ഉണ്ട്. ബിപിഎഫിൻ്റെ ഉപയോഗത്തെയും വികസനത്തെയും കുറിച്ചുള്ള റിപ്പോർട്ടുകൾ കൊണ്ട് കോൺഫറൻസുകൾ നിറഞ്ഞിരിക്കുന്നു. ലിനക്സ് നെറ്റ്‌വർക്ക് സബ്സിസ്റ്റം മെയിൻ്റനർ ഡേവിഡ് മില്ലർ, ലിനക്സ് പ്ലംബേഴ്സ് 2018-ൽ തൻ്റെ പ്രസംഗം വിളിക്കുന്നു “ഈ സംസാരം XDP യെ കുറിച്ചല്ല” (ബിപിഎഫിനുള്ള ഒരു ഉപയോഗ കേസാണ് XDP). ബ്രണ്ടൻ ഗ്രെഗ് എന്ന തലക്കെട്ടിൽ പ്രസംഗങ്ങൾ നടത്തുന്നു Linux BPF സൂപ്പർ പവർസ്. ടോക്ക് ഹോയ്‌ലാൻഡ്-ജോർഗൻസെൻ ചിരിക്കുന്നുകേർണൽ ഇപ്പോൾ ഒരു മൈക്രോകെർണൽ ആണെന്ന്. തോമസ് ഗ്രാഫ് ഈ ആശയം പ്രോത്സാഹിപ്പിക്കുന്നു കെർണലിനുള്ള ജാവാസ്ക്രിപ്റ്റാണ് ബിപിഎഫ്.

ഹബ്രെയിൽ ബിപിഎഫിനെക്കുറിച്ച് ഇപ്പോഴും ചിട്ടയായ വിവരണമില്ല, അതിനാൽ ഒരു ലേഖന പരമ്പരയിൽ സാങ്കേതികവിദ്യയുടെ ചരിത്രത്തെക്കുറിച്ചും ആർക്കിടെക്ചർ, ഡെവലപ്‌മെൻ്റ് ടൂളുകളെക്കുറിച്ചും വിവരിക്കാനും ബിപിഎഫ് ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോഗത്തിൻ്റെയും പരിശീലനത്തിൻ്റെയും മേഖലകൾ വിവരിക്കാനും ഞാൻ ശ്രമിക്കും. സീരീസിലെ പൂജ്യം എന്ന ഈ ലേഖനം ക്ലാസിക് ബിപിഎഫിൻ്റെ ചരിത്രവും വാസ്തുവിദ്യയും പറയുന്നു, കൂടാതെ അതിൻ്റെ പ്രവർത്തന തത്വങ്ങളുടെ രഹസ്യങ്ങളും വെളിപ്പെടുത്തുന്നു. tcpdump, seccomp, strace, അതോടൊപ്പം തന്നെ കുടുതല്.

BPF ൻ്റെ വികസനം നിയന്ത്രിക്കുന്നത് Linux നെറ്റ്‌വർക്കിംഗ് കമ്മ്യൂണിറ്റിയാണ്, BPF-ൻ്റെ നിലവിലുള്ള പ്രധാന ആപ്ലിക്കേഷനുകൾ നെറ്റ്‌വർക്കുകളുമായി ബന്ധപ്പെട്ടതാണ്, അതിനാൽ അനുമതിയോടെ @യൂക്കാരിയറ്റ്, മഹത്തായ പരമ്പരയുടെ ബഹുമാനാർത്ഥം ഞാൻ പരമ്പരയെ "കൊച്ചുകുട്ടികൾക്കുള്ള BPF" എന്ന് വിളിച്ചു "ചെറിയ കുട്ടികൾക്കുള്ള നെറ്റ്‌വർക്കുകൾ".

ബിപിഎഫിൻ്റെ ചരിത്രത്തിലെ ഒരു ചെറിയ കോഴ്സ്(c)

ആധുനിക ബിപിഎഫ് സാങ്കേതികവിദ്യ പഴയ സാങ്കേതികവിദ്യയുടെ മെച്ചപ്പെടുത്തിയതും വിപുലീകരിച്ചതുമായ അതേ പേരിലുള്ള പതിപ്പാണ്, ആശയക്കുഴപ്പം ഒഴിവാക്കാൻ ഇപ്പോൾ ക്ലാസിക് ബിപിഎഫ് എന്ന് വിളിക്കുന്നു. ക്ലാസിക് BPF അടിസ്ഥാനമാക്കി ഒരു അറിയപ്പെടുന്ന യൂട്ടിലിറ്റി സൃഷ്ടിച്ചു tcpdump, മെക്കാനിസം seccomp, അതുപോലെ അറിയപ്പെടാത്ത മൊഡ്യൂളുകൾ xt_bpf വേണ്ടി iptables ക്ലാസിഫയറും cls_bpf. ആധുനിക ലിനക്സിൽ, ക്ലാസിക് BPF പ്രോഗ്രാമുകൾ സ്വയമേവ പുതിയ രൂപത്തിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു, എന്നിരുന്നാലും, ഒരു ഉപയോക്തൃ കാഴ്ചപ്പാടിൽ, API നിലനിന്നിരുന്നു, ഈ ലേഖനത്തിൽ നമ്മൾ കാണുന്നത് പോലെ, ക്ലാസിക് BPF-നുള്ള പുതിയ ഉപയോഗങ്ങൾ ഇപ്പോഴും കണ്ടെത്തി. ഇക്കാരണത്താൽ, കൂടാതെ ലിനക്സിലെ ക്ലാസിക്കൽ ബിപിഎഫിൻ്റെ വികസനത്തിൻ്റെ ചരിത്രം പിന്തുടർന്ന്, അത് എങ്ങനെ, എന്തുകൊണ്ട് അതിൻ്റെ ആധുനിക രൂപത്തിലേക്ക് പരിണമിച്ചുവെന്ന് വ്യക്തമാകും, ക്ലാസിക്കൽ ബിപിഎഫിനെക്കുറിച്ചുള്ള ഒരു ലേഖനത്തിൽ നിന്ന് ആരംഭിക്കാൻ ഞാൻ തീരുമാനിച്ചു.

കഴിഞ്ഞ നൂറ്റാണ്ടിൻ്റെ എൺപതുകളുടെ അവസാനത്തിൽ, പ്രശസ്ത ലോറൻസ് ബെർക്ക്ലി ലബോറട്ടറിയിൽ നിന്നുള്ള എഞ്ചിനീയർമാർ കഴിഞ്ഞ നൂറ്റാണ്ടിൻ്റെ എൺപതുകളുടെ അവസാനത്തിൽ ആധുനികമായ ഹാർഡ്‌വെയറിൽ നെറ്റ്‌വർക്ക് പാക്കറ്റുകൾ എങ്ങനെ ശരിയായി ഫിൽട്ടർ ചെയ്യാം എന്ന ചോദ്യത്തിൽ താൽപ്പര്യം പ്രകടിപ്പിച്ചു. CSPF (CMU/Stanford Packet Filter) സാങ്കേതികവിദ്യയിൽ ആദ്യം നടപ്പിലാക്കിയ ഫിൽട്ടറിംഗിൻ്റെ അടിസ്ഥാന ആശയം, അനാവശ്യമായ പാക്കറ്റുകൾ എത്രയും വേഗം ഫിൽട്ടർ ചെയ്യുക എന്നതായിരുന്നു, അതായത്. കേർണൽ സ്‌പെയ്‌സിൽ, ഇത് അനാവശ്യ ഡാറ്റ യൂസർ സ്‌പെയ്‌സിലേക്ക് പകർത്തുന്നത് ഒഴിവാക്കുന്നു. കേർണൽ സ്‌പെയ്‌സിൽ യൂസർ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് റൺടൈം സുരക്ഷ നൽകുന്നതിന്, ഒരു സാൻഡ്‌ബോക്‌സ് ചെയ്‌ത വെർച്വൽ മെഷീൻ ഉപയോഗിച്ചു.

എന്നിരുന്നാലും, നിലവിലുള്ള ഫിൽട്ടറുകൾക്കായുള്ള വെർച്വൽ മെഷീനുകൾ സ്റ്റാക്ക് അധിഷ്‌ഠിത മെഷീനുകളിൽ പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു, മാത്രമല്ല പുതിയ RISC മെഷീനുകളിൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കുന്നില്ല. തൽഫലമായി, ബെർക്ക്‌ലി ലാബ്‌സിൽ നിന്നുള്ള എഞ്ചിനീയർമാരുടെ പരിശ്രമത്തിലൂടെ, ഒരു പുതിയ ബിപിഎഫ് (ബെർക്ക്‌ലി പാക്കറ്റ് ഫിൽട്ടറുകൾ) സാങ്കേതികവിദ്യ വികസിപ്പിച്ചെടുത്തു, ഇതിൻ്റെ വെർച്വൽ മെഷീൻ ആർക്കിടെക്ചർ മോട്ടറോള 6502 പ്രോസസറിനെ അടിസ്ഥാനമാക്കി രൂപകൽപ്പന ചെയ്‌തതാണ് - അത്തരം അറിയപ്പെടുന്ന ഉൽപ്പന്നങ്ങളുടെ വർക്ക്‌ഹോഴ്‌സ് ആപ്പിൾ II അഥവാ NES. നിലവിലുള്ള സൊല്യൂഷനുകളെ അപേക്ഷിച്ച് പുതിയ വെർച്വൽ മെഷീൻ ഫിൽട്ടർ പ്രകടനം പത്തിരട്ടി വർദ്ധിപ്പിച്ചു.

ബിപിഎഫ് മെഷീൻ ആർക്കിടെക്ചർ

ഉദാഹരണങ്ങൾ വിശകലനം ചെയ്തുകൊണ്ട് ഞങ്ങൾ വാസ്തുവിദ്യയെ പ്രവർത്തനരീതിയിൽ പരിചയപ്പെടും. എന്നിരുന്നാലും, ആരംഭിക്കുന്നതിന്, മെഷീനിൽ ഉപയോക്താവിന് ആക്സസ് ചെയ്യാവുന്ന രണ്ട് 32-ബിറ്റ് രജിസ്റ്ററുകൾ ഉണ്ടെന്ന് പറയാം, ഒരു അക്യുമുലേറ്റർ A സൂചിക രജിസ്റ്ററും X, 64 ബൈറ്റുകൾ മെമ്മറി (16 വാക്കുകൾ), എഴുതുന്നതിനും തുടർന്നുള്ള വായനയ്ക്കും ലഭ്യമാണ്, കൂടാതെ ഈ വസ്തുക്കളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ചെറിയ കമാൻഡ് സിസ്റ്റം. സോപാധികമായ പദപ്രയോഗങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള ജമ്പ് നിർദ്ദേശങ്ങളും പ്രോഗ്രാമുകളിൽ ലഭ്യമാണ്, എന്നാൽ പ്രോഗ്രാം സമയബന്ധിതമായി പൂർത്തീകരിക്കുന്നതിന്, ജമ്പുകൾ മുന്നോട്ട് കൊണ്ടുപോകാൻ മാത്രമേ കഴിയൂ, അതായത്, പ്രത്യേകിച്ചും, ലൂപ്പുകൾ സൃഷ്ടിക്കുന്നത് നിരോധിച്ചിരിക്കുന്നു.

മെഷീൻ ആരംഭിക്കുന്നതിനുള്ള പൊതു സ്കീം ഇപ്രകാരമാണ്. ഉപയോക്താവ് ബിപിഎഫ് ആർക്കിടെക്ചറിനായി ഒരു പ്രോഗ്രാം സൃഷ്ടിക്കുന്നു ചിലത് കേർണൽ മെക്കാനിസം (ഒരു സിസ്റ്റം കോൾ പോലുള്ളവ), പ്രോഗ്രാം ലോഡ് ചെയ്യുകയും ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു ചിലർക്ക് കേർണലിലെ ഇവൻ്റ് ജനറേറ്ററിലേക്ക് (ഉദാഹരണത്തിന്, നെറ്റ്‌വർക്ക് കാർഡിലെ അടുത്ത പാക്കറ്റിൻ്റെ വരവാണ് ഇവൻ്റ്). ഒരു ഇവൻ്റ് സംഭവിക്കുമ്പോൾ, കേർണൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, ഒരു ഇൻ്റർപ്രെറ്ററിൽ), കൂടാതെ മെഷീൻ മെമ്മറി സമാനമാണ് ചിലർക്ക് കേർണൽ മെമ്മറി മേഖല (ഉദാഹരണത്തിന്, ഒരു ഇൻകമിംഗ് പാക്കറ്റിൻ്റെ ഡാറ്റ).

ഉദാഹരണങ്ങൾ നോക്കാൻ തുടങ്ങുന്നതിന് മുകളിൽ പറഞ്ഞവ മതിയാകും: ആവശ്യാനുസരണം സിസ്റ്റവും കമാൻഡ് ഫോർമാറ്റും ഞങ്ങൾ പരിചയപ്പെടും. നിങ്ങൾക്ക് ഒരു വെർച്വൽ മെഷീൻ്റെ കമാൻഡ് സിസ്റ്റം ഉടനടി പഠിക്കാനും അതിൻ്റെ എല്ലാ കഴിവുകളെക്കുറിച്ചും അറിയണമെങ്കിൽ, നിങ്ങൾക്ക് യഥാർത്ഥ ലേഖനം വായിക്കാം BSD പാക്കറ്റ് ഫിൽട്ടർ കൂടാതെ/അല്ലെങ്കിൽ ഫയലിൻ്റെ ആദ്യ പകുതി ഡോക്യുമെന്റേഷൻ/നെറ്റ്‌വർക്കിംഗ്/filter.txt കേർണൽ ഡോക്യുമെൻ്റേഷനിൽ നിന്ന്. കൂടാതെ, നിങ്ങൾക്ക് അവതരണം പഠിക്കാം libpcap: പാക്കറ്റ് ക്യാപ്ചറിനുള്ള ഒരു ആർക്കിടെക്ചറും ഒപ്റ്റിമൈസേഷൻ രീതിയും, അതിൽ ബിപിഎഫിൻ്റെ രചയിതാക്കളിൽ ഒരാളായ മക്കാൻ സൃഷ്ടിയുടെ ചരിത്രത്തെക്കുറിച്ച് സംസാരിക്കുന്നു libpcap.

ലിനക്സിൽ ക്ലാസിക് ബിപിഎഫ് ഉപയോഗിക്കുന്നതിൻ്റെ എല്ലാ പ്രധാന ഉദാഹരണങ്ങളും പരിഗണിക്കാൻ ഞങ്ങൾ ഇപ്പോൾ മുന്നോട്ട് പോകുന്നു: tcpdump (libpcap), seccomp, xt_bpf, cls_bpf.

tcpdump

അറിയപ്പെടുന്ന യൂട്ടിലിറ്റിയായ പാക്കറ്റ് ഫിൽട്ടറിംഗിനുള്ള മുൻഭാഗത്തിൻ്റെ വികസനത്തിന് സമാന്തരമായാണ് ബിപിഎഫിൻ്റെ വികസനം നടത്തിയത്. tcpdump. കൂടാതെ, പല ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും ലഭ്യമായ ക്ലാസിക് ബിപിഎഫ് ഉപയോഗിക്കുന്നതിൻ്റെ ഏറ്റവും പഴയതും പ്രശസ്തവുമായ ഉദാഹരണമായതിനാൽ, ഞങ്ങൾ സാങ്കേതികവിദ്യയെക്കുറിച്ചുള്ള ഞങ്ങളുടെ പഠനം ആരംഭിക്കും.

(ലിനക്സിലെ ഈ ലേഖനത്തിലെ എല്ലാ ഉദാഹരണങ്ങളും ഞാൻ പ്രവർത്തിപ്പിച്ചു 5.6.0-rc6. മികച്ച വായനാക്ഷമതയ്ക്കായി ചില കമാൻഡുകളുടെ ഔട്ട്പുട്ട് എഡിറ്റ് ചെയ്തിട്ടുണ്ട്.)

ഉദാഹരണം: IPv6 പാക്കറ്റുകൾ നിരീക്ഷിക്കൽ

ഒരു ഇൻ്റർഫേസിൽ എല്ലാ IPv6 പാക്കറ്റുകളും നോക്കണമെന്ന് നമുക്ക് സങ്കൽപ്പിക്കാം eth0. ഇത് ചെയ്യുന്നതിന്, നമുക്ക് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാം tcpdump ഒരു ലളിതമായ ഫിൽട്ടർ ഉപയോഗിച്ച് ip6:

$ sudo tcpdump -i eth0 ip6

ഇപ്രകാരം tcpdump ഫിൽട്ടർ കംപൈൽ ചെയ്യുന്നു ip6 ബിപിഎഫ് ആർക്കിടെക്ചർ ബൈറ്റ്കോഡിലേക്ക് കേർണലിലേക്ക് അയയ്ക്കുക (വിഭാഗത്തിലെ വിശദാംശങ്ങൾ കാണുക Tcpdump: ലോഡ് ചെയ്യുന്നു). ഇൻ്റർഫേസിലൂടെ കടന്നുപോകുന്ന ഓരോ പാക്കറ്റിനും ലോഡ് ചെയ്ത ഫിൽട്ടർ പ്രവർത്തിക്കും eth0. ഫിൽട്ടർ പൂജ്യമല്ലാത്ത ഒരു മൂല്യം നൽകുന്നുവെങ്കിൽ n, പിന്നെ വരെ n പാക്കറ്റിൻ്റെ ബൈറ്റുകൾ യൂസർ സ്‌പെയ്‌സിലേക്ക് പകർത്തും, അത് ഔട്ട്‌പുട്ടിൽ നമുക്ക് കാണാനാകും tcpdump.

ഏത് ബൈറ്റ്കോഡാണ് കേർണലിലേക്ക് അയച്ചതെന്ന് നമുക്ക് എളുപ്പത്തിൽ കണ്ടെത്താനാകും 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)വിശകലനം ചെയ്ത നെറ്റ്‌വർക്ക് പാക്കറ്റിൻ്റെ ബൈറ്റ്. ഇഥർനെറ്റ് ഇൻ്റർഫേസിൽ നിന്ന് ഞങ്ങൾ പാക്കറ്റുകൾ വായിക്കുന്നു eth0, ഇതും അർത്ഥംപാക്കറ്റ് ഇതുപോലെ കാണപ്പെടുന്നു (ലാളിത്യത്തിനായി, പാക്കറ്റിൽ VLAN ടാഗുകൾ ഇല്ലെന്ന് ഞങ്ങൾ അനുമാനിക്കുന്നു):

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

അതിനാൽ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്ത ശേഷം ldh [12] രജിസ്റ്ററിൽ A ഒരു വയൽ ഉണ്ടാകും Ether Type — ഈ ഇഥർനെറ്റ് ഫ്രെയിമിൽ ട്രാൻസ്മിറ്റ് ചെയ്ത പാക്കറ്റിൻ്റെ തരം. 1 വരിയിൽ ഞങ്ങൾ രജിസ്റ്ററിൻ്റെ ഉള്ളടക്കങ്ങൾ താരതമ്യം ചെയ്യുന്നു A (പാക്കേജ് തരം) സി 0x86dd, ഇതും ഉണ്ട് ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള തരം IPv6 ആണ്. ലൈൻ 1-ൽ, താരതമ്യ കമാൻഡിന് പുറമേ, രണ്ട് നിരകൾ കൂടി ഉണ്ട് - jt 2 и jf 3 — താരതമ്യം വിജയകരമാണെങ്കിൽ നിങ്ങൾ പോകേണ്ട മാർക്കുകൾ (A == 0x86dd) വിജയിച്ചില്ല. അതിനാൽ, വിജയകരമായ ഒരു കേസിൽ (IPv6) ഞങ്ങൾ വരി 2 ലേക്ക് പോകുന്നു, വിജയിക്കാത്ത സാഹചര്യത്തിൽ - വരി 3 ലേക്ക്. ലൈൻ 3 ൽ പ്രോഗ്രാം കോഡ് 0 ഉപയോഗിച്ച് അവസാനിക്കുന്നു (പാക്കറ്റ് പകർത്തരുത്), വരി 2 ൽ പ്രോഗ്രാം കോഡ് ഉപയോഗിച്ച് അവസാനിക്കുന്നു. 262144 (എനിക്ക് പരമാവധി 256 കിലോബൈറ്റ് പാക്കേജ് പകർത്തുക).

കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം: ഞങ്ങൾ ലക്ഷ്യസ്ഥാന പോർട്ട് വഴി TCP പാക്കറ്റുകൾ നോക്കുന്നു

ഡെസ്റ്റിനേഷൻ പോർട്ട് 666 ഉപയോഗിച്ച് എല്ലാ TCP പാക്കറ്റുകളും പകർത്തുന്ന ഒരു ഫിൽട്ടർ എങ്ങനെയുണ്ടെന്ന് നോക്കാം. 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 പാക്കറ്റാണെന്ന് ഞങ്ങൾ ഇതിനകം പരിശോധിച്ചു (ഈതർ തരം = 0x800) രജിസ്റ്ററിൽ ലോഡ് ചെയ്യുക A പാക്കറ്റിൻ്റെ 24-ാമത്തെ ബൈറ്റ്. ഞങ്ങളുടെ പാക്കേജ് ഇതുപോലെ കാണപ്പെടുന്നു

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

അതായത് ഞങ്ങൾ രജിസ്റ്ററിൽ ലോഡ് ചെയ്യുന്നു A ഐപി ഹെഡറിൻ്റെ പ്രോട്ടോക്കോൾ ഫീൽഡ്, ഇത് ലോജിക്കൽ ആണ്, കാരണം ഞങ്ങൾ TCP പാക്കറ്റുകൾ മാത്രം പകർത്താൻ ആഗ്രഹിക്കുന്നു. ഞങ്ങൾ പ്രോട്ടോക്കോൾ താരതമ്യം ചെയ്യുന്നു 0x6 (IPPROTO_TCP) ലൈൻ 3 ൽ.

4, 5 വരികളിൽ ഞങ്ങൾ വിലാസം 20 ൽ സ്ഥിതിചെയ്യുന്ന ഹാഫ് വേഡുകൾ ലോഡ് ചെയ്യുകയും കമാൻഡ് ഉപയോഗിക്കുകയും ചെയ്യുന്നു jset മൂന്നിൽ ഒന്ന് സജ്ജീകരിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക പതാകകൾ - പുറത്തിറക്കിയ മാസ്ക് ധരിച്ച് jset ഏറ്റവും പ്രധാനപ്പെട്ട മൂന്ന് ബിറ്റുകൾ മായ്ച്ചു. മൂന്ന് ബിറ്റുകളിൽ രണ്ടെണ്ണം പാക്കറ്റ് ഒരു വിഘടിച്ച ഐപി പാക്കറ്റിൻ്റെ ഭാഗമാണോ എന്നും അങ്ങനെയാണെങ്കിൽ, അത് അവസാന ശകലമാണോ എന്നും നമ്മോട് പറയുന്നു. മൂന്നാമത്തെ ബിറ്റ് റിസർവ് ചെയ്‌തിരിക്കുന്നു, അത് പൂജ്യമായിരിക്കണം. അപൂർണ്ണമോ തകർന്നതോ ആയ പാക്കറ്റുകൾ പരിശോധിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല, അതിനാൽ ഞങ്ങൾ മൂന്ന് ബിറ്റുകളും പരിശോധിക്കുന്നു.

ഈ ലിസ്റ്റിംഗിലെ ഏറ്റവും രസകരമായത് വരി 6 ആണ്. എക്സ്പ്രഷൻ ldxb 4*([14]&0xf) ഞങ്ങൾ രജിസ്റ്ററിൽ ലോഡ് ചെയ്യുന്നു എന്നാണ് X പാക്കറ്റിൻ്റെ പതിനഞ്ചാമത്തെ ബൈറ്റിൻ്റെ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള നാല് ബിറ്റുകൾ 4 കൊണ്ട് ഗുണിച്ചാൽ. പതിനഞ്ചാമത്തെ ബൈറ്റിൻ്റെ ഏറ്റവും കുറഞ്ഞ നാല് ബിറ്റുകൾ ഫീൽഡാണ് ഇൻ്റർനെറ്റ് തലക്കെട്ടിൻ്റെ ദൈർഘ്യം IPv4 തലക്കെട്ട്, അത് തലക്കെട്ടിൻ്റെ ദൈർഘ്യം വാക്കുകളിൽ സംഭരിക്കുന്നു, അതിനാൽ നിങ്ങൾ 4 കൊണ്ട് ഗുണിക്കേണ്ടതുണ്ട്. രസകരമെന്നു പറയട്ടെ, എക്സ്പ്രഷൻ 4*([14]&0xf) ഈ ഫോമിൽ മാത്രം ഉപയോഗിക്കാവുന്ന ഒരു പ്രത്യേക അഡ്രസ്സിംഗ് സ്കീമിനുള്ള ഒരു പദവിയാണ് ഒരു രജിസ്റ്ററിന് മാത്രം X, അതായത്. നമുക്കും പറയാനാവില്ല ldb 4*([14]&0xf) ഇല്ല ldxb 5*([14]&0xf) (ഞങ്ങൾക്ക് മറ്റൊരു ഓഫ്‌സെറ്റ് മാത്രമേ വ്യക്തമാക്കാൻ കഴിയൂ, ഉദാഹരണത്തിന്, ldxb 4*([16]&0xf)). ഈ അഡ്രസ്സിംഗ് സ്കീം കൃത്യമായി ലഭിക്കുന്നതിന് വേണ്ടിയാണ് ബിപിഎഫിൽ ചേർത്തതെന്ന് വ്യക്തമാണ് 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 ബൈറ്റ്കോഡ് എങ്ങനെ ലോഡുചെയ്യുന്നു എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ വിശദമായി പറഞ്ഞിട്ടില്ല. പൊതുവായി പറഞ്ഞാല്, tcpdump നിരവധി സിസ്റ്റങ്ങളിലേക്കും ഫിൽട്ടറുകളിൽ പ്രവർത്തിക്കാനും പോർട്ട് ചെയ്തു tcpdump ലൈബ്രറി ഉപയോഗിക്കുന്നു libpcap. ചുരുക്കത്തിൽ, ഉപയോഗിച്ച് ഒരു ഇൻ്റർഫേസിൽ ഒരു ഫിൽട്ടർ സ്ഥാപിക്കാൻ libpcap, നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യേണ്ടതുണ്ട്:

• ഒരു തരം ഡിസ്ക്രിപ്റ്റർ സൃഷ്ടിക്കുക pcap_t ഇൻ്റർഫേസ് നാമത്തിൽ നിന്ന്: pcap_create,
• ഇൻ്റർഫേസ് സജീവമാക്കുക: pcap_activate,
• കംപൈൽ ഫിൽട്ടർ: pcap_compile,
• കണക്ട് ഫിൽട്ടർ: pcap_setfilter.

പ്രവർത്തനം എങ്ങനെയെന്ന് കാണാൻ pcap_setfilter ലിനക്സിൽ നടപ്പിലാക്കി, ഞങ്ങൾ ഉപയോഗിക്കുന്നത് 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
...

ഔട്ട്പുട്ടിൻ്റെ ആദ്യ രണ്ട് വരികളിൽ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു അസംസ്കൃത സോക്കറ്റ് എല്ലാ ഇഥർനെറ്റ് ഫ്രെയിമുകളും വായിച്ച് ഇൻ്റർഫേസിലേക്ക് ബന്ധിപ്പിക്കാൻ eth0. ഒരു പക്ഷെ ഞങ്ങളുടെ ആദ്യ ഉദാഹരണം ഫിൽട്ടർ ആണെന്ന് നമുക്കറിയാം ip നാല് ബിപിഎഫ് നിർദ്ദേശങ്ങൾ ഉൾക്കൊള്ളുന്നു, മൂന്നാമത്തെ വരിയിൽ ഈ ഓപ്ഷൻ എങ്ങനെ ഉപയോഗിക്കുന്നു എന്ന് നമുക്ക് കാണാം SO_ATTACH_FILTER സിസ്റ്റം കോൾ setsockopt 4 നീളമുള്ള ഒരു ഫിൽട്ടർ ഞങ്ങൾ ലോഡ് ചെയ്യുകയും ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു. ഇതാണ് ഞങ്ങളുടെ ഫിൽട്ടർ.

ക്ലാസിക് ബിപിഎഫിൽ, ഒരു ഫിൽട്ടർ ലോഡുചെയ്യുന്നതും ബന്ധിപ്പിക്കുന്നതും എല്ലായ്പ്പോഴും ഒരു ആറ്റോമിക് ഓപ്പറേഷനായിട്ടാണ് സംഭവിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്, കൂടാതെ ബിപിഎഫിൻ്റെ പുതിയ പതിപ്പിൽ, പ്രോഗ്രാം ലോഡുചെയ്യുന്നതും ഇവൻ്റ് ജനറേറ്ററുമായി ബന്ധിപ്പിക്കുന്നതും കൃത്യസമയത്ത് വേർതിരിക്കപ്പെടുന്നു.

മറഞ്ഞിരിക്കുന്ന സത്യം

ഔട്ട്പുട്ടിൻ്റെ കുറച്ചുകൂടി പൂർണ്ണമായ പതിപ്പ് ഇതുപോലെ കാണപ്പെടുന്നു:

$ 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 വരികളിൽ എന്താണ് സംഭവിക്കുന്നത്? ഇത് മാറുന്നു libpcap ഞങ്ങളെ പരിപാലിക്കുന്നു - അതിനാൽ ഞങ്ങളുടെ ഫിൽട്ടറിൻ്റെ ഔട്ട്പുട്ടിൽ അത് തൃപ്തിപ്പെടുത്താത്ത പാക്കറ്റുകൾ ഉൾപ്പെടില്ല, ലൈബ്രറി ബന്ധിപ്പിക്കുന്നു ഡമ്മി ഫിൽട്ടർ ret #0 (എല്ലാ പാക്കറ്റുകളും ഡ്രോപ്പ് ചെയ്യുക), സോക്കറ്റ് നോൺ-ബ്ലോക്കിംഗ് മോഡിലേക്ക് മാറ്റുകയും മുമ്പത്തെ ഫിൽട്ടറുകളിൽ നിന്ന് ശേഷിക്കുന്ന എല്ലാ പാക്കറ്റുകളും കുറയ്ക്കാൻ ശ്രമിക്കുകയും ചെയ്യുന്നു.

മൊത്തത്തിൽ, ക്ലാസിക് BPF ഉപയോഗിച്ച് Linux-ൽ പാക്കേജുകൾ ഫിൽട്ടർ ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് ഒരു ഘടനയുടെ രൂപത്തിൽ ഒരു ഫിൽട്ടർ ആവശ്യമാണ് struct sock_fprog ഒരു തുറന്ന സോക്കറ്റും, അതിനുശേഷം ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ച് സോക്കറ്റിലേക്ക് ഫിൽട്ടർ ഘടിപ്പിക്കാം setsockopt.

രസകരമെന്നു പറയട്ടെ, ഫിൽട്ടർ അസംസ്കൃതമായി മാത്രമല്ല, ഏത് സോക്കറ്റിലും ഘടിപ്പിക്കാം. ഇവിടെ ഉദാഹരണം എല്ലാ ഇൻകമിംഗ് യുഡിപി ഡാറ്റാഗ്രാമുകളിൽ നിന്നും ആദ്യത്തെ രണ്ട് ബൈറ്റുകൾ ഒഴികെ മറ്റെല്ലാം വെട്ടിമാറ്റുന്ന ഒരു പ്രോഗ്രാം. (ലേഖനം അലങ്കോലപ്പെടുത്താതിരിക്കാൻ ഞാൻ കോഡിൽ അഭിപ്രായങ്ങൾ ചേർത്തു.)

ഉപയോഗത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ setsockopt ഫിൽട്ടറുകൾ ബന്ധിപ്പിക്കുന്നതിന്, കാണുക സോക്കറ്റ്(7), എന്നാൽ നിങ്ങളുടെ സ്വന്തം ഫിൽട്ടറുകൾ എഴുതുന്നതിനെക്കുറിച്ച് struct sock_fprog സഹായമില്ലാതെ tcpdump ഞങ്ങൾ വിഭാഗത്തിൽ സംസാരിക്കും നമ്മുടെ സ്വന്തം കൈകൊണ്ട് BPF പ്രോഗ്രാമിംഗ്.

ക്ലാസിക് ബിപിഎഫും 21-ാം നൂറ്റാണ്ടും

1997-ൽ BPF ലിനക്സിൽ ഉൾപ്പെടുത്തി, ദീർഘകാലമായി ഒരു ജോലിക്കാരനായി തുടർന്നു libpcap പ്രത്യേക മാറ്റങ്ങളൊന്നും കൂടാതെ (ലിനക്സ്-നിർദ്ദിഷ്ട മാറ്റങ്ങൾ, തീർച്ചയായും, അത് ആയിരുന്നു, പക്ഷേ അവർ ആഗോള ചിത്രം മാറ്റിയില്ല). 2011-ൽ എറിക് ഡുമസെറ്റ് നിർദ്ദേശിച്ചപ്പോഴാണ് ബിപിഎഫ് വികസിക്കുമെന്നതിൻ്റെ ആദ്യ ഗുരുതരമായ സൂചനകൾ ഉണ്ടായത്. പാച്ച്, ഇത് കേർണലിലേക്ക് ജസ്റ്റ് ഇൻ ടൈം കംപൈലർ ചേർക്കുന്നു - ബിപിഎഫ് ബൈറ്റ്കോഡ് നേറ്റീവ് ആയി പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ഒരു വിവർത്തകൻ x86_64 കോഡ്.

മാറ്റങ്ങളുടെ ശൃംഖലയിലെ ആദ്യത്തേത് JIT കംപൈലർ ആയിരുന്നു: 2012 ൽ പ്രത്യക്ഷപ്പെട്ടു ഫിൽട്ടറുകൾ എഴുതാനുള്ള കഴിവ് സെക്കന്റ്, BPF ഉപയോഗിച്ച്, 2013 ജനുവരിയിൽ ഉണ്ടായിരുന്നു കൂട്ടിച്ചേർത്തു മൊഡ്യൂൾ xt_bpf, ഇത് നിയമങ്ങൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു iptables ബിപിഎഫിൻ്റെ സഹായത്തോടെ, 2013 ഒക്ടോബറിൽ കൂട്ടിച്ചേർത്തു ഒരു മൊഡ്യൂളും cls_bpf, BPF ഉപയോഗിച്ച് ട്രാഫിക് ക്ലാസിഫയറുകൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഈ ഉദാഹരണങ്ങളെല്ലാം ഞങ്ങൾ ഉടൻ തന്നെ കൂടുതൽ വിശദമായി പരിശോധിക്കും, എന്നാൽ ലൈബ്രറി നൽകുന്ന കഴിവുകൾ കാരണം, ബിപിഎഫിനായി അനിയന്ത്രിതമായ പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതാമെന്നും കംപൈൽ ചെയ്യാമെന്നും പഠിക്കുന്നത് ആദ്യം ഞങ്ങൾക്ക് ഉപയോഗപ്രദമാകും. libpcap പരിമിതം (ലളിതമായ ഉദാഹരണം: ഫിൽട്ടർ സൃഷ്ടിച്ചത് libpcap രണ്ട് മൂല്യങ്ങൾ മാത്രമേ നൽകാനാകൂ - 0 അല്ലെങ്കിൽ 0x40000) അല്ലെങ്കിൽ പൊതുവെ, seccomp-ൻ്റെ കാര്യത്തിലെന്നപോലെ, ബാധകമല്ല.

നമ്മുടെ സ്വന്തം കൈകൊണ്ട് BPF പ്രോഗ്രാമിംഗ്

BPF നിർദ്ദേശങ്ങളുടെ ബൈനറി ഫോർമാറ്റ് നമുക്ക് പരിചയപ്പെടാം, ഇത് വളരെ ലളിതമാണ്:

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

ഓരോ നിർദ്ദേശവും 64 ബിറ്റുകൾ ഉൾക്കൊള്ളുന്നു, അതിൽ ആദ്യത്തെ 16 ബിറ്റുകൾ നിർദ്ദേശ കോഡാണ്, തുടർന്ന് രണ്ട് എട്ട്-ബിറ്റ് ഇൻഡൻ്റുകൾ ഉണ്ട്, jt и jf, വാദത്തിനായി 32 ബിറ്റുകൾ K, ഇതിൻ്റെ ഉദ്ദേശ്യം കമാൻഡിൽ നിന്ന് കമാൻഡ് വരെ വ്യത്യാസപ്പെടുന്നു. ഉദാഹരണത്തിന്, കമാൻഡ് ret, പ്രോഗ്രാം അവസാനിപ്പിക്കുന്ന കോഡ് ഉണ്ട് 6, കൂടാതെ റിട്ടേൺ മൂല്യം സ്ഥിരാങ്കത്തിൽ നിന്ന് എടുക്കുന്നു K. സിയിൽ, ഒരൊറ്റ ബിപിഎഫ് നിർദ്ദേശം ഒരു ഘടനയായി പ്രതിനിധീകരിക്കുന്നു

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))

മെഷീൻ കോഡുകളുടെ രൂപത്തിൽ പ്രോഗ്രാമുകൾ എഴുതുന്നത് വളരെ സൗകര്യപ്രദമല്ല, പക്ഷേ ചിലപ്പോൾ ഇത് ആവശ്യമാണ് (ഉദാഹരണത്തിന്, ഡീബഗ്ഗിംഗ്, യൂണിറ്റ് ടെസ്റ്റുകൾ സൃഷ്ടിക്കൽ, ഹബ്രെയിൽ ലേഖനങ്ങൾ എഴുതൽ മുതലായവ). സൗകര്യാർത്ഥം, ഫയലിൽ <linux/filter.h> ഹെൽപ്പർ മാക്രോകൾ നിർവചിച്ചിരിക്കുന്നു - മുകളിലുള്ള അതേ ഉദാഹരണം ഇതായി മാറ്റിയെഴുതാം

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),
}

എന്നിരുന്നാലും, ഈ ഓപ്ഷൻ വളരെ സൗകര്യപ്രദമല്ല. ഇതാണ് ലിനക്സ് കേർണൽ പ്രോഗ്രാമർമാർ ന്യായീകരിച്ചത്, അതിനാൽ ഡയറക്ടറിയിൽ tools/bpf ക്ലാസിക് BPF-ൽ പ്രവർത്തിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു അസംബ്ലറും ഡീബഗ്ഗറും കണ്ടെത്താൻ കഴിയുന്ന കേർണലുകൾ.

അസംബ്ലി ഭാഷ ഡീബഗ് ഔട്ട്പുട്ടുമായി വളരെ സാമ്യമുള്ളതാണ് 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,

സി പ്രോഗ്രാമർമാരുടെ സൗകര്യത്തിനായി, മറ്റൊരു ഔട്ട്പുട്ട് ഫോർമാറ്റ് ഉപയോഗിക്കാം:

$ 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 വിപുലീകരണങ്ങൾ

സ്റ്റാൻഡേർഡ് ബിപിഎഫിന് പുറമേ, ലിനക്സും tools/bpf/bpf_asm പിന്തുണ ഒപ്പം നിലവാരമില്ലാത്ത സെറ്റ്. അടിസ്ഥാനപരമായി, ഒരു ഘടനയുടെ ഫീൽഡുകൾ ആക്സസ് ചെയ്യാൻ നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു struct sk_buff, ഇത് കേർണലിലെ ഒരു നെറ്റ്‌വർക്ക് പാക്കറ്റിനെ വിവരിക്കുന്നു. എന്നിരുന്നാലും, മറ്റ് തരത്തിലുള്ള സഹായ നിർദ്ദേശങ്ങളും ഉണ്ട്, ഉദാഹരണത്തിന് ldw cpu രജിസ്റ്ററിൽ ലോഡ് ചെയ്യും A ഒരു കേർണൽ ഫംഗ്ഷൻ പ്രവർത്തിപ്പിക്കുന്നതിൻ്റെ ഫലം raw_smp_processor_id(). (BPF-ൻ്റെ പുതിയ പതിപ്പിൽ, മെമ്മറി, ഘടനകൾ, ഇവൻ്റുകൾ എന്നിവ ആക്‌സസ് ചെയ്യുന്നതിനായി ഒരു കൂട്ടം കേർണൽ സഹായികളുമായി പ്രോഗ്രാമുകൾ നൽകുന്നതിനായി ഈ നിലവാരമില്ലാത്ത വിപുലീകരണങ്ങൾ വിപുലീകരിച്ചിരിക്കുന്നു.) ഞങ്ങൾ പകർത്തുന്ന ഫിൽട്ടറിൻ്റെ രസകരമായ ഒരു ഉദാഹരണം ഇതാ. വിപുലീകരണം ഉപയോഗിച്ച് ഉപയോക്തൃ സ്ഥലത്തേക്ക് പാക്കറ്റ് തലക്കെട്ടുകൾ poff, പേലോഡ് ഓഫ്‌സെറ്റ്:

ld poff
ret a

ബിപിഎഫ് എക്സ്റ്റൻഷനുകൾ ഉപയോഗിക്കാൻ കഴിയില്ല tcpdump, എന്നാൽ യൂട്ടിലിറ്റി പാക്കേജ് പരിചയപ്പെടാൻ ഇത് ഒരു നല്ല കാരണമാണ് netsniff-ng, മറ്റ് കാര്യങ്ങൾക്കൊപ്പം, ഒരു വിപുലമായ പ്രോഗ്രാം അടങ്ങിയിരിക്കുന്നു netsniff-ng, ഇതിൽ, BPF ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നതിനു പുറമേ, ഫലപ്രദമായ ട്രാഫിക് ജനറേറ്ററും അടങ്ങിയിരിക്കുന്നു, കൂടാതെ കൂടുതൽ വിപുലമായ tools/bpf/bpf_asm, ഒരു ബിപിഎഫ് അസംബ്ലർ വിളിച്ചു bpfc. പാക്കേജിൽ വിശദമായ ഡോക്യുമെൻ്റേഷൻ അടങ്ങിയിരിക്കുന്നു, ലേഖനത്തിൻ്റെ അവസാനത്തെ ലിങ്കുകളും കാണുക.

സെക്കന്റ്

അതിനാൽ, അനിയന്ത്രിതമായ സങ്കീർണ്ണതയുടെ BPF പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതാമെന്ന് ഞങ്ങൾക്കറിയാം, കൂടാതെ പുതിയ ഉദാഹരണങ്ങൾ നോക്കാൻ തയ്യാറാണ്, അതിൽ ആദ്യത്തേത് seccomp സാങ്കേതികവിദ്യയാണ്, ഇത് BPF ഫിൽട്ടറുകൾ ഉപയോഗിച്ച്, ലഭ്യമായ സിസ്റ്റം കോൾ ആർഗ്യുമെൻ്റുകളുടെ സെറ്റും സെറ്റും നിയന്ത്രിക്കാൻ അനുവദിക്കുന്നു. ഒരു നിശ്ചിത പ്രക്രിയയും അതിൻ്റെ പിൻഗാമികളും.

2005-ൽ seccomp-ൻ്റെ ആദ്യ പതിപ്പ് കേർണലിലേക്ക് ചേർത്തു, അത് വളരെ ജനപ്രിയമായിരുന്നില്ല, കാരണം ഇത് ഒരൊറ്റ ഓപ്ഷൻ മാത്രമേ നൽകിയിട്ടുള്ളൂ - ഒരു പ്രോസസ്സിലേക്ക് ലഭ്യമായ സിസ്റ്റം കോളുകളുടെ സെറ്റ് ഇനിപ്പറയുന്നവയിലേക്ക് പരിമിതപ്പെടുത്താൻ: read, write, exit и sigreturn, കൂടാതെ നിയമങ്ങൾ ലംഘിച്ച പ്രക്രിയ ഉപയോഗിച്ച് കൊന്നു SIGKILL. എന്നിരുന്നാലും, 2012-ൽ, BPF ഫിൽട്ടറുകൾ ഉപയോഗിക്കാനുള്ള കഴിവ് seccomp ചേർത്തു, ഇത് അനുവദനീയമായ സിസ്റ്റം കോളുകളുടെ ഒരു കൂട്ടം നിർവ്വചിക്കാനും അവയുടെ ആർഗ്യുമെൻ്റുകളിൽ പരിശോധന നടത്താനും നിങ്ങളെ അനുവദിക്കുന്നു. (രസകരമെന്നു പറയട്ടെ, ഈ പ്രവർത്തനത്തിൻ്റെ ആദ്യ ഉപയോക്താക്കളിൽ ഒരാളായിരുന്നു Chrome, കൂടാതെ Chrome ആളുകൾ നിലവിൽ BPF-ൻ്റെ ഒരു പുതിയ പതിപ്പിനെ അടിസ്ഥാനമാക്കി ഒരു KRSI സംവിധാനം വികസിപ്പിക്കുകയും Linux സെക്യൂരിറ്റി മൊഡ്യൂളുകളുടെ ഇഷ്‌ടാനുസൃതമാക്കൽ അനുവദിക്കുകയും ചെയ്യുന്നു.) അധിക ഡോക്യുമെൻ്റേഷനിലേക്കുള്ള ലിങ്കുകൾ അവസാനം കണ്ടെത്താനാകും. ലേഖനത്തിൻ്റെ.

seccomp ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് ഹബ്ബിൽ ഇതിനകം തന്നെ ലേഖനങ്ങൾ ഉണ്ടായിട്ടുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക, ഇനിപ്പറയുന്ന ഉപവിഭാഗങ്ങൾ വായിക്കുന്നതിന് മുമ്പ് (അല്ലെങ്കിൽ പകരം) ആരെങ്കിലും അവ വായിക്കാൻ ആഗ്രഹിച്ചേക്കാം. ലേഖനത്തിൽ കണ്ടെയ്നറുകളും സുരക്ഷയും: seccomp 2007-ലെ പതിപ്പും BPF ഉപയോഗിച്ചുള്ള പതിപ്പും seccomp ഉപയോഗിക്കുന്നതിൻ്റെ ഉദാഹരണങ്ങൾ നൽകുന്നു (ലിബ്സെക്കോമ്പ് ഉപയോഗിച്ചാണ് ഫിൽട്ടറുകൾ സൃഷ്ടിക്കുന്നത്), ഡോക്കറുമായുള്ള സെക്കോമ്പിൻ്റെ കണക്ഷനെക്കുറിച്ച് സംസാരിക്കുന്നു, കൂടാതെ ധാരാളം ഉപയോഗപ്രദമായ ലിങ്കുകളും നൽകുന്നു. ലേഖനത്തിൽ systemd ഉപയോഗിച്ച് ഡെമണുകളെ ഒറ്റപ്പെടുത്തുന്നു അല്ലെങ്കിൽ "ഇതിന് നിങ്ങൾക്ക് ഡോക്കർ ആവശ്യമില്ല!" സിസ്റ്റംഡിയിൽ പ്രവർത്തിക്കുന്ന ഡെമണുകൾക്കുള്ള സിസ്റ്റം കോളുകളുടെ ബ്ലാക്ക്‌ലിസ്റ്റുകളോ വൈറ്റ്‌ലിസ്റ്റുകളോ എങ്ങനെ ചേർക്കാം എന്നത് ഇത് ഉൾക്കൊള്ളുന്നു.

അടുത്തതായി ഫിൽട്ടറുകൾ എങ്ങനെ എഴുതാമെന്നും ലോഡ് ചെയ്യാമെന്നും നോക്കാം seccomp നഗ്നമായ C യിലും ലൈബ്രറി ഉപയോഗിക്കുകയും ചെയ്യുന്നു libseccomp ഓരോ ഓപ്ഷൻ്റെയും ഗുണദോഷങ്ങൾ എന്തൊക്കെയാണ്, അവസാനമായി, പ്രോഗ്രാം എങ്ങനെ seccomp ഉപയോഗിക്കുന്നുവെന്ന് നോക്കാം strace.

seccomp-നായി ഫിൽട്ടറുകൾ എഴുതുകയും ലോഡുചെയ്യുകയും ചെയ്യുന്നു

BPF പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതണമെന്ന് ഞങ്ങൾക്കറിയാം, അതിനാൽ നമുക്ക് ആദ്യം seccomp പ്രോഗ്രാമിംഗ് ഇൻ്റർഫേസ് നോക്കാം. നിങ്ങൾക്ക് പ്രോസസ്സ് തലത്തിൽ ഒരു ഫിൽട്ടർ സജ്ജമാക്കാൻ കഴിയും, കൂടാതെ എല്ലാ ചൈൽഡ് പ്രോസസുകളും നിയന്ത്രണങ്ങൾ അവകാശമാക്കും. ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് seccomp(2):

seccomp(SECCOMP_SET_MODE_FILTER, flags, &filter)

എവിടെ &filter - ഇത് നമുക്ക് ഇതിനകം പരിചിതമായ ഒരു ഘടനയിലേക്കുള്ള ഒരു സൂചനയാണ് struct sock_fprog, അതായത്. ബിപിഎഫ് പ്രോഗ്രാം.

seccomp-നുള്ള പ്രോഗ്രാമുകൾ സോക്കറ്റുകൾക്കുള്ള പ്രോഗ്രാമുകളിൽ നിന്ന് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു? സംപ്രേഷണം ചെയ്ത സന്ദർഭം. സോക്കറ്റുകളുടെ കാര്യത്തിൽ, ഞങ്ങൾക്ക് പാക്കറ്റ് അടങ്ങിയ ഒരു മെമ്മറി ഏരിയ നൽകി, സെക്കോമ്പിൻ്റെ കാര്യത്തിൽ ഞങ്ങൾക്ക് ഇതുപോലെ ഒരു ഘടന നൽകി

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

ഇത് nr ലോഞ്ച് ചെയ്യേണ്ട സിസ്റ്റം കോളിൻ്റെ നമ്പറാണ്, arch - നിലവിലെ വാസ്തുവിദ്യ (ഇതിൽ കൂടുതൽ താഴെ), args - ആറ് വരെ സിസ്റ്റം കോൾ ആർഗ്യുമെൻ്റുകൾ, കൂടാതെ instruction_pointer സിസ്റ്റം കോൾ ഉണ്ടാക്കിയ ഉപയോക്തൃ സ്പേസ് നിർദ്ദേശത്തിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്. അങ്ങനെ, ഉദാഹരണത്തിന്, രജിസ്റ്ററിലേക്ക് സിസ്റ്റം കോൾ നമ്പർ ലോഡ് ചെയ്യാൻ A ഞങ്ങൾ പറയണം

ldw [0]

seccomp പ്രോഗ്രാമുകൾക്കായി മറ്റ് സവിശേഷതകളുണ്ട്, ഉദാഹരണത്തിന്, സന്ദർഭം 32-ബിറ്റ് വിന്യാസത്തിലൂടെ മാത്രമേ ആക്‌സസ് ചെയ്യാൻ കഴിയൂ, നിങ്ങൾക്ക് ഒരു ഫിൽട്ടർ ലോഡുചെയ്യാൻ ശ്രമിക്കുമ്പോൾ പകുതി വാക്കോ ബൈറ്റോ ലോഡ് ചെയ്യാൻ കഴിയില്ല. ldh [0] സിസ്റ്റം കോൾ seccomp തിരിച്ചു വരും EINVAL. ലോഡ് ചെയ്ത ഫിൽട്ടറുകൾ ഫംഗ്ഷൻ പരിശോധിക്കുന്നു seccomp_check_filter() കേർണലുകൾ. (തമാശയുള്ള കാര്യം, seccomp ഫംഗ്‌ഷണാലിറ്റി ചേർത്ത യഥാർത്ഥ കമ്മിറ്റിൽ, ഈ ഫംഗ്‌ഷനിലേക്ക് നിർദ്ദേശം ഉപയോഗിക്കാനുള്ള അനുമതി ചേർക്കാൻ അവർ മറന്നു. mod (ഡിവിഷൻ ബാക്കി) കൂടാതെ ഇപ്പോൾ സെക്കോംപ് ബിപിഎഫ് പ്രോഗ്രാമുകൾക്ക് ഇത് ലഭ്യമല്ല, അത് ചേർത്തതിന് ശേഷം തകർക്കും എബിഐ.)

അടിസ്ഥാനപരമായി, 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

നേറ്റീവ് കോഡിലോ ബിപിഎഫ് അസംബ്ലിയിലോ ഫിൽട്ടറുകൾ എഴുതുന്നത് ഫലത്തിൽ പൂർണ്ണ നിയന്ത്രണം നേടാൻ നിങ്ങളെ അനുവദിക്കുന്നു, എന്നാൽ അതേ സമയം, പോർട്ടബിൾ കൂടാതെ/അല്ലെങ്കിൽ റീഡബിൾ കോഡ് ഉണ്ടായിരിക്കുന്നതാണ് നല്ലത്. ഇതിന് ലൈബ്രറി നമ്മെ സഹായിക്കും 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]);
}

ആദ്യം നമ്മൾ ഒരു അറേ നിർവചിക്കുന്നു sys_numbers ബ്ലോക്ക് ചെയ്യാനുള്ള 40+ സിസ്റ്റം കോൾ നമ്പറുകൾ. തുടർന്ന്, സന്ദർഭം ആരംഭിക്കുക ctx ഞങ്ങൾ അനുവദിക്കാൻ ആഗ്രഹിക്കുന്നത് ലൈബ്രറിയോട് പറയുക (SCMP_ACT_ALLOW) ഡിഫോൾട്ടായി എല്ലാ സിസ്റ്റം കോളുകളും (ബ്ലാക്ക്‌ലിസ്റ്റുകൾ നിർമ്മിക്കുന്നത് എളുപ്പമാണ്). തുടർന്ന്, ബ്ലാക്ക്‌ലിസ്റ്റിൽ നിന്നുള്ള എല്ലാ സിസ്റ്റം കോളുകളും ഞങ്ങൾ ഒന്നൊന്നായി ചേർക്കുന്നു. ലിസ്റ്റിൽ നിന്നുള്ള ഒരു സിസ്റ്റം കോളിന് പ്രതികരണമായി, ഞങ്ങൾ അഭ്യർത്ഥിക്കുന്നു SCMP_ACT_TRAP, ഈ സാഹചര്യത്തിൽ seccomp പ്രക്രിയയിലേക്ക് ഒരു സിഗ്നൽ അയയ്ക്കും SIGSYS ഏത് സിസ്റ്റം കോൾ നിയമങ്ങൾ ലംഘിച്ചുവെന്നതിൻ്റെ വിവരണത്തോടൊപ്പം. അവസാനമായി, ഞങ്ങൾ പ്രോഗ്രാം ഉപയോഗിച്ച് കേർണലിലേക്ക് ലോഡ് ചെയ്യുന്നു 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, നിസ്സാരമല്ലാത്ത കോഡ് നാല് വരികളായി ഘടിപ്പിക്കുന്നു. മുകളിലുള്ള ഉദാഹരണത്തിൽ, ധാരാളം സിസ്റ്റം കോളുകൾ ഉണ്ടെങ്കിൽ, എക്സിക്യൂഷൻ സമയം ഗണ്യമായി കുറയ്ക്കാൻ കഴിയും, കാരണം പരിശോധന താരതമ്യങ്ങളുടെ ഒരു ലിസ്റ്റ് മാത്രമാണ്. ഒപ്റ്റിമൈസേഷനായി, libseccomp അടുത്തിടെ ഉണ്ടായിരുന്നു പാച്ച് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, ഇത് ഫിൽട്ടർ ആട്രിബ്യൂട്ടിനുള്ള പിന്തുണ ചേർക്കുന്നു SCMP_FLTATR_CTL_OPTIMIZE. ഈ ആട്രിബ്യൂട്ട് 2 ആയി സജ്ജീകരിക്കുന്നത് ഫിൽട്ടറിനെ ഒരു ബൈനറി തിരയൽ പ്രോഗ്രാമാക്കി മാറ്റും.

ബൈനറി തിരയൽ ഫിൽട്ടറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണണമെങ്കിൽ, നോക്കുക ലളിതമായ സ്ക്രിപ്റ്റ്, സിസ്റ്റം കോൾ നമ്പറുകൾ ഡയൽ ചെയ്തുകൊണ്ട് 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 പ്രോഗ്രാമുകൾക്ക് ഇൻഡൻ്റേഷൻ ജമ്പ് ചെയ്യാൻ കഴിയാത്തതിനാൽ നിങ്ങൾക്ക് കാര്യമായി വേഗത്തിൽ ഒന്നും എഴുതാൻ കഴിയില്ല (ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് ചെയ്യാൻ കഴിയില്ല, jmp A അഥവാ jmp [label+X]) അതിനാൽ എല്ലാ സംക്രമണങ്ങളും നിശ്ചലമാണ്.

seccomp ആൻഡ് strace

പ്രയോജനം എല്ലാവർക്കും അറിയാം strace Linux-ലെ പ്രക്രിയകളുടെ സ്വഭാവം പഠിക്കുന്നതിനുള്ള ഒരു ഒഴിച്ചുകൂടാനാവാത്ത ഉപകരണമാണ്. എന്നിരുന്നാലും, പലരും ഇതിനെക്കുറിച്ച് കേട്ടിട്ടുണ്ട് പ്രകടന പ്രശ്നങ്ങൾ ഈ യൂട്ടിലിറ്റി ഉപയോഗിക്കുമ്പോൾ. എന്നതാണ് വസ്തുത strace ഉപയോഗിച്ച് നടപ്പിലാക്കി ptrace(2), കൂടാതെ ഈ മെക്കാനിസത്തിൽ, ഏത് സിസ്റ്റം കോളുകളുടെ സെറ്റിലാണ് നമുക്ക് പ്രോസസ്സ് നിർത്തേണ്ടതെന്ന് വ്യക്തമാക്കാൻ കഴിയില്ല, അതായത്, ഉദാഹരണത്തിന്, കമാൻഡുകൾ

$ 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 നിന്ന് കണ്ടെത്താനാകും സമീപകാല റിപ്പോർട്ട്. ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം, ഏറ്റവും രസകരമായ വസ്തുത, seccomp പ്രതിനിധീകരിക്കുന്ന ക്ലാസിക് BPF ഇന്നും ഉപയോഗിക്കുന്നു എന്നതാണ്.

xt_bpf

ഇനി നമുക്ക് നെറ്റ്‌വർക്കുകളുടെ ലോകത്തേക്ക് മടങ്ങാം.

പശ്ചാത്തലം: വളരെക്കാലം മുമ്പ്, 2007 ൽ, കോർ ആയിരുന്നു കൂട്ടിച്ചേർത്തു മൊഡ്യൂൾ xt_u32 നെറ്റ്ഫിൽട്ടറിനായി. അതിലും പ്രാചീനമായ ഒരു ട്രാഫിക്ക് ക്ലാസിഫയറുമായുള്ള സാമ്യം ഉപയോഗിച്ചാണ് ഇത് എഴുതിയത് cls_u32 ഇനിപ്പറയുന്ന ലളിതമായ പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് iptables-ന് അനിയന്ത്രിതമായ ബൈനറി നിയമങ്ങൾ എഴുതാൻ നിങ്ങളെ അനുവദിച്ചു: ഒരു പാക്കേജിൽ നിന്ന് 32 ബിറ്റുകൾ ലോഡുചെയ്ത് അവയിൽ ഒരു കൂട്ടം ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുക. ഉദാഹരണത്തിന്,

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

IP ഹെഡറിൻ്റെ 32 ബിറ്റുകൾ ലോഡുചെയ്യുന്നു, പാഡിംഗ് 6-ൽ ആരംഭിക്കുന്നു, അവയ്ക്ക് ഒരു മാസ്ക് പ്രയോഗിക്കുന്നു 0xFF (കുറഞ്ഞ ബൈറ്റ് എടുക്കുക). ഈ ഫീൽഡ് protocol IP തലക്കെട്ടും ഞങ്ങൾ അതിനെ 1 (ICMP) മായി താരതമ്യം ചെയ്യുന്നു. നിങ്ങൾക്ക് ഒരു നിയമത്തിൽ നിരവധി ചെക്കുകൾ സംയോജിപ്പിക്കാൻ കഴിയും, കൂടാതെ നിങ്ങൾക്ക് ഓപ്പറേറ്ററെ എക്സിക്യൂട്ട് ചെയ്യാനും കഴിയും @ — X ബൈറ്റുകൾ വലത്തേക്ക് നീക്കുക. ഉദാഹരണത്തിന്, ഭരണം

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

TCP സീക്വൻസ് നമ്പർ തുല്യമല്ലെങ്കിൽ പരിശോധിക്കുന്നു 0x29. അത്തരം നിയമങ്ങൾ കൈകൊണ്ട് എഴുതുന്നത് വളരെ സൗകര്യപ്രദമല്ലെന്ന് ഇതിനകം വ്യക്തമായതിനാൽ ഞാൻ കൂടുതൽ വിശദാംശങ്ങളിലേക്ക് പോകില്ല. ലേഖനത്തിൽ ബിപിഎഫ് - മറന്നുപോയ ബൈറ്റ്കോഡ്, ഉപയോഗത്തിൻ്റെയും നിയമനിർമ്മാണത്തിൻ്റെയും ഉദാഹരണങ്ങളുള്ള നിരവധി ലിങ്കുകൾ ഉണ്ട് xt_u32. ഈ ലേഖനത്തിൻ്റെ അവസാനത്തെ ലിങ്കുകളും കാണുക.

മൊഡ്യൂളിന് പകരം 2013 മുതൽ മൊഡ്യൂൾ xt_u32 നിങ്ങൾക്ക് ഒരു BPF അടിസ്ഥാനമാക്കിയുള്ള മൊഡ്യൂൾ ഉപയോഗിക്കാം xt_bpf. ഇതുവരെ വായിച്ചിട്ടുള്ള ആർക്കും അതിൻ്റെ പ്രവർത്തന തത്വത്തെക്കുറിച്ച് വ്യക്തമായിരിക്കണം: BPF bytecode iptables നിയമങ്ങളായി പ്രവർത്തിപ്പിക്കുക. നിങ്ങൾക്ക് ഒരു പുതിയ നിയമം സൃഷ്ടിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഇതുപോലെ:

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

ഇവിടെ <байткод> - അസംബ്ലർ ഔട്ട്പുട്ട് ഫോർമാറ്റിലുള്ള കോഡാണിത് 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 ഒരു പേരിനായുള്ള DNS അന്വേഷണവുമായി പൊരുത്തപ്പെടുന്ന ഒരു BPF പ്രോഗ്രാം നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും 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 ഡാറ്റാഗ്രാമിനുള്ളിൽ, തുടർന്ന് അഭ്യർത്ഥന പരിശോധിക്കുക: 0x04686162 <-> "x04hab" അതുപോലെ.

കുറച്ച് കഴിഞ്ഞ്, Cloudfare p0f -> BPF കമ്പൈലർ കോഡ് പ്രസിദ്ധീകരിച്ചു. ലേഖനത്തിൽ p0f BPF കമ്പൈലർ അവതരിപ്പിക്കുന്നു 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,
...

നിലവിൽ ക്ലൗഡ്ഫെയർ ഉപയോഗിക്കുന്നില്ല xt_bpf, അവർ XDP-യിലേക്ക് മാറിയതിനാൽ - BPF-ൻ്റെ പുതിയ പതിപ്പ് ഉപയോഗിക്കുന്നതിനുള്ള ഓപ്ഷനുകളിലൊന്ന്, കാണുക. L4Drop: XDP DDoS മിറ്റിഗേഷൻസ്.

cls_bpf

കെർണലിൽ ക്ലാസിക് ബിപിഎഫ് ഉപയോഗിക്കുന്നതിൻ്റെ അവസാന ഉദാഹരണം ക്ലാസിഫയർ ആണ് cls_bpf ലിനക്സിലെ ട്രാഫിക് കൺട്രോൾ സബ്സിസ്റ്റത്തിനായി, 2013 അവസാനത്തോടെ ലിനക്സിലേക്ക് കൂട്ടിച്ചേർക്കുകയും പുരാതനമായതിനെ ആശയപരമായി മാറ്റിസ്ഥാപിക്കുകയും ചെയ്തു. cls_u32.

എന്നിരുന്നാലും, ഞങ്ങൾ ഇപ്പോൾ ജോലിയെ വിവരിക്കുന്നില്ല cls_bpf, ക്ലാസിക് ബിപിഎഫിനെക്കുറിച്ചുള്ള അറിവിൻ്റെ വീക്ഷണകോണിൽ നിന്ന് ഇത് ഞങ്ങൾക്ക് ഒന്നും നൽകില്ല - എല്ലാ പ്രവർത്തനങ്ങളും ഞങ്ങൾ ഇതിനകം പരിചിതമായിക്കഴിഞ്ഞു. കൂടാതെ, വിപുലീകൃത ബിപിഎഫിനെക്കുറിച്ച് സംസാരിക്കുന്ന തുടർന്നുള്ള ലേഖനങ്ങളിൽ, ഞങ്ങൾ ഒന്നിലധികം തവണ ഈ ക്ലാസിഫയർ കാണും.

ക്ലാസിക് ബിപിഎഫ് സി ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് സംസാരിക്കാതിരിക്കാനുള്ള മറ്റൊരു കാരണം cls_bpf വിപുലീകൃത ബിപിഎഫുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഈ കേസിൽ പ്രയോഗത്തിൻ്റെ വ്യാപ്തി സമൂലമായി ചുരുക്കിയിരിക്കുന്നു എന്നതാണ് പ്രശ്നം: ക്ലാസിക്കൽ പ്രോഗ്രാമുകൾക്ക് പാക്കേജുകളുടെ ഉള്ളടക്കം മാറ്റാനും കോളുകൾക്കിടയിൽ നില സംരക്ഷിക്കാനും കഴിയില്ല.

അതുകൊണ്ട് ക്ലാസിക് ബിപിഎഫിനോട് വിടപറയാനും ഭാവിയിലേക്ക് നോക്കാനുമുള്ള സമയമാണിത്.

ക്ലാസിക് ബിപിഎഫിന് വിട

തൊണ്ണൂറുകളുടെ തുടക്കത്തിൽ വികസിപ്പിച്ച ബിപിഎഫ് സാങ്കേതികവിദ്യ എങ്ങനെ കാൽനൂറ്റാണ്ട് വിജയകരമായി ജീവിക്കുകയും അവസാനം വരെ പുതിയ ആപ്ലിക്കേഷനുകൾ കണ്ടെത്തുകയും ചെയ്തുവെന്ന് ഞങ്ങൾ പരിശോധിച്ചു. എന്നിരുന്നാലും, സ്റ്റാക്ക് മെഷീനുകളിൽ നിന്ന് RISC-ലേക്കുള്ള പരിവർത്തനത്തിന് സമാനമായി, ഇത് ക്ലാസിക് ബിപിഎഫിൻ്റെ വികസനത്തിന് പ്രേരണയായി, 32-കളിൽ 64-ബിറ്റിൽ നിന്ന് XNUMX-ബിറ്റ് മെഷീനുകളിലേക്കുള്ള ഒരു മാറ്റം ഉണ്ടായി, ക്ലാസിക് ബിപിഎഫ് കാലഹരണപ്പെടാൻ തുടങ്ങി. കൂടാതെ, ക്ലാസിക് ബിപിഎഫിൻ്റെ കഴിവുകൾ വളരെ പരിമിതമാണ്, കാലഹരണപ്പെട്ട ആർക്കിടെക്ചറിന് പുറമേ - ബിപിഎഫ് പ്രോഗ്രാമുകളിലേക്കുള്ള കോളുകൾക്കിടയിൽ നില സംരക്ഷിക്കാനുള്ള കഴിവ് ഞങ്ങൾക്ക് ഇല്ല, നേരിട്ടുള്ള ഉപയോക്തൃ ഇടപെടലിന് സാധ്യതയില്ല, സംവദിക്കാനുള്ള സാധ്യതയില്ല. കേർണലിനൊപ്പം, പരിമിതമായ സ്ട്രക്ചർ ഫീൽഡുകൾ വായിക്കുന്നത് ഒഴികെ sk_buff ഏറ്റവും ലളിതമായ സഹായ പ്രവർത്തനങ്ങൾ സമാരംഭിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് പാക്കറ്റുകളുടെ ഉള്ളടക്കം മാറ്റാനും റീഡയറക്‌ടുചെയ്യാനും കഴിയില്ല.

വാസ്തവത്തിൽ, നിലവിൽ ലിനക്സിലെ ക്ലാസിക് ബിപിഎഫിൽ അവശേഷിക്കുന്നത് എപിഐ ഇൻ്റർഫേസാണ്, കൂടാതെ കേർണലിനുള്ളിൽ എല്ലാ ക്ലാസിക് പ്രോഗ്രാമുകളും സോക്കറ്റ് ഫിൽട്ടറുകളോ സെക്കോമ്പ് ഫിൽട്ടറുകളോ ആകട്ടെ, വിപുലീകരിച്ച ബിപിഎഫ് എന്ന പുതിയ ഫോർമാറ്റിലേക്ക് സ്വയമേവ വിവർത്തനം ചെയ്യപ്പെടുന്നു. (ഇത് എങ്ങനെ സംഭവിക്കുന്നു എന്നതിനെക്കുറിച്ച് അടുത്ത ലേഖനത്തിൽ നമ്മൾ സംസാരിക്കും.)

ഒരു പുതിയ വാസ്തുവിദ്യയിലേക്കുള്ള മാറ്റം 2013-ൽ ആരംഭിച്ചു, അലക്സി സ്റ്റാരോവോയിറ്റോവ് ഒരു ബിപിഎഫ് അപ്‌ഡേറ്റ് സ്കീം നിർദ്ദേശിച്ചതോടെയാണ്. 2014-ൽ അനുബന്ധ പാച്ചുകൾ പ്രത്യക്ഷപ്പെടാൻ തുടങ്ങി കാമ്പിൽ. ഞാൻ മനസ്സിലാക്കിയിടത്തോളം, 64-ബിറ്റ് മെഷീനുകളിൽ കൂടുതൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കുന്നതിന് ആർക്കിടെക്ചറും JIT കംപൈലറും ഒപ്റ്റിമൈസ് ചെയ്യുക മാത്രമായിരുന്നു പ്രാരംഭ പദ്ധതി, പകരം ഈ ഒപ്റ്റിമൈസേഷനുകൾ ലിനക്സ് വികസനത്തിൽ ഒരു പുതിയ അധ്യായത്തിന് തുടക്കം കുറിച്ചു.

ഈ പരമ്പരയിലെ കൂടുതൽ ലേഖനങ്ങൾ പുതിയ സാങ്കേതികവിദ്യയുടെ ആർക്കിടെക്ചറും പ്രയോഗങ്ങളും ഉൾക്കൊള്ളുന്നു, തുടക്കത്തിൽ ഇൻ്റേണൽ ബിപിഎഫ് എന്നും പിന്നീട് വിപുലീകൃത ബിപിഎഫ് എന്നും ഇപ്പോൾ ലളിതമായി ബിപിഎഫ് എന്നും അറിയപ്പെട്ടിരുന്നു.

റെഫറൻസുകൾ

1. സ്റ്റീവൻ മക്കാനെയും വാൻ ജേക്കബ്‌സണും, "ദി ബിഎസ്‌ഡി പാക്കറ്റ് ഫിൽട്ടർ: ഉപയോക്തൃ തലത്തിലുള്ള പാക്കറ്റ് ക്യാപ്‌ചറിനുള്ള പുതിയ ആർക്കിടെക്ചർ", https://www.tcpdump.org/papers/bpf-usenix93.pdf
2. സ്റ്റീവൻ മക്കാൻ, "libpcap: പാക്കറ്റ് ക്യാപ്‌ചറിനായുള്ള ഒരു വാസ്തുവിദ്യയും ഒപ്റ്റിമൈസേഷൻ രീതിയും", https://sharkfestus.wireshark.org/sharkfest.11/presentations/McCanne-Sharkfest'11_Keynote_Address.pdf
3. tcpdump, libpcap: https://www.tcpdump.org/
4. IPtable U32 മാച്ച് ട്യൂട്ടോറിയൽ.
5. BPF - മറന്നുപോയ ബൈറ്റ്കോഡ്: https://blog.cloudflare.com/bpf-the-forgotten-bytecode/
6. BPF ടൂൾ അവതരിപ്പിക്കുന്നു: https://blog.cloudflare.com/introducing-the-bpf-tools/
7. bpf_cls: http://man7.org/linux/man-pages/man8/tc-bpf.8.html
8. ഒരു സെക്കൻ്റ് അവലോകനം: https://lwn.net/Articles/656307/
9. https://github.com/torvalds/linux/blob/master/Documentation/userspace-api/seccomp_filter.rst
10. habr: പാത്രങ്ങളും സുരക്ഷയും: seccomp
11. habr: systemd ഉപയോഗിച്ച് ഡെമണുകളെ ഒറ്റപ്പെടുത്തുന്നു അല്ലെങ്കിൽ "ഇതിന് നിങ്ങൾക്ക് ഡോക്കർ ആവശ്യമില്ല!"
12. പോൾ ചൈഗ്നൺ, "സ്ട്രേസ് --സെക്കോംപ്-ബിപിഎഫ്: എ ലുക്ക് അണ്ടർ ദി ഹൂഡ്", https://fosdem.org/2020/schedule/event/debugging_strace_bpf/
13. netsniff-ng: http://netsniff-ng.org/

അവലംബം: www.habr.com