ਛੋਟੇ ਬੱਚਿਆਂ ਲਈ BPF, ਭਾਗ ਜ਼ੀਰੋ: ਕਲਾਸਿਕ BPF

ਬਰਕਲੇ ਪੈਕੇਟ ਫਿਲਟਰਸ (BPF) ਇੱਕ ਲੀਨਕਸ ਕਰਨਲ ਤਕਨਾਲੋਜੀ ਹੈ ਜੋ ਪਿਛਲੇ ਕਈ ਸਾਲਾਂ ਤੋਂ ਅੰਗਰੇਜ਼ੀ-ਭਾਸ਼ਾ ਦੇ ਤਕਨੀਕੀ ਪ੍ਰਕਾਸ਼ਨਾਂ ਦੇ ਪਹਿਲੇ ਪੰਨਿਆਂ 'ਤੇ ਹੈ। ਕਾਨਫਰੰਸਾਂ ਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਅਤੇ ਵਿਕਾਸ ਬਾਰੇ ਰਿਪੋਰਟਾਂ ਨਾਲ ਭਰੀਆਂ ਹੋਈਆਂ ਹਨ। ਡੇਵਿਡ ਮਿਲਰ, ਲੀਨਕਸ ਨੈੱਟਵਰਕ ਸਬ-ਸਿਸਟਮ ਮੇਨਟੇਨਰ, ਲੀਨਕਸ ਪਲੰਬਰਜ਼ 2018 'ਤੇ ਆਪਣੇ ਭਾਸ਼ਣ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ "ਇਹ ਗੱਲਬਾਤ XDP ਬਾਰੇ ਨਹੀਂ ਹੈ" (XDP BPF ਲਈ ਇੱਕ ਵਰਤੋਂ ਦਾ ਕੇਸ ਹੈ)। ਬ੍ਰੈਂਡਨ ਗ੍ਰੇਗ ਨੇ ਸਿਰਲੇਖ ਵਾਲੇ ਭਾਸ਼ਣ ਦਿੱਤੇ ਲੀਨਕਸ ਬੀਪੀਐਫ ਸੁਪਰਪਾਵਰਜ਼. ਟੋਕ ਹੋਇਲੈਂਡ-ਜੋਰਗਨਸਨ ਹੱਸਦਾ ਹੈਕਿ ਕਰਨਲ ਹੁਣ ਮਾਈਕ੍ਰੋਕਰਨੇਲ ਹੈ। ਥਾਮਸ ਗ੍ਰਾਫ਼ ਇਸ ਵਿਚਾਰ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹੈ BPF ਕਰਨਲ ਲਈ ਜਾਵਾਸਕ੍ਰਿਪਟ ਹੈ.

Habré 'ਤੇ BPF ਦਾ ਅਜੇ ਵੀ ਕੋਈ ਵਿਵਸਥਿਤ ਵਰਣਨ ਨਹੀਂ ਹੈ, ਅਤੇ ਇਸਲਈ ਲੇਖਾਂ ਦੀ ਇੱਕ ਲੜੀ ਵਿੱਚ ਮੈਂ ਤਕਨਾਲੋਜੀ ਦੇ ਇਤਿਹਾਸ ਬਾਰੇ ਗੱਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗਾ, ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਵਿਕਾਸ ਸਾਧਨਾਂ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ, ਅਤੇ BPF ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕਾਰਜ ਅਤੇ ਅਭਿਆਸ ਦੇ ਖੇਤਰਾਂ ਦੀ ਰੂਪਰੇਖਾ ਬਣਾਵਾਂਗਾ। ਇਹ ਲੇਖ, ਜ਼ੀਰੋ, ਲੜੀ ਵਿੱਚ, ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਇਤਿਹਾਸ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਦੱਸਦਾ ਹੈ, ਅਤੇ ਇਸਦੇ ਓਪਰੇਟਿੰਗ ਸਿਧਾਂਤਾਂ ਦੇ ਭੇਦ ਵੀ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ। tcpdump, seccomp, strace, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ।

ਬੀਪੀਐਫ ਦੇ ਵਿਕਾਸ ਨੂੰ ਲੀਨਕਸ ਨੈਟਵਰਕਿੰਗ ਕਮਿਊਨਿਟੀ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਬੀਪੀਐਫ ਦੀਆਂ ਮੁੱਖ ਮੌਜੂਦਾ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੈਟਵਰਕ ਨਾਲ ਸਬੰਧਤ ਹਨ ਅਤੇ ਇਸਲਈ, ਇਜਾਜ਼ਤ ਨਾਲ @eucariot, ਮੈਂ ਮਹਾਨ ਲੜੀ ਦੇ ਸਨਮਾਨ ਵਿੱਚ ਲੜੀ ਨੂੰ "ਛੋਟੇ ਬੱਚਿਆਂ ਲਈ BPF" ਕਿਹਾ "ਛੋਟੇ ਬੱਚਿਆਂ ਲਈ ਨੈੱਟਵਰਕ".

ਬੀਪੀਐਫ ਦੇ ਇਤਿਹਾਸ ਵਿੱਚ ਇੱਕ ਛੋਟਾ ਕੋਰਸ (c)

ਆਧੁਨਿਕ BPF ਤਕਨਾਲੋਜੀ ਉਸੇ ਨਾਮ ਨਾਲ ਪੁਰਾਣੀ ਤਕਨਾਲੋਜੀ ਦਾ ਇੱਕ ਸੁਧਾਰਿਆ ਅਤੇ ਵਿਸਤ੍ਰਿਤ ਰੂਪ ਹੈ, ਜਿਸਨੂੰ ਹੁਣ ਉਲਝਣ ਤੋਂ ਬਚਣ ਲਈ ਕਲਾਸਿਕ BPF ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਮਸ਼ਹੂਰ ਉਪਯੋਗਤਾ ਬਣਾਈ ਗਈ ਸੀ tcpdump, ਵਿਧੀ seccomp, ਨਾਲ ਹੀ ਘੱਟ ਜਾਣੇ ਜਾਂਦੇ ਮੋਡੀਊਲ xt_bpf ਨੂੰ iptables ਅਤੇ ਵਰਗੀਕਰਣਕਾਰ cls_bpf. ਆਧੁਨਿਕ ਲੀਨਕਸ ਵਿੱਚ, ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਾਂ ਦਾ ਆਪਣੇ ਆਪ ਹੀ ਨਵੇਂ ਰੂਪ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਹਾਲਾਂਕਿ, ਉਪਭੋਗਤਾ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਏਪੀਆਈ ਕਾਇਮ ਹੈ ਅਤੇ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਲਈ ਨਵੇਂ ਉਪਯੋਗ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਦੇਖਾਂਗੇ, ਅਜੇ ਵੀ ਲੱਭੇ ਜਾ ਰਹੇ ਹਨ। ਇਸ ਕਾਰਨ ਕਰਕੇ, ਅਤੇ ਇਹ ਵੀ ਕਿਉਂਕਿ ਲੀਨਕਸ ਵਿੱਚ ਕਲਾਸੀਕਲ ਬੀਪੀਐਫ ਦੇ ਵਿਕਾਸ ਦੇ ਇਤਿਹਾਸ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋਏ, ਇਹ ਸਪੱਸ਼ਟ ਹੋ ਜਾਵੇਗਾ ਕਿ ਇਹ ਇਸਦੇ ਆਧੁਨਿਕ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਅਤੇ ਕਿਉਂ ਵਿਕਸਤ ਹੋਇਆ, ਮੈਂ ਕਲਾਸੀਕਲ ਬੀਪੀਐਫ ਬਾਰੇ ਇੱਕ ਲੇਖ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ।

ਪਿਛਲੀ ਸਦੀ ਦੇ ਅੱਸੀਵਿਆਂ ਦੇ ਅੰਤ ਵਿੱਚ, ਮਸ਼ਹੂਰ ਲਾਰੈਂਸ ਬਰਕਲੇ ਲੈਬਾਰਟਰੀ ਦੇ ਇੰਜੀਨੀਅਰ ਇਸ ਸਵਾਲ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਸਨ ਕਿ ਪਿਛਲੀ ਸਦੀ ਦੇ ਅੱਸੀਵਿਆਂ ਦੇ ਅਖੀਰ ਵਿੱਚ ਆਧੁਨਿਕ ਹਾਰਡਵੇਅਰ ਉੱਤੇ ਨੈਟਵਰਕ ਪੈਕੇਟਾਂ ਨੂੰ ਕਿਵੇਂ ਫਿਲਟਰ ਕਰਨਾ ਹੈ। ਫਿਲਟਰਿੰਗ ਦਾ ਮੂਲ ਵਿਚਾਰ, ਅਸਲ ਵਿੱਚ CSPF (CMU/ਸਟੈਨਫੋਰਡ ਪੈਕੇਟ ਫਿਲਟਰ) ਤਕਨਾਲੋਜੀ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ, ਬੇਲੋੜੇ ਪੈਕੇਟਾਂ ਨੂੰ ਜਿੰਨੀ ਜਲਦੀ ਹੋ ਸਕੇ ਫਿਲਟਰ ਕਰਨਾ ਸੀ, ਯਾਨੀ. ਕਰਨਲ ਸਪੇਸ ਵਿੱਚ, ਕਿਉਂਕਿ ਇਹ ਯੂਜ਼ਰ ਸਪੇਸ ਵਿੱਚ ਬੇਲੋੜੇ ਡੇਟਾ ਦੀ ਨਕਲ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ। ਕਰਨਲ ਸਪੇਸ ਵਿੱਚ ਯੂਜ਼ਰ ਕੋਡ ਚਲਾਉਣ ਲਈ ਰਨਟਾਈਮ ਸੁਰੱਖਿਆ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ, ਇੱਕ ਸੈਂਡਬੌਕਸਡ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਰਤੀ ਗਈ ਸੀ।

ਹਾਲਾਂਕਿ, ਮੌਜੂਦਾ ਫਿਲਟਰਾਂ ਲਈ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਸਟੈਕ-ਅਧਾਰਿਤ ਮਸ਼ੀਨਾਂ 'ਤੇ ਚੱਲਣ ਲਈ ਤਿਆਰ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ ਅਤੇ ਨਵੀਆਂ RISC ਮਸ਼ੀਨਾਂ 'ਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਨਹੀਂ ਚੱਲਦੀਆਂ ਸਨ। ਨਤੀਜੇ ਵਜੋਂ, ਬਰਕਲੇ ਲੈਬਜ਼ ਦੇ ਇੰਜੀਨੀਅਰਾਂ ਦੇ ਯਤਨਾਂ ਦੁਆਰਾ, ਇੱਕ ਨਵੀਂ ਬੀਪੀਐਫ (ਬਰਕਲੇ ਪੈਕੇਟ ਫਿਲਟਰ) ਤਕਨਾਲੋਜੀ ਵਿਕਸਤ ਕੀਤੀ ਗਈ ਸੀ, ਜਿਸਦਾ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਆਰਕੀਟੈਕਚਰ ਮੋਟੋਰੋਲਾ 6502 ਪ੍ਰੋਸੈਸਰ ਦੇ ਅਧਾਰ ਤੇ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ - ਅਜਿਹੇ ਮਸ਼ਹੂਰ ਉਤਪਾਦਾਂ ਦਾ ਵਰਕ ਹਾਰਸ ਐਪਲ II ਜ NES. ਨਵੀਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੇ ਮੌਜੂਦਾ ਹੱਲਾਂ ਦੇ ਮੁਕਾਬਲੇ ਫਿਲਟਰ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਕਈ ਗੁਣਾ ਵਧਾ ਦਿੱਤਾ ਹੈ।

ਬੀਪੀਐਫ ਮਸ਼ੀਨ ਆਰਕੀਟੈਕਚਰ

ਅਸੀਂ ਉਦਾਹਰਨਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੇ ਹੋਏ, ਕਾਰਜਕਾਰੀ ਢੰਗ ਨਾਲ ਆਰਕੀਟੈਕਚਰ ਤੋਂ ਜਾਣੂ ਹੋਵਾਂਗੇ। ਹਾਲਾਂਕਿ, ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਮੰਨ ਲਓ ਕਿ ਮਸ਼ੀਨ ਵਿੱਚ ਉਪਭੋਗਤਾ ਲਈ ਪਹੁੰਚਯੋਗ ਦੋ 32-ਬਿੱਟ ਰਜਿਸਟਰ ਸਨ, ਇੱਕ ਸੰਚਵਕ A ਅਤੇ ਸੂਚਕਾਂਕ ਰਜਿਸਟਰ X, 64 ਬਾਈਟ ਮੈਮੋਰੀ (16 ਸ਼ਬਦ), ਲਿਖਣ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਪੜ੍ਹਨ ਲਈ ਉਪਲਬਧ, ਅਤੇ ਇਹਨਾਂ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਛੋਟੀ ਪ੍ਰਣਾਲੀ। ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਜੰਪ ਨਿਰਦੇਸ਼ ਵੀ ਉਪਲਬਧ ਸਨ, ਪਰ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸਮੇਂ ਸਿਰ ਮੁਕੰਮਲ ਹੋਣ ਦੀ ਗਾਰੰਟੀ ਦੇਣ ਲਈ, ਜੰਪ ਸਿਰਫ਼ ਅੱਗੇ ਹੀ ਕੀਤੇ ਜਾ ਸਕਦੇ ਸਨ, ਯਾਨੀ, ਖਾਸ ਤੌਰ 'ਤੇ, ਲੂਪਸ ਬਣਾਉਣ ਦੀ ਮਨਾਹੀ ਸੀ।

ਮਸ਼ੀਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਆਮ ਸਕੀਮ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ. ਉਪਭੋਗਤਾ BPF ਆਰਕੀਟੈਕਚਰ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ, ਵਰਤਦਾ ਹੈ ਕੁੱਝ ਕਰਨਲ ਮਕੈਨਿਜ਼ਮ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਸਿਸਟਮ ਕਾਲ), ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲੋਡ ਅਤੇ ਕਨੈਕਟ ਕਰਦਾ ਹੈ ਕੁਝ ਨੂੰ ਕਰਨਲ ਵਿੱਚ ਈਵੈਂਟ ਜਨਰੇਟਰ ਨੂੰ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਇਵੈਂਟ ਨੈੱਟਵਰਕ ਕਾਰਡ ਉੱਤੇ ਅਗਲੇ ਪੈਕੇਟ ਦਾ ਆਗਮਨ ਹੈ)। ਜਦੋਂ ਕੋਈ ਘਟਨਾ ਵਾਪਰਦੀ ਹੈ, ਤਾਂ ਕਰਨਲ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਦੁਭਾਸ਼ੀਏ ਵਿੱਚ), ਅਤੇ ਮਸ਼ੀਨ ਦੀ ਮੈਮੋਰੀ ਇਸ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ ਕੁਝ ਨੂੰ ਕਰਨਲ ਮੈਮੋਰੀ ਖੇਤਰ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਆਉਣ ਵਾਲੇ ਪੈਕੇਟ ਦਾ ਡੇਟਾ)।

ਉਪਰੋਕਤ ਸਾਡੇ ਲਈ ਉਦਾਹਰਣਾਂ ਨੂੰ ਵੇਖਣਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਹੋਵੇਗਾ: ਅਸੀਂ ਲੋੜ ਅਨੁਸਾਰ ਸਿਸਟਮ ਅਤੇ ਕਮਾਂਡ ਫਾਰਮੈਟ ਤੋਂ ਜਾਣੂ ਹੋਵਾਂਗੇ। ਜੇ ਤੁਸੀਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਕਮਾਂਡ ਸਿਸਟਮ ਦਾ ਤੁਰੰਤ ਅਧਿਐਨ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਇਸ ਦੀਆਂ ਸਾਰੀਆਂ ਸਮਰੱਥਾਵਾਂ ਬਾਰੇ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਸਲ ਲੇਖ ਪੜ੍ਹ ਸਕਦੇ ਹੋ BSD ਪੈਕੇਟ ਫਿਲਟਰ ਅਤੇ/ਜਾਂ ਫਾਈਲ ਦਾ ਪਹਿਲਾ ਅੱਧ Documentation/networking/filter.txt ਕਰਨਲ ਦਸਤਾਵੇਜ਼ ਤੋਂ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਪੇਸ਼ਕਾਰੀ ਦਾ ਅਧਿਐਨ ਕਰ ਸਕਦੇ ਹੋ libpcap: ਪੈਕੇਟ ਕੈਪਚਰ ਲਈ ਇੱਕ ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਵਿਧੀ, ਜਿਸ ਵਿੱਚ ਮੈਕਕੇਨ, ਬੀਪੀਐਫ ਦੇ ਲੇਖਕਾਂ ਵਿੱਚੋਂ ਇੱਕ, ਰਚਨਾ ਦੇ ਇਤਿਹਾਸ ਬਾਰੇ ਗੱਲ ਕਰਦਾ ਹੈ libpcap.

ਅਸੀਂ ਹੁਣ ਲੀਨਕਸ ਉੱਤੇ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਸਾਰੀਆਂ ਮਹੱਤਵਪੂਰਨ ਉਦਾਹਰਣਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧਦੇ ਹਾਂ: tcpdump (libpcap), seccomp, xt_bpf, cls_bpf.

tcpdump

ਬੀਪੀਐਫ ਦਾ ਵਿਕਾਸ ਪੈਕੇਟ ਫਿਲਟਰਿੰਗ ਲਈ ਫਰੰਟਐਂਡ ਦੇ ਵਿਕਾਸ ਦੇ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਸੀ - ਇੱਕ ਮਸ਼ਹੂਰ ਉਪਯੋਗਤਾ tcpdump. ਅਤੇ, ਕਿਉਂਕਿ ਇਹ ਕਲਾਸਿਕ BPF ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਪੁਰਾਣਾ ਅਤੇ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਉਦਾਹਰਨ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਸਾਰੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ 'ਤੇ ਉਪਲਬਧ ਹੈ, ਅਸੀਂ ਇਸ ਨਾਲ ਤਕਨਾਲੋਜੀ ਦਾ ਆਪਣਾ ਅਧਿਐਨ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।

(ਮੈਂ ਲੀਨਕਸ ਉੱਤੇ ਇਸ ਲੇਖ ਦੀਆਂ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਚਲਾਈਆਂ 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 ਕਿਲੋਬਾਈਟ ਪੈਕੇਜ ਕਾਪੀ ਕਰੋ)।

ਇੱਕ ਹੋਰ ਗੁੰਝਲਦਾਰ ਉਦਾਹਰਨ: ਅਸੀਂ ਟੀਸੀਪੀ ਪੈਕੇਟ ਨੂੰ ਮੰਜ਼ਿਲ ਪੋਰਟ ਦੁਆਰਾ ਦੇਖਦੇ ਹਾਂ

ਆਉ ਦੇਖੀਏ ਕਿ ਇੱਕ ਫਿਲਟਰ ਕਿਹੋ ਜਿਹਾ ਦਿਸਦਾ ਹੈ ਜੋ ਕਿ ਮੰਜ਼ਿਲ ਪੋਰਟ 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 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, i.e. ਅਸੀਂ ਵੀ ਨਹੀਂ ਕਹਿ ਸਕਦੇ 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 ਲੀਨਕਸ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ 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 (ਸਾਰੇ ਪੈਕੇਟ ਛੱਡੋ), ਸਾਕਟ ਨੂੰ ਨਾਨ-ਬਲਾਕਿੰਗ ਮੋਡ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਅਤੇ ਸਾਰੇ ਪੈਕੇਟਾਂ ਨੂੰ ਘਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੋ ਪਿਛਲੇ ਫਿਲਟਰਾਂ ਤੋਂ ਰਹਿ ਸਕਦੇ ਹਨ।

ਕੁਲ ਮਿਲਾ ਕੇ, ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਲੀਨਕਸ ਉੱਤੇ ਪੈਕੇਜਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਢਾਂਚੇ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਫਿਲਟਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਵੇਂ ਕਿ struct sock_fprog ਅਤੇ ਇੱਕ ਖੁੱਲਾ ਸਾਕਟ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਫਿਲਟਰ ਨੂੰ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਾਕਟ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ setsockopt.

ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਫਿਲਟਰ ਨੂੰ ਕਿਸੇ ਵੀ ਸਾਕਟ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ ਕੱਚਾ. ਇਥੇ ਉਦਾਹਰਨ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜੋ ਆਉਣ ਵਾਲੇ ਸਾਰੇ UDP ਡੇਟਾਗ੍ਰਾਮਾਂ ਤੋਂ ਪਹਿਲੇ ਦੋ ਬਾਈਟਾਂ ਨੂੰ ਛੱਡ ਕੇ ਸਭ ਨੂੰ ਕੱਟਦਾ ਹੈ। (ਮੈਂ ਕੋਡ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਹਨ ਤਾਂ ਜੋ ਲੇਖ ਵਿੱਚ ਗੜਬੜ ਨਾ ਹੋਵੇ।)

ਵਰਤੋਂ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ setsockopt ਫਿਲਟਰਾਂ ਨੂੰ ਜੋੜਨ ਲਈ, ਵੇਖੋ ਸਾਕਟ(7), ਪਰ ਆਪਣੇ ਖੁਦ ਦੇ ਫਿਲਟਰ ਲਿਖਣ ਬਾਰੇ ਜਿਵੇਂ ਕਿ struct sock_fprog ਮਦਦ ਦੇ ਬਗੈਰ tcpdump ਅਸੀਂ ਭਾਗ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗੇ ਸਾਡੇ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਿੰਗ.

ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਅਤੇ 21ਵੀਂ ਸਦੀ

ਬੀਪੀਐਫ ਨੂੰ 1997 ਵਿੱਚ ਲੀਨਕਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਇੱਕ ਵਰਕ ਹਾਰਸ ਰਿਹਾ ਹੈ libpcap ਬਿਨਾਂ ਕਿਸੇ ਵਿਸ਼ੇਸ਼ ਤਬਦੀਲੀਆਂ (ਲੀਨਕਸ-ਵਿਸ਼ੇਸ਼ ਤਬਦੀਲੀਆਂ, ਬੇਸ਼ਕ, ਇਹ ਸੀ, ਪਰ ਉਹਨਾਂ ਨੇ ਗਲੋਬਲ ਤਸਵੀਰ ਨੂੰ ਨਹੀਂ ਬਦਲਿਆ)। ਬੀਪੀਐਫ ਦੇ ਵਿਕਾਸ ਦੇ ਪਹਿਲੇ ਗੰਭੀਰ ਸੰਕੇਤ 2011 ਵਿੱਚ ਆਏ ਸਨ, ਜਦੋਂ ਐਰਿਕ ਡੂਮਾਜ਼ੇਟ ਨੇ ਪ੍ਰਸਤਾਵਿਤ ਕੀਤਾ ਸੀ। ਪੈਚ, ਜੋ ਕਿ ਕਰਨਲ ਵਿੱਚ ਜਸਟ ਇਨ ਟਾਈਮ ਕੰਪਾਈਲਰ ਜੋੜਦਾ ਹੈ - ਬੀਪੀਐਫ ਬਾਈਟਕੋਡ ਨੂੰ ਮੂਲ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ ਇੱਕ ਅਨੁਵਾਦਕ x86_64 ਕੋਡ।

JIT ਕੰਪਾਈਲਰ ਤਬਦੀਲੀਆਂ ਦੀ ਲੜੀ ਵਿੱਚ ਪਹਿਲਾ ਸੀ: 2012 ਵਿੱਚ ਪ੍ਰਗਟ ਹੋਇਆ ਲਈ ਫਿਲਟਰ ਲਿਖਣ ਦੀ ਯੋਗਤਾ ਸਕਿੰਟਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜਨਵਰੀ 2013 ਵਿੱਚ ਸੀ ਸ਼ਾਮਲ ਕੀਤਾ ਮੋਡੀ .ਲ xt_bpf, ਜੋ ਤੁਹਾਨੂੰ ਲਈ ਨਿਯਮ ਲਿਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ iptables ਬੀਪੀਐਫ ਦੀ ਮਦਦ ਨਾਲ, ਅਤੇ ਅਕਤੂਬਰ 2013 ਵਿੱਚ ਸੀ ਸ਼ਾਮਲ ਕੀਤਾ ਇੱਕ ਮੋਡੀਊਲ ਵੀ cls_bpf, ਜੋ ਤੁਹਾਨੂੰ BPF ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟ੍ਰੈਫਿਕ ਵਰਗੀਕਰਣ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਅਸੀਂ ਇਹਨਾਂ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਜਲਦੀ ਹੀ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਦੇਖਾਂਗੇ, ਪਰ ਪਹਿਲਾਂ ਇਹ ਸਾਡੇ ਲਈ ਇਹ ਸਿੱਖਣਾ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ ਕਿ BPF ਲਈ ਆਰਬਿਟਰੇਰੀ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਅਤੇ ਕੰਪਾਇਲ ਕਰਨਾ ਹੈ, ਕਿਉਂਕਿ ਲਾਇਬ੍ਰੇਰੀ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਗਈਆਂ ਸਮਰੱਥਾਵਾਂ libpcap ਸੀਮਿਤ (ਸਧਾਰਨ ਉਦਾਹਰਨ: ਫਿਲਟਰ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ libpcap ਸਿਰਫ ਦੋ ਮੁੱਲ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹਨ - 0 ਜਾਂ 0x40000) ਜਾਂ ਆਮ ਤੌਰ 'ਤੇ, ਜਿਵੇਂ ਕਿ seccomp ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਲਾਗੂ ਨਹੀਂ ਹੁੰਦੇ ਹਨ।

ਸਾਡੇ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਿੰਗ

ਆਓ 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> helper macros ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ - ਉਪਰੋਕਤ ਦੇ ਰੂਪ ਵਿੱਚ ਉਹੀ ਉਦਾਹਰਨ ਦੁਬਾਰਾ ਲਿਖੀ ਜਾ ਸਕਦੀ ਹੈ

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,

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 ਐਕਸਟੈਂਸ਼ਨ

ਸਟੈਂਡਰਡ ਬੀਪੀਐਫ ਤੋਂ ਇਲਾਵਾ, ਲੀਨਕਸ ਅਤੇ 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 ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਅਤੇ ਨਵੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਦੇਖਣ ਲਈ ਤਿਆਰ ਹਾਂ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਪਹਿਲੀ ਹੈ seccomp ਤਕਨਾਲੋਜੀ, ਜੋ ਕਿ BPF ਫਿਲਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਉਪਲਬਧ ਸਿਸਟਮ ਕਾਲ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਸੈੱਟ ਅਤੇ ਸੈੱਟ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਇੱਕ ਦਿੱਤੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਇਸਦੇ ਵੰਸ਼ਜ.

seccomp ਦਾ ਪਹਿਲਾ ਸੰਸਕਰਣ 2005 ਵਿੱਚ ਕਰਨਲ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਸੀ ਅਤੇ ਬਹੁਤ ਮਸ਼ਹੂਰ ਨਹੀਂ ਸੀ, ਕਿਉਂਕਿ ਇਸਨੇ ਸਿਰਫ ਇੱਕ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕੀਤਾ ਸੀ - ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ ਉਪਲਬਧ ਸਿਸਟਮ ਕਾਲਾਂ ਦੇ ਸੈੱਟ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਤੱਕ ਸੀਮਤ ਕਰਨ ਲਈ: read, write, exit и sigreturn, ਅਤੇ ਨਿਯਮਾਂ ਦੀ ਉਲੰਘਣਾ ਕਰਨ ਵਾਲੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਰਿਆ ਗਿਆ ਸੀ SIGKILL. ਹਾਲਾਂਕਿ, 2012 ਵਿੱਚ, seccomp ਨੇ BPF ਫਿਲਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਯੋਗਤਾ ਨੂੰ ਜੋੜਿਆ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਸਿਸਟਮ ਕਾਲਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਦਲੀਲਾਂ ਦੀ ਜਾਂਚ ਵੀ ਕਰ ਸਕਦੇ ਹੋ। (ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ, ਕ੍ਰੋਮ ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਪਹਿਲੇ ਉਪਭੋਗਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਸੀ, ਅਤੇ Chrome ਲੋਕ ਵਰਤਮਾਨ ਵਿੱਚ BPF ਦੇ ਇੱਕ ਨਵੇਂ ਸੰਸਕਰਣ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ KRSI ਵਿਧੀ ਵਿਕਸਿਤ ਕਰ ਰਹੇ ਹਨ ਅਤੇ ਲੀਨਕਸ ਸੁਰੱਖਿਆ ਮੋਡੀਊਲ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇ ਰਹੇ ਹਨ।) ਵਾਧੂ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਲਿੰਕ ਅੰਤ ਵਿੱਚ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ ਲੇਖ ਦੇ.

ਨੋਟ ਕਰੋ ਕਿ seccomp ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਹੱਬ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਲੇਖ ਹਨ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਕੋਈ ਵਿਅਕਤੀ ਹੇਠਾਂ ਦਿੱਤੇ ਉਪ-ਭਾਗਾਂ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ (ਜਾਂ ਇਸ ਦੀ ਬਜਾਏ) ਉਹਨਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਚਾਹੇਗਾ। ਲੇਖ ਵਿਚ ਕੰਟੇਨਰ ਅਤੇ ਸੁਰੱਖਿਆ: seccomp seccomp ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, 2007 ਵਰਜਨ ਅਤੇ BPF (ਫਿਲਟਰ libseccomp ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ), ਡੌਕਰ ਨਾਲ seccomp ਦੇ ਕੁਨੈਕਸ਼ਨ ਬਾਰੇ ਗੱਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਕਈ ਉਪਯੋਗੀ ਲਿੰਕ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਲੇਖ ਵਿਚ ਸਿਸਟਮਡ ਜਾਂ "ਤੁਹਾਨੂੰ ਇਸ ਲਈ ਡੌਕਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ!" ਨਾਲ ਡੈਮਨ ਨੂੰ ਅਲੱਗ ਕਰਨਾ ਇਹ ਕਵਰ ਕਰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ, ਸਿਸਟਮਡ ਚੱਲ ਰਹੇ ਡੈਮਨ ਲਈ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀਆਂ ਬਲੈਕਲਿਸਟਾਂ ਜਾਂ ਵਾਈਟਲਿਸਟਾਂ ਨੂੰ ਕਿਵੇਂ ਸ਼ਾਮਲ ਕਰਨਾ ਹੈ।

ਅੱਗੇ ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਫਿਲਟਰ ਕਿਵੇਂ ਲਿਖਣੇ ਅਤੇ ਲੋਡ ਕਰਨੇ ਹਨ seccomp ਬੇਅਰ C ਵਿੱਚ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ libseccomp ਅਤੇ ਹਰੇਕ ਵਿਕਲਪ ਦੇ ਫਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨ ਕੀ ਹਨ, ਅਤੇ ਅੰਤ ਵਿੱਚ, ਆਓ ਦੇਖੀਏ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੁਆਰਾ seccomp ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ strace.

seccomp ਲਈ ਫਿਲਟਰ ਲਿਖਣਾ ਅਤੇ ਲੋਡ ਕਰਨਾ

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਾਂ ਕਿ BPF ਪ੍ਰੋਗਰਾਮ ਕਿਵੇਂ ਲਿਖਣੇ ਹਨ, ਇਸ ਲਈ ਆਓ ਪਹਿਲਾਂ seccomp ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ ਨੂੰ ਵੇਖੀਏ। ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆ ਪੱਧਰ 'ਤੇ ਇੱਕ ਫਿਲਟਰ ਸੈਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਸਾਰੀਆਂ ਬਾਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਪਾਬੰਦੀਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨਗੀਆਂ। ਇਹ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ seccomp(2):

seccomp(SECCOMP_SET_MODE_FILTER, flags, &filter)

ਜਿੱਥੇ &filter - ਇਹ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣੂ ਬਣਤਰ ਦਾ ਸੰਕੇਤ ਹੈ struct sock_fprog, i.e. ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮ.

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 BPF ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਉਪਲਬਧ ਨਹੀਂ ਹੈ ਟੁੱਟ ਜਾਵੇਗਾ 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]);
}

ਪਹਿਲਾਂ ਅਸੀਂ ਇੱਕ ਐਰੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ 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 ਲੀਨਕਸ ਉੱਤੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਵਿਵਹਾਰ ਦਾ ਅਧਿਐਨ ਕਰਨ ਲਈ ਇੱਕ ਲਾਜ਼ਮੀ ਸਾਧਨ ਹੈ। ਹਾਲਾਂਕਿ, ਕਈਆਂ ਨੇ ਇਸ ਬਾਰੇ ਵੀ ਸੁਣਿਆ ਹੈ ਪ੍ਰਦਰਸ਼ਨ ਮੁੱਦੇ ਇਸ ਸਹੂਲਤ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ. ਤੱਥ ਇਹ ਹੈ ਕਿ 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. ਮੈਂ ਹੋਰ ਵੇਰਵਿਆਂ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ, ਕਿਉਂਕਿ ਇਹ ਪਹਿਲਾਂ ਹੀ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਅਜਿਹੇ ਨਿਯਮਾਂ ਨੂੰ ਹੱਥ ਨਾਲ ਲਿਖਣਾ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ. ਲੇਖ ਵਿਚ BPF - ਭੁੱਲਿਆ ਹੋਇਆ ਬਾਈਟਕੋਡ, ਲਈ ਵਰਤੋਂ ਅਤੇ ਨਿਯਮ ਬਣਾਉਣ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਕਈ ਲਿੰਕ ਹਨ xt_u32. ਇਸ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਲਿੰਕ ਵੀ ਦੇਖੋ।

2013 ਤੋਂ ਮੋਡੀਊਲ ਦੀ ਬਜਾਏ ਮੋਡੀਊਲ xt_u32 ਤੁਸੀਂ BPF ਅਧਾਰਤ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ xt_bpf. ਕੋਈ ਵੀ ਜਿਸਨੇ ਇਸ ਨੂੰ ਹੁਣ ਤੱਕ ਪੜ੍ਹਿਆ ਹੈ ਉਸਨੂੰ ਇਸਦੇ ਕਾਰਜ ਦੇ ਸਿਧਾਂਤ ਬਾਰੇ ਪਹਿਲਾਂ ਹੀ ਸਪੱਸ਼ਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: BPF ਬਾਈਟਕੋਡ ਨੂੰ 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 ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਨਾਲੋਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਫਿਲਟਰਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਆਉ ਕਲਾਉਡਫੇਅਰ ਤੋਂ ਅਸਲ ਉਦਾਹਰਣਾਂ ਨੂੰ ਵੇਖੀਏ। ਹਾਲ ਹੀ ਤੱਕ ਉਹ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਨ 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 ਡੇਟਾਗ੍ਰਾਮ ਦੇ ਅੰਦਰ ਅਤੇ ਫਿਰ ਬੇਨਤੀ ਦੀ ਜਾਂਚ ਕਰੋ: 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,
...

ਵਰਤਮਾਨ ਵਿੱਚ Cloudfare ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ xt_bpf, ਕਿਉਂਕਿ ਉਹ XDP ਵਿੱਚ ਚਲੇ ਗਏ ਹਨ - BPF ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ, ਵੇਖੋ। L4Drop: XDP DDoS ਮਿਟੀਗੇਸ਼ਨ.

cls_bpf

ਕਰਨਲ ਵਿੱਚ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਖਰੀ ਉਦਾਹਰਣ ਕਲਾਸੀਫਾਇਰ ਹੈ cls_bpf ਲੀਨਕਸ ਵਿੱਚ ਟ੍ਰੈਫਿਕ ਨਿਯੰਤਰਣ ਉਪ-ਸਿਸਟਮ ਲਈ, 2013 ਦੇ ਅੰਤ ਵਿੱਚ ਲੀਨਕਸ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਅਤੇ ਸੰਕਲਪਿਕ ਤੌਰ 'ਤੇ ਪ੍ਰਾਚੀਨ ਨੂੰ ਬਦਲਿਆ ਗਿਆ। cls_u32.

ਹਾਲਾਂਕਿ, ਅਸੀਂ ਹੁਣ ਕੰਮ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕਰਾਂਗੇ cls_bpf, ਕਿਉਂਕਿ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਬਾਰੇ ਗਿਆਨ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਇਹ ਸਾਨੂੰ ਕੁਝ ਨਹੀਂ ਦੇਵੇਗਾ - ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸਾਰੀਆਂ ਕਾਰਜਸ਼ੀਲਤਾਵਾਂ ਤੋਂ ਜਾਣੂ ਹੋ ਗਏ ਹਾਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਵਿਸਤ੍ਰਿਤ ਬੀਪੀਐਫ ਬਾਰੇ ਗੱਲ ਕਰਨ ਵਾਲੇ ਅਗਲੇ ਲੇਖਾਂ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਵਰਗੀਫਾਇਰ ਨੂੰ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਮਿਲਾਂਗੇ।

ਕਲਾਸਿਕ BPF c ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਗੱਲ ਨਾ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਕਾਰਨ cls_bpf ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ, ਵਿਸਤ੍ਰਿਤ ਬੀਪੀਐਫ ਦੀ ਤੁਲਨਾ ਵਿੱਚ, ਇਸ ਕੇਸ ਵਿੱਚ ਲਾਗੂ ਹੋਣ ਦਾ ਦਾਇਰਾ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸੰਕੁਚਿਤ ਹੈ: ਕਲਾਸੀਕਲ ਪ੍ਰੋਗਰਾਮ ਪੈਕੇਜਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਨਹੀਂ ਬਦਲ ਸਕਦੇ ਅਤੇ ਕਾਲਾਂ ਵਿਚਕਾਰ ਸਥਿਤੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਨ।

ਇਸ ਲਈ ਇਹ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਨੂੰ ਅਲਵਿਦਾ ਕਹਿਣ ਅਤੇ ਭਵਿੱਖ ਵੱਲ ਦੇਖਣ ਦਾ ਸਮਾਂ ਹੈ।

ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਨੂੰ ਅਲਵਿਦਾ

ਅਸੀਂ ਦੇਖਿਆ ਕਿ ਕਿਵੇਂ BPF ਤਕਨਾਲੋਜੀ, ਨੱਬੇ ਦੇ ਦਹਾਕੇ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਵਿਕਸਤ ਹੋਈ, ਇੱਕ ਸਦੀ ਦੇ ਇੱਕ ਚੌਥਾਈ ਹਿੱਸੇ ਤੱਕ ਸਫਲਤਾਪੂਰਵਕ ਜਿਉਂਦੀ ਰਹੀ ਅਤੇ ਅੰਤ ਤੱਕ ਨਵੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲੱਭੀਆਂ। ਹਾਲਾਂਕਿ, ਸਟੈਕ ਮਸ਼ੀਨਾਂ ਤੋਂ ਆਰਆਈਐਸਸੀ ਵਿੱਚ ਤਬਦੀਲੀ ਦੇ ਸਮਾਨ, ਜਿਸਨੇ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਵਿਕਾਸ ਲਈ ਇੱਕ ਪ੍ਰੇਰਣਾ ਵਜੋਂ ਕੰਮ ਕੀਤਾ, 32 ਦੇ ਦਹਾਕੇ ਵਿੱਚ 64-ਬਿੱਟ ਤੋਂ XNUMX-ਬਿੱਟ ਮਸ਼ੀਨਾਂ ਵਿੱਚ ਤਬਦੀਲੀ ਹੋਈ ਅਤੇ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਪੁਰਾਣਾ ਹੋਣਾ ਸ਼ੁਰੂ ਹੋ ਗਿਆ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਬਹੁਤ ਸੀਮਤ ਹਨ, ਅਤੇ ਪੁਰਾਣੀ ਆਰਕੀਟੈਕਚਰ ਤੋਂ ਇਲਾਵਾ - ਸਾਡੇ ਕੋਲ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਕਾਲਾਂ ਦੇ ਵਿਚਕਾਰ ਰਾਜ ਨੂੰ ਬਚਾਉਣ ਦੀ ਸਮਰੱਥਾ ਨਹੀਂ ਹੈ, ਸਿੱਧੇ ਉਪਭੋਗਤਾ ਇੰਟਰੈਕਸ਼ਨ ਦੀ ਕੋਈ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ, ਇੰਟਰੈਕਟ ਕਰਨ ਦੀ ਕੋਈ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ. ਕਰਨਲ ਦੇ ਨਾਲ, ਢਾਂਚਾ ਖੇਤਰਾਂ ਦੀ ਇੱਕ ਸੀਮਤ ਗਿਣਤੀ ਨੂੰ ਪੜ੍ਹਨ ਨੂੰ ਛੱਡ ਕੇ sk_buff ਅਤੇ ਸਭ ਤੋਂ ਸਰਲ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਨਾਲ, ਤੁਸੀਂ ਪੈਕੇਟਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਬਦਲ ਨਹੀਂ ਸਕਦੇ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਰੀਡਾਇਰੈਕਟ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਵਾਸਤਵ ਵਿੱਚ, ਵਰਤਮਾਨ ਵਿੱਚ ਲੀਨਕਸ ਵਿੱਚ ਕਲਾਸਿਕ ਬੀਪੀਐਫ ਦੇ ਬਚੇ ਹੋਏ ਸਾਰੇ ਏਪੀਆਈ ਇੰਟਰਫੇਸ ਹਨ, ਅਤੇ ਕਰਨਲ ਦੇ ਅੰਦਰ ਸਾਰੇ ਕਲਾਸਿਕ ਪ੍ਰੋਗਰਾਮ, ਭਾਵੇਂ ਇਹ ਸਾਕਟ ਫਿਲਟਰ ਜਾਂ ਸੈਕੌਂਪ ਫਿਲਟਰ ਹੋਣ, ਆਪਣੇ ਆਪ ਇੱਕ ਨਵੇਂ ਫਾਰਮੈਟ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਵਿਸਤ੍ਰਿਤ ਬੀਪੀਐਫ। (ਅਸੀਂ ਅਗਲੇ ਲੇਖ ਵਿਚ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ ਕਿ ਇਹ ਕਿਵੇਂ ਹੁੰਦਾ ਹੈ।)

ਇੱਕ ਨਵੇਂ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਤਬਦੀਲੀ 2013 ਵਿੱਚ ਸ਼ੁਰੂ ਹੋਈ, ਜਦੋਂ ਅਲੈਕਸੀ ਸਟਾਰੋਵੋਇਟੋਵ ਨੇ ਇੱਕ BPF ਅਪਡੇਟ ਸਕੀਮ ਦਾ ਪ੍ਰਸਤਾਵ ਕੀਤਾ। 2014 ਵਿੱਚ ਅਨੁਸਾਰੀ ਪੈਚ ਦਿਖਾਈ ਦੇਣ ਲੱਗਾ ਕੋਰ ਵਿੱਚ. ਜਿੱਥੋਂ ਤੱਕ ਮੈਂ ਸਮਝਦਾ ਹਾਂ, ਅਸਲ ਯੋਜਨਾ ਸਿਰਫ 64-ਬਿੱਟ ਮਸ਼ੀਨਾਂ 'ਤੇ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਚਲਾਉਣ ਲਈ ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਜੇਆਈਟੀ ਕੰਪਾਈਲਰ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਸੀ, ਪਰ ਇਸ ਦੀ ਬਜਾਏ ਇਹਨਾਂ ਅਨੁਕੂਲਤਾਵਾਂ ਨੇ ਲੀਨਕਸ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਇੱਕ ਨਵੇਂ ਅਧਿਆਏ ਦੀ ਸ਼ੁਰੂਆਤ ਕੀਤੀ।

ਇਸ ਲੜੀ ਦੇ ਹੋਰ ਲੇਖ ਨਵੀਂ ਤਕਨਾਲੋਜੀ ਦੇ ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਵਰ ਕਰਨਗੇ, ਜਿਸ ਨੂੰ ਸ਼ੁਰੂ ਵਿੱਚ ਅੰਦਰੂਨੀ 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. ਇੱਕ seccomp ਸੰਖੇਪ ਜਾਣਕਾਰੀ: https://lwn.net/Articles/656307/
9. https://github.com/torvalds/linux/blob/master/Documentation/userspace-api/seccomp_filter.rst
10. habr: ਕੰਟੇਨਰ ਅਤੇ ਸੁਰੱਖਿਆ: seccomp
11. ਹੈਬਰ: ਸਿਸਟਮਡ ਨਾਲ ਡੈਮਨ ਨੂੰ ਅਲੱਗ ਕਰਨਾ ਜਾਂ "ਤੁਹਾਨੂੰ ਇਸ ਲਈ ਡੌਕਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ!"
12. ਪੌਲ ਚੈਗਨਨ, "ਸਟਰੇਸ --ਸੇਕੌਂਪ-ਬੀਪੀਐਫ: ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਇੱਕ ਨਜ਼ਰ", https://fosdem.org/2020/schedule/event/debugging_strace_bpf/
13. netsniff-ng: http://netsniff-ng.org/

ਸਰੋਤ: www.habr.com