નાનાઓ માટે BPF, ભાગ શૂન્ય: ક્લાસિક BPF

બર્કલે પેકેટ ફિલ્ટર્સ (BPF) એ એક Linux કર્નલ ટેકનોલોજી છે જે છેલ્લા ઘણા વર્ષોથી અંગ્રેજી ભાષાના ટેક પ્રકાશનોના પહેલા પાના પર છે. કોન્ફરન્સ BPF ના ઉપયોગ અને વિકાસ પરના અહેવાલોથી ભરેલી છે. ડેવિડ મિલર, લિનક્સ નેટવર્ક સબસિસ્ટમ જાળવનાર, Linux Plumbers 2018 પર તેમની વાત કહે છે "આ ચર્ચા XDP વિશે નથી" (XDP એ BPF માટે એક ઉપયોગનો કેસ છે). બ્રેન્ડન ગ્રેગ હકદાર વાર્તાલાપ આપે છે Linux BPF સુપરપાવર. Toke Høiland-Jørgensen હસે છેકે કર્નલ હવે માઇક્રોકર્નલ છે. થોમસ ગ્રાફ આ વિચારને પ્રોત્સાહન આપે છે BPF કર્નલ માટે જાવાસ્ક્રિપ્ટ છે.

Habré પર હજુ પણ BPF નું કોઈ વ્યવસ્થિત વર્ણન નથી, અને તેથી લેખોની શ્રેણીમાં હું ટેક્નોલોજીના ઇતિહાસ વિશે વાત કરવાનો પ્રયાસ કરીશ, આર્કિટેક્ચર અને વિકાસ સાધનોનું વર્ણન કરીશ અને BPF નો ઉપયોગ કરવાના ક્ષેત્રો અને પ્રેક્ટિસની રૂપરેખા આપીશ. આ લેખ, શૂન્ય, શ્રેણીમાં, ક્લાસિક BPF ના ઇતિહાસ અને આર્કિટેક્ચરને કહે છે, અને તેના સંચાલન સિદ્ધાંતોના રહસ્યો પણ જણાવે છે. tcpdump, seccomp, strace, અને ઘણું બધું.

BPF ના વિકાસને Linux નેટવર્કિંગ સમુદાય દ્વારા નિયંત્રિત કરવામાં આવે છે, BPF ની મુખ્ય વર્તમાન એપ્લિકેશનો નેટવર્ક સાથે સંબંધિત છે અને તેથી પરવાનગી સાથે @eucariot, મેં મહાન શ્રેણીના માનમાં શ્રેણીને “નાના લોકો માટે BPF” કહી "નાના લોકો માટે નેટવર્ક્સ".

બીપીએફના ઇતિહાસમાં ટૂંકો અભ્યાસક્રમ(c)

આધુનિક BPF ટેક્નૉલૉજી એ જ નામની જૂની ટેક્નૉલૉજીનું સુધારેલું અને વિસ્તૃત વર્ઝન છે, જેને મૂંઝવણ ટાળવા માટે હવે ક્લાસિક BPF કહેવાય છે. ક્લાસિક BPF ના આધારે એક જાણીતી ઉપયોગિતા બનાવવામાં આવી હતી tcpdump, મિકેનિઝમ seccomp, તેમજ ઓછા જાણીતા મોડ્યુલો xt_bpf માટે iptables અને વર્ગીકૃત cls_bpf. આધુનિક લિનક્સમાં, ક્લાસિક BPF પ્રોગ્રામ્સ નવા સ્વરૂપમાં આપમેળે અનુવાદિત થાય છે, જો કે, વપરાશકર્તાના દૃષ્ટિકોણથી, API સ્થાને રહ્યું છે અને ક્લાસિક BPF માટે નવા ઉપયોગો, જેમ કે આપણે આ લેખમાં જોઈશું, હજુ પણ જોવા મળી રહ્યા છે. આ કારણોસર, અને એ પણ કારણ કે Linux માં ક્લાસિકલ BPF ના વિકાસના ઇતિહાસને અનુસરીને, તે સ્પષ્ટ થઈ જશે કે તે કેવી રીતે અને શા માટે તેના આધુનિક સ્વરૂપમાં વિકસિત થયું, મેં ક્લાસિકલ BPF વિશેના લેખ સાથે પ્રારંભ કરવાનું નક્કી કર્યું.

છેલ્લી સદીના એંસીના દાયકાના અંતમાં, પ્રખ્યાત લોરેન્સ બર્કલે લેબોરેટરીના ઇજનેરોને છેલ્લી સદીના એંસીના દાયકાના અંતમાં આધુનિક એવા હાર્ડવેર પર નેટવર્ક પેકેટ્સને યોગ્ય રીતે કેવી રીતે ફિલ્ટર કરવું તે પ્રશ્નમાં રસ પડ્યો. ફિલ્ટરિંગનો મૂળ વિચાર, મૂળ રૂપે CSPF (CMU/સ્ટેનફોર્ડ પેકેટ ફિલ્ટર) ટેક્નોલોજીમાં લાગુ કરવામાં આવ્યો હતો, તે શક્ય તેટલી વહેલી તકે બિનજરૂરી પેકેટોને ફિલ્ટર કરવાનો હતો, એટલે કે. કર્નલ સ્પેસમાં, કારણ કે આ બિનજરૂરી ડેટાની યુઝર સ્પેસમાં નકલ કરવાનું ટાળે છે. કર્નલ જગ્યામાં વપરાશકર્તા કોડ ચલાવવા માટે રનટાઇમ સુરક્ષા પૂરી પાડવા માટે, સેન્ડબોક્સવાળી વર્ચ્યુઅલ મશીનનો ઉપયોગ કરવામાં આવ્યો હતો.

જો કે, હાલના ફિલ્ટર્સ માટેની વર્ચ્યુઅલ મશીનો સ્ટેક-આધારિત મશીનો પર ચલાવવા માટે ડિઝાઇન કરવામાં આવી હતી અને નવી RISC મશીનો પર તેટલી અસરકારક રીતે ચાલતી ન હતી. પરિણામે, બર્કલે લેબ્સના એન્જિનિયરોના પ્રયત્નો દ્વારા, નવી BPF (બર્કલે પેકેટ ફિલ્ટર્સ) તકનીક વિકસાવવામાં આવી હતી, જેનું વર્ચ્યુઅલ મશીન આર્કિટેક્ચર Motorola 6502 પ્રોસેસર પર આધારિત હતું - જેમ કે જાણીતા ઉત્પાદનોનું વર્કહોર્સ. એપલ II અથવા એનઈએસ. નવા વર્ચ્યુઅલ મશીને હાલના સોલ્યુશન્સની તુલનામાં ફિલ્ટર પ્રદર્શન દસ ગણું વધાર્યું છે.

BPF મશીન આર્કિટેક્ચર

અમે ઉદાહરણોનું વિશ્લેષણ કરીને, કાર્યકારી રીતે આર્કિટેક્ચરથી પરિચિત થઈશું. જો કે, શરૂ કરવા માટે, ચાલો કહીએ કે મશીનમાં વપરાશકર્તા માટે સુલભ બે 32-બીટ રજિસ્ટર હતા, એક સંચયક A અને ઈન્ડેક્સ રજીસ્ટર X, 64 બાઇટ્સ મેમરી (16 શબ્દો), લેખન અને અનુગામી વાંચન માટે ઉપલબ્ધ છે, અને આ ઑબ્જેક્ટ્સ સાથે કામ કરવા માટે આદેશોની એક નાની સિસ્ટમ. પ્રોગ્રામ્સમાં શરતી અભિવ્યક્તિઓ લાગુ કરવા માટેની સૂચનાઓ પણ ઉપલબ્ધ હતી, પરંતુ પ્રોગ્રામની સમયસર પૂર્ણતાની ખાતરી આપવા માટે, કૂદકા માત્ર આગળ કરી શકાય છે, એટલે કે, ખાસ કરીને, લૂપ્સ બનાવવાની મનાઈ હતી.

મશીન શરૂ કરવા માટેની સામાન્ય યોજના નીચે મુજબ છે. વપરાશકર્તા BPF આર્કિટેક્ચર માટે એક પ્રોગ્રામ બનાવે છે અને તેનો ઉપયોગ કરીને કેટલાક કર્નલ મિકેનિઝમ (જેમ કે સિસ્ટમ કૉલ), પ્રોગ્રામને લોડ કરે છે અને કનેક્ટ કરે છે કેટલાકને કર્નલમાં ઇવેન્ટ જનરેટર પર (ઉદાહરણ તરીકે, ઇવેન્ટ એ નેટવર્ક કાર્ડ પરના આગલા પેકેટનું આગમન છે). જ્યારે કોઈ ઘટના બને છે, ત્યારે કર્નલ પ્રોગ્રામ ચલાવે છે (ઉદાહરણ તરીકે, દુભાષિયામાં), અને મશીન મેમરીને અનુરૂપ કેટલાકને કર્નલ મેમરી પ્રદેશ (ઉદાહરણ તરીકે, ઇનકમિંગ પેકેટનો ડેટા).

ઉપરોક્ત અમારા માટે ઉદાહરણો જોવાનું શરૂ કરવા માટે પૂરતું હશે: અમે સિસ્ટમ અને કમાન્ડ ફોર્મેટ સાથે જરૂરી તરીકે પરિચિત થઈશું. જો તમે વર્ચ્યુઅલ મશીનની કમાન્ડ સિસ્ટમનો તાત્કાલિક અભ્યાસ કરવા અને તેની તમામ ક્ષમતાઓ વિશે જાણવા માંગતા હો, તો તમે મૂળ લેખ વાંચી શકો છો. BSD પેકેટ ફિલ્ટર અને/અથવા ફાઇલનો પ્રથમ અર્ધ દસ્તાવેજીકરણ/networking/filter.txt કર્નલ દસ્તાવેજીકરણમાંથી. વધુમાં, તમે પ્રસ્તુતિનો અભ્યાસ કરી શકો છો libpcap: પેકેટ કેપ્ચર માટે એક આર્કિટેક્ચર અને ઑપ્ટિમાઇઝેશન પદ્ધતિ, જેમાં BPF ના લેખકો પૈકીના એક McCanne, સર્જનના ઇતિહાસ વિશે વાત કરે છે libpcap.

અમે Linux પર ક્લાસિક BPF નો ઉપયોગ કરવાના તમામ નોંધપાત્ર ઉદાહરણોને ધ્યાનમાં લેવા આગળ વધીએ છીએ: tcpdump (libpcap), seccomp, xt_bpf, cls_bpf.

tcpdump

BPF નો વિકાસ પેકેટ ફિલ્ટરિંગ માટે ફ્રન્ટએન્ડના વિકાસ સાથે સમાંતર રીતે હાથ ધરવામાં આવ્યો હતો - એક જાણીતી ઉપયોગિતા tcpdump. અને, ઘણા ઓપરેટિંગ સિસ્ટમ્સ પર ઉપલબ્ધ ક્લાસિક BPF નો ઉપયોગ કરવાનું આ સૌથી જૂનું અને સૌથી પ્રખ્યાત ઉદાહરણ હોવાથી, અમે તેની સાથે ટેક્નોલોજીનો અમારો અભ્યાસ શરૂ કરીશું.

(મેં આ લેખના તમામ ઉદાહરણો Linux પર ચલાવ્યા છે 5.6.0-rc6. કેટલાક આદેશોનું આઉટપુટ વધુ સારી રીતે વાંચી શકાય તે માટે સંપાદિત કરવામાં આવ્યું છે.)

ઉદાહરણ: IPv6 પેકેટોનું અવલોકન

ચાલો કલ્પના કરીએ કે આપણે ઈન્ટરફેસ પરના તમામ IPv6 પેકેટો જોવા માંગીએ છીએ eth0. આ કરવા માટે આપણે પ્રોગ્રામ ચલાવી શકીએ છીએ tcpdump સરળ ફિલ્ટર સાથે ip6:

$ sudo tcpdump -i eth0 ip6

આમ tcpdump ફિલ્ટર કમ્પાઇલ કરે છે ip6 BPF આર્કિટેક્ચર બાયટેકોડમાં અને તેને કર્નલ પર મોકલો (વિભાગમાં વિગતો જુઓ 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 (પેકેજ પ્રકાર) c 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 પેકેટ છે (ઇથર પ્રકાર = 0x800) અને તેને રજીસ્ટરમાં લોડ કરો A પેકેટનો 24મો બાઈટ. અમારું પેકેજ એવું લાગે છે

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

જેનો અર્થ છે કે આપણે રજિસ્ટરમાં લોડ કરીએ છીએ A IP હેડરનું પ્રોટોકોલ ક્ષેત્ર, જે તાર્કિક છે, કારણ કે આપણે ફક્ત TCP પેકેટોની નકલ કરવા માંગીએ છીએ. અમે પ્રોટોકોલ સાથે સરખામણી કરીએ છીએ 0x6 (IPPROTO_TCP) લાઇન 3 પર.

4 અને 5 લીટીઓ પર આપણે એડ્રેસ 20 પર સ્થિત હાફવર્ડ્સ લોડ કરીએ છીએ અને આદેશનો ઉપયોગ કરીએ છીએ jset ત્રણમાંથી એક સેટ છે કે કેમ તે તપાસો ધ્વજ - જારી કરાયેલ માસ્ક પહેરીને jset ત્રણ સૌથી નોંધપાત્ર બિટ્સ સાફ કરવામાં આવે છે. ત્રણમાંથી બે બિટ્સ અમને જણાવે છે કે શું પેકેટ ખંડિત IP પેકેટનો ભાગ છે, અને જો એમ હોય તો, શું તે છેલ્લો ટુકડો છે. ત્રીજો બીટ આરક્ષિત છે અને શૂન્ય હોવો જોઈએ. અમે અપૂર્ણ અથવા તૂટેલા પેકેટો તપાસવા માંગતા નથી, તેથી અમે ત્રણેય બિટ્સ તપાસીએ છીએ.

આ સૂચિમાં લાઇન 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)). તે સ્પષ્ટ છે કે આ સંબોધન યોજના 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 બાઇટકોડ કેવી રીતે લોડ કરીએ છીએ તેના પર વિગતવાર ધ્યાન આપ્યું નથી. સામાન્ય રીતે કહીએ તો, tcpdump ઘણી સિસ્ટમો પર પોર્ટેડ અને ફિલ્ટર્સ સાથે કામ કરવા માટે 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
...

આઉટપુટની પ્રથમ બે લીટીઓ પર આપણે બનાવીએ છીએ કાચો સોકેટ તમામ ઈથરનેટ ફ્રેમ વાંચવા અને તેને ઈન્ટરફેસ સાથે જોડવા માટે 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 લાઇન પર શું થાય છે? તે તારણ આપે છે કે આ libpcap અમારી સંભાળ રાખે છે - જેથી અમારા ફિલ્ટરના આઉટપુટમાં તે પેકેટો શામેલ ન હોય જે તેને સંતોષતા નથી, પુસ્તકાલય જોડે છે બનાવટી ફિલ્ટર ret #0 (બધા પેકેટો છોડો), સોકેટને નોન-બ્લોકીંગ મોડ પર સ્વિચ કરે છે અને અગાઉના ફિલ્ટરમાંથી રહી શકે તેવા તમામ પેકેટોને બાદ કરવાનો પ્રયાસ કરે છે.

કુલ મળીને, ક્લાસિક BPF નો ઉપયોગ કરીને લિનક્સ પર પેકેજોને ફિલ્ટર કરવા માટે, તમારે બંધારણના સ્વરૂપમાં ફિલ્ટર હોવું જરૂરી છે જેમ કે struct sock_fprog અને એક ખુલ્લું સોકેટ, જેના પછી સિસ્ટમ કોલનો ઉપયોગ કરીને ફિલ્ટરને સોકેટ સાથે જોડી શકાય છે setsockopt.

રસપ્રદ રીતે, ફિલ્ટરને કોઈપણ સોકેટ સાથે જોડી શકાય છે, માત્ર કાચા જ નહીં. અહીં ઉદાહરણ એક પ્રોગ્રામ જે આવનારા UDP ડેટાગ્રામમાંથી પ્રથમ બે બાઇટ્સ સિવાય તમામને કાપી નાખે છે. (મેં કોડમાં ટિપ્પણીઓ ઉમેરી છે જેથી લેખમાં ગડબડ ન થાય.)

ઉપયોગ વિશે વધુ વિગતો setsockopt ફિલ્ટર્સને કનેક્ટ કરવા માટે, જુઓ સોકેટ(7), પરંતુ તમારા પોતાના ફિલ્ટર્સ જેવા લખવા વિશે struct sock_fprog મદદ વગર tcpdump અમે વિભાગમાં વાત કરીશું આપણા પોતાના હાથથી BPF પ્રોગ્રામિંગ.

ઉત્તમ BPF અને XNUMXમી સદી

BPF 1997 માં Linux માં સમાવવામાં આવ્યું હતું અને તે લાંબા સમયથી વર્કહોર્સ રહ્યું છે libpcap કોઈપણ ખાસ ફેરફારો વિના (લિનક્સ-વિશિષ્ટ ફેરફારો, અલબત્ત, તે, પરંતુ તેઓએ વૈશ્વિક ચિત્ર બદલ્યું નથી). પ્રથમ ગંભીર સંકેતો કે BPF વિકસિત થશે 2011 માં, જ્યારે એરિક ડુમાઝેટે પ્રસ્તાવ મૂક્યો પેચ, જે કર્નલમાં જસ્ટ ઈન ટાઈમ કમ્પાઈલર ઉમેરે છે - BPF બાઈટકોડને મૂળમાં રૂપાંતરિત કરવા માટેનું અનુવાદક x86_64 કોડ

JIT કમ્પાઇલર ફેરફારોની સાંકળમાં પ્રથમ હતું: 2012 માં દેખાયા માટે ફિલ્ટર્સ લખવાની ક્ષમતા સેકમ્પ, BPF નો ઉપયોગ કરીને, જાન્યુઆરી 2013 માં હતો ઉમેર્યું મોડ્યુલ xt_bpf, જે તમને નિયમો લખવા માટે પરવાનગી આપે છે iptables BPF ની મદદ સાથે, અને ઓક્ટોબર 2013 માં હતી ઉમેર્યું એક મોડ્યુલ પણ cls_bpf, જે તમને BPF નો ઉપયોગ કરીને ટ્રાફિક વર્ગીકરણ લખવા માટે પરવાનગી આપે છે.

અમે આ તમામ ઉદાહરણોને ટૂંક સમયમાં વધુ વિગતમાં જોઈશું, પરંતુ પ્રથમ તે અમારા માટે BPF માટે મનસ્વી પ્રોગ્રામ્સ કેવી રીતે લખવા અને કમ્પાઈલ કરવા તે શીખવા માટે ઉપયોગી થશે, કારણ કે પુસ્તકાલય દ્વારા પ્રદાન કરવામાં આવેલી ક્ષમતાઓ libpcap મર્યાદિત (સરળ ઉદાહરણ: ફિલ્ટર જનરેટ libpcap ફક્ત બે મૂલ્યો પરત કરી શકે છે - 0 અથવા 0x40000) અથવા સામાન્ય રીતે, જેમ કે સેકકોમ્પના કિસ્સામાં, લાગુ પડતું નથી.

આપણા પોતાના હાથથી BPF પ્રોગ્રામિંગ

ચાલો BPF સૂચનાઓના બાઈનરી ફોર્મેટથી પરિચિત થઈએ, તે ખૂબ જ સરળ છે:

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

દરેક સૂચના 64 બિટ્સ ધરાવે છે, જેમાં પ્રથમ 16 બિટ્સ સૂચના કોડ છે, પછી બે આઠ-બિટ ઇન્ડેન્ટ્સ છે, jt и jf, અને દલીલ માટે 32 બિટ્સ 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))

મશીન કોડના રૂપમાં પ્રોગ્રામ્સ લખવા એ ખૂબ અનુકૂળ નથી, પરંતુ કેટલીકવાર તે જરૂરી છે (ઉદાહરણ તરીકે, ડિબગીંગ માટે, એકમ પરીક્ષણો બનાવવા, હેબ્રે પર લેખો લખવા વગેરે). સગવડ માટે, ફાઇલમાં <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),
}

જો કે, આ વિકલ્પ ખૂબ અનુકૂળ નથી. આ તે છે જે Linux કર્નલ પ્રોગ્રામરોએ તર્ક આપ્યો છે, અને તેથી ડિરેક્ટરીમાં 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 એક્સ્ટેંશન

પ્રમાણભૂત BPF ઉપરાંત, Linux અને tools/bpf/bpf_asm આધાર અને બિન-માનક સમૂહ. મૂળભૂત રીતે, સૂચનાઓનો ઉપયોગ માળખાના ક્ષેત્રોને ઍક્સેસ કરવા માટે થાય છે struct sk_buff, જે કર્નલમાં નેટવર્ક પેકેટનું વર્ણન કરે છે. જો કે, અન્ય પ્રકારની સહાયક સૂચનાઓ પણ છે, ઉદાહરણ તરીકે ldw cpu રજિસ્ટરમાં લોડ થશે A કર્નલ ફંક્શન ચલાવવાનું પરિણામ raw_smp_processor_id(). (BPF ના નવા સંસ્કરણમાં, મેમરી, સ્ટ્રક્ચર્સ અને ઇવેન્ટ્સ જનરેટ કરવા માટે કર્નલ સહાયકોના સમૂહ સાથે પ્રોગ્રામ્સ પ્રદાન કરવા માટે આ બિન-માનક એક્સ્ટેન્શન્સને વિસ્તૃત કરવામાં આવ્યા છે.) અહીં ફિલ્ટરનું એક રસપ્રદ ઉદાહરણ છે જેમાં આપણે ફક્ત કોપી કરીએ છીએ. એક્સ્ટેંશનનો ઉપયોગ કરીને વપરાશકર્તા જગ્યામાં પેકેટ હેડરો poff, પેલોડ ઓફસેટ:

ld poff
ret a

BPF એક્સ્ટેંશનનો ઉપયોગ કરી શકાતો નથી tcpdump, પરંતુ ઉપયોગિતા પેકેજથી પરિચિત થવાનું આ એક સારું કારણ છે netsniff-ng, જે, અન્ય વસ્તુઓની સાથે, એક અદ્યતન પ્રોગ્રામ ધરાવે છે netsniff-ng, જે, BPF નો ઉપયોગ કરીને ફિલ્ટર કરવા ઉપરાંત, અસરકારક ટ્રાફિક જનરેટર પણ ધરાવે છે, અને તેના કરતા વધુ અદ્યતન tools/bpf/bpf_asm, એક BPF એસેમ્બલરને બોલાવવામાં આવ્યો bpfc. પેકેજમાં ખૂબ વિગતવાર દસ્તાવેજો છે, લેખના અંતે લિંક્સ પણ જુઓ.

સેકમ્પ

તેથી, આપણે પહેલાથી જ જાણીએ છીએ કે મનસ્વી જટિલતાના BPF પ્રોગ્રામ્સ કેવી રીતે લખવા અને નવા ઉદાહરણો જોવા માટે તૈયાર છીએ, જેમાંથી પ્રથમ સેકકોમ્પ ટેક્નોલોજી છે, જે BPF ફિલ્ટર્સનો ઉપયોગ કરીને, ઉપલબ્ધ સિસ્ટમ કૉલ દલીલોના સેટ અને સેટનું સંચાલન કરવાની મંજૂરી આપે છે. આપેલ પ્રક્રિયા અને તેના વંશજો.

seccomp નું પ્રથમ સંસ્કરણ 2005 માં કર્નલમાં ઉમેરવામાં આવ્યું હતું અને તે ખૂબ લોકપ્રિય ન હતું, કારણ કે તે ફક્ત એક જ વિકલ્પ પૂરો પાડે છે - પ્રક્રિયા માટે ઉપલબ્ધ સિસ્ટમ કૉલ્સના સેટને નીચેના સુધી મર્યાદિત કરવા: read, write, exit и sigreturn, અને નિયમોનું ઉલ્લંઘન કરતી પ્રક્રિયાનો ઉપયોગ કરીને હત્યા કરવામાં આવી હતી SIGKILL. જો કે, 2012 માં, seccomp એ BPF ફિલ્ટર્સનો ઉપયોગ કરવાની ક્ષમતા ઉમેરી, જેનાથી તમે માન્ય સિસ્ટમ કૉલ્સના સમૂહને વ્યાખ્યાયિત કરી શકો છો અને તેમની દલીલો પર તપાસ પણ કરી શકો છો. (રસપ્રદ વાત એ છે કે, ક્રોમ આ કાર્યક્ષમતાના પ્રથમ વપરાશકર્તાઓમાંનું એક હતું, અને ક્રોમ લોકો હાલમાં BPF ના નવા સંસ્કરણ પર આધારિત KRSI મિકેનિઝમ વિકસાવી રહ્યા છે અને Linux સુરક્ષા મોડ્યુલ્સને કસ્ટમાઇઝ કરવાની મંજૂરી આપે છે.) વધારાના દસ્તાવેજોની લિંક્સ અંતે મળી શકે છે. લેખના.

નોંધ કરો કે સેકકોમ્પનો ઉપયોગ કરવા વિશે હબ પર પહેલાથી જ લેખો છે, કદાચ કોઈ તેને નીચેના પેટાવિભાગો વાંચતા પહેલા (અથવા તેના બદલે) વાંચવા માંગશે. લેખમાં કન્ટેનર અને સુરક્ષા: seccomp seccomp નો ઉપયોગ કરવાના ઉદાહરણો પૂરા પાડે છે, બંને 2007 સંસ્કરણ અને BPF નો ઉપયોગ કરીને સંસ્કરણ (ફિલ્ટર્સ libseccomp નો ઉપયોગ કરીને જનરેટ થાય છે), ડોકર સાથે seccomp ના જોડાણ વિશે વાત કરે છે, અને ઘણી ઉપયોગી લિંક્સ પણ પૂરી પાડે છે. લેખમાં સિસ્ટમ્ડ સાથે ડિમન્સને અલગ કરવું અથવા "તમને આ માટે ડોકરની જરૂર નથી!" તે આવરી લે છે, ખાસ કરીને, કેવી રીતે બ્લેકલિસ્ટ્સ અથવા સિસ્ટમ કૉલ્સની વ્હાઇટલિસ્ટ્સ સિસ્ટમ પર ચાલી રહેલ ડિમન માટે કેવી રીતે ઉમેરવી.

આગળ આપણે જોઈશું કે ફિલ્ટર્સ કેવી રીતે લખવા અને લોડ કરવા seccomp એકદમ સીમાં અને પુસ્તકાલયનો ઉપયોગ કરીને libseccomp અને દરેક વિકલ્પના ફાયદા અને ગેરફાયદા શું છે, અને અંતે, ચાલો જોઈએ કે પ્રોગ્રામ દ્વારા સેકકોમ્પનો ઉપયોગ કેવી રીતે થાય છે strace.

સેકકોમ્પ માટે ફિલ્ટર્સ લખવું અને લોડ કરવું

BPF પ્રોગ્રામ્સ કેવી રીતે લખવા તે આપણે પહેલાથી જ જાણીએ છીએ, તો ચાલો પહેલા seccomp પ્રોગ્રામિંગ ઈન્ટરફેસ જોઈએ. તમે પ્રક્રિયા સ્તર પર ફિલ્ટર સેટ કરી શકો છો, અને તમામ બાળ પ્રક્રિયાઓ પ્રતિબંધો વારસામાં મેળવશે. આ સિસ્ટમ કૉલનો ઉપયોગ કરીને કરવામાં આવે છે seccomp(2):

seccomp(SECCOMP_SET_MODE_FILTER, flags, &filter)

જ્યાં &filter - આ અમને પહેલેથી જ પરિચિત માળખું માટે નિર્દેશક છે struct sock_fprog, એટલે કે BPF કાર્યક્રમ.

સેકકોમ્પ માટેના પ્રોગ્રામ્સ સોકેટ્સ માટેના પ્રોગ્રામ્સથી કેવી રીતે અલગ પડે છે? પ્રસારિત સંદર્ભ. સોકેટ્સના કિસ્સામાં, અમને પેકેટ ધરાવતો મેમરી વિસ્તાર આપવામાં આવ્યો હતો, અને સેકકોમ્પના કિસ્સામાં અમને એક માળખું આપવામાં આવ્યું હતું જેમ કે

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

તે nr લોંચ થનાર સિસ્ટમ કોલનો નંબર છે, arch - વર્તમાન આર્કિટેક્ચર (નીચે આના પર વધુ), args - છ સુધી સિસ્ટમ કૉલ દલીલો, અને instruction_pointer એ યુઝર સ્પેસ સૂચના માટે એક નિર્દેશક છે જેણે સિસ્ટમ કોલ કર્યો હતો. આમ, ઉદાહરણ તરીકે, રજિસ્ટરમાં સિસ્ટમ કૉલ નંબર લોડ કરવા માટે A આપણે કહેવું પડશે

ldw [0]

સેકકોમ્પ પ્રોગ્રામ્સ માટે અન્ય સુવિધાઓ છે, ઉદાહરણ તરીકે, સંદર્ભ ફક્ત 32-બીટ ગોઠવણી દ્વારા જ ઍક્સેસ કરી શકાય છે અને તમે અડધો શબ્દ અથવા બાઈટ લોડ કરી શકતા નથી - જ્યારે ફિલ્ટર લોડ કરવાનો પ્રયાસ કરી રહ્યા હોય ldh [0] સિસ્ટમ કૉલ seccomp પાછા આવસે EINVAL. ફંક્શન લોડ કરેલા ફિલ્ટર્સને તપાસે છે seccomp_check_filter() કર્નલો (મજાની વાત એ છે કે, મૂળ કમિટમાં જે સેકકોમ્પ કાર્યક્ષમતા ઉમેરે છે, તેઓ આ કાર્યમાં સૂચનાનો ઉપયોગ કરવાની પરવાનગી ઉમેરવાનું ભૂલી ગયા હતા. mod (વિભાગ શેષ) અને હવે સેકકોમ્પ BPF પ્રોગ્રામ્સ માટે અનુપલબ્ધ છે, ત્યારથી તેના ઉમેરાથી તૂટી જશે ABI.)

મૂળભૂત રીતે, આપણે સેકકોમ્પ પ્રોગ્રામ લખવા અને વાંચવા માટે પહેલાથી જ બધું જાણીએ છીએ. સામાન્ય રીતે પ્રોગ્રામ લોજિક સિસ્ટમ કૉલ્સની સફેદ અથવા કાળી સૂચિ તરીકે ગોઠવવામાં આવે છે, ઉદાહરણ તરીકે પ્રોગ્રામ

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]);
}

પ્રથમ આપણે એરે વ્યાખ્યાયિત કરીએ છીએ 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, અને તેથી વધુ.

સેકકોમ્પ સાથે, જો કે, આ પ્રક્રિયાને આપણે ઇચ્છીએ તે રીતે બરાબર ઑપ્ટિમાઇઝ કરી શકાય છે. જેમ કે, જો આપણે ફક્ત સિસ્ટમ કૉલને જોવા માંગીએ છીએ 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 આજે પણ ઉપયોગમાં લેવાય છે.

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. હું વધુ વિગતોમાં જઈશ નહીં, કારણ કે તે પહેલેથી જ સ્પષ્ટ છે કે આવા નિયમો હાથથી લખવા ખૂબ અનુકૂળ નથી. લેખમાં BPF - ભૂલી ગયેલા બાયટેકોડ, માટે ઉપયોગ અને નિયમ બનાવવાના ઉદાહરણો સાથે ઘણી લિંક્સ છે xt_u32. આ લેખના અંતે લિંક્સ પણ જુઓ.

2013 થી મોડ્યુલને બદલે મોડ્યુલ xt_u32 તમે BPF આધારિત મોડ્યુલનો ઉપયોગ કરી શકો છો xt_bpf. કોઈપણ જેણે આ અત્યાર સુધી વાંચ્યું છે તે તેના ઓપરેશનના સિદ્ધાંત વિશે પહેલેથી જ સ્પષ્ટ હોવું જોઈએ: iptables નિયમો તરીકે BPF બાયટેકોડ ચલાવો. તમે એક નવો નિયમ બનાવી શકો છો, ઉદાહરણ તરીકે, આના જેવું:

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" અને તેથી પર

થોડી વાર પછી, ક્લાઉડફેરે 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

કર્નલમાં ક્લાસિક BPF નો ઉપયોગ કરવાનું છેલ્લું ઉદાહરણ ક્લાસિફાયર છે cls_bpf લિનક્સમાં ટ્રાફિક કંટ્રોલ સબસિસ્ટમ માટે, 2013ના અંતમાં લિનક્સમાં ઉમેરવામાં આવ્યું હતું અને વૈચારિક રીતે પ્રાચીનને બદલીને cls_u32.

જો કે, અમે હવે કાર્યનું વર્ણન કરીશું નહીં cls_bpf, કારણ કે ક્લાસિક BPF વિશેના જ્ઞાનના દૃષ્ટિકોણથી આ અમને કંઈપણ આપશે નહીં - અમે પહેલેથી જ બધી કાર્યક્ષમતાથી પરિચિત થઈ ગયા છીએ. વધુમાં, વિસ્તૃત BPF વિશે વાત કરતા અનુગામી લેખોમાં, અમે આ વર્ગીકરણકર્તાને એક કરતા વધુ વાર મળીશું.

ક્લાસિક BPF નો ઉપયોગ કરવા વિશે વાત ન કરવાનું બીજું કારણ c cls_bpf સમસ્યા એ છે કે, વિસ્તૃત BPF ની તુલનામાં, આ કિસ્સામાં લાગુ થવાનો અવકાશ ધરમૂળથી સંકુચિત છે: ક્લાસિકલ પ્રોગ્રામ્સ પેકેજોની સામગ્રીને બદલી શકતા નથી અને કૉલ્સ વચ્ચે સ્થિતિ સાચવી શકતા નથી.

તેથી ક્લાસિક BPF ને અલવિદા કહેવાનો અને ભવિષ્ય તરફ ધ્યાન આપવાનો આ સમય છે.

ક્લાસિક BPF ને વિદાય

અમે જોયું કે કેવી રીતે નેવુંના દાયકાની શરૂઆતમાં વિકસિત થયેલ BPF ટેક્નોલોજી, એક સદીના એક ક્વાર્ટર સુધી સફળતાપૂર્વક જીવી અને અંત સુધી નવી એપ્લિકેશન મળી. જો કે, સ્ટેક મશીનોથી RISC માં સંક્રમણની જેમ, જે ક્લાસિક BPF ના વિકાસ માટે પ્રોત્સાહન તરીકે સેવા આપી હતી, 32 ના દાયકામાં 64-bit થી XNUMX-bit મશીનોમાં સંક્રમણ થયું હતું અને ક્લાસિક BPF અપ્રચલિત થવા લાગ્યું હતું. વધુમાં, ક્લાસિક BPF ની ક્ષમતાઓ ખૂબ જ મર્યાદિત છે, અને જૂના આર્કિટેક્ચર ઉપરાંત - અમારી પાસે BPF પ્રોગ્રામ્સ પરના કૉલ્સ વચ્ચે રાજ્ય બચાવવાની ક્ષમતા નથી, વપરાશકર્તાની સીધી ક્રિયાપ્રતિક્રિયાની કોઈ શક્યતા નથી, ક્રિયાપ્રતિક્રિયાની કોઈ શક્યતા નથી. કર્નલ સાથે, મર્યાદિત સંખ્યામાં સ્ટ્રક્ચર ફીલ્ડ્સ વાંચવા સિવાય sk_buff અને સૌથી સરળ હેલ્પર ફંક્શન્સ લોન્ચ કરીને, તમે પેકેટોની સામગ્રી બદલી શકતા નથી અને તેમને રીડાયરેક્ટ કરી શકતા નથી.

વાસ્તવમાં, હાલમાં Linux માં ક્લાસિક BPF ના બાકી રહેલ તમામ API ઇન્ટરફેસ છે, અને કર્નલની અંદર તમામ ક્લાસિક પ્રોગ્રામ્સ, પછી ભલે તે સોકેટ ફિલ્ટર્સ હોય કે seccomp ફિલ્ટર્સ, એક નવા ફોર્મેટ, વિસ્તૃત BPFમાં આપમેળે અનુવાદિત થાય છે. (આ કેવી રીતે થાય છે તે વિશે અમે આગલા લેખમાં વાત કરીશું.)

નવા આર્કિટેક્ચરમાં સંક્રમણ 2013 માં શરૂ થયું, જ્યારે એલેક્સી સ્ટારોવોઇટોવે BPF અપડેટ સ્કીમનો પ્રસ્તાવ મૂક્યો. 2014 માં અનુરૂપ પેચો દેખાવા લાગ્યા કોર માં. જ્યાં સુધી હું સમજું છું, પ્રારંભિક યોજના ફક્ત આર્કિટેક્ચર અને JIT કમ્પાઈલરને 64-બીટ મશીનો પર વધુ કાર્યક્ષમ રીતે ચલાવવા માટે ઑપ્ટિમાઇઝ કરવાની હતી, પરંતુ તેના બદલે આ ઑપ્ટિમાઇઝેશન્સે Linux વિકાસમાં નવા પ્રકરણની શરૂઆત કરી.

આ શ્રેણીના આગળના લેખો નવી ટેકનોલોજીના આર્કિટેક્ચર અને એપ્લિકેશનને આવરી લેશે, જે શરૂઆતમાં આંતરિક BPF, પછી વિસ્તૃત BPF અને હવે ફક્ત BPF તરીકે ઓળખાય છે.

સંદર્ભો

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