ਕਿਤਾਬ "ਲੀਨਕਸ ਨਿਗਰਾਨੀ ਲਈ ਬੀਪੀਐਫ"

ਹੈਲੋ, ਖਾਬਰੋ ਨਿਵਾਸੀਓ! BPF ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਲੀਨਕਸ ਕਰਨਲ ਦੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਭਾਗਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਇਸਦੀ ਸਹੀ ਵਰਤੋਂ ਸਿਸਟਮ ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਨੁਕਸ ਲੱਭਣ ਅਤੇ ਸਭ ਤੋਂ ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ। ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕਰਨਲ ਦੇ ਵਿਹਾਰ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਸੰਸ਼ੋਧਨ ਕਰਨ ਵਾਲੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ, ਕਰਨਲ ਵਿੱਚ ਘਟਨਾਵਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਕੋਡ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ। David Calavera ਅਤੇ Lorenzo Fontana BPF ਦੀ ਸ਼ਕਤੀ ਨੂੰ ਅਨਲੌਕ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨਗੇ। ਪ੍ਰਦਰਸ਼ਨ ਅਨੁਕੂਲਨ, ਨੈੱਟਵਰਕਿੰਗ, ਸੁਰੱਖਿਆ ਦੇ ਆਪਣੇ ਗਿਆਨ ਦਾ ਵਿਸਤਾਰ ਕਰੋ। - ਲੀਨਕਸ ਕਰਨਲ ਦੇ ਵਿਹਾਰ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਸੋਧ ਕਰਨ ਲਈ BPF ਦੀ ਵਰਤੋਂ ਕਰੋ। - ਕਰਨਲ ਨੂੰ ਮੁੜ ਕੰਪਾਇਲ ਕੀਤੇ ਜਾਂ ਸਿਸਟਮ ਨੂੰ ਰੀਬੂਟ ਕੀਤੇ ਬਿਨਾਂ ਕਰਨਲ ਇਵੈਂਟਸ ਦੀ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਕੋਡ ਨੂੰ ਇੰਜੈਕਟ ਕਰੋ। — C, Go ਜਾਂ Python ਵਿੱਚ ਸੁਵਿਧਾਜਨਕ ਕੋਡ ਉਦਾਹਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। - ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮ ਜੀਵਨ ਚੱਕਰ ਦੇ ਮਾਲਕ ਦੁਆਰਾ ਨਿਯੰਤਰਣ ਲਓ।

ਲੀਨਕਸ ਕਰਨਲ ਸੁਰੱਖਿਆ, ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਸੈਕੌਂਪ

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

ਲੀਨਕਸ ਸੁਰੱਖਿਆ ਮੋਡੀਊਲ (LSM) ਇੱਕ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਫੰਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਮਿਆਰੀ ਢੰਗ ਨਾਲ ਵੱਖ-ਵੱਖ ਸੁਰੱਖਿਆ ਮਾਡਲਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। LSM ਨੂੰ ਸਿੱਧੇ ਕਰਨਲ ਸੋਰਸ ਟ੍ਰੀ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ Apparmor, SELinux ਅਤੇ Tomoyo।

ਆਉ ਲੀਨਕਸ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਬਾਰੇ ਚਰਚਾ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੀਏ।

ਫੀਚਰ

ਲੀਨਕਸ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦਾ ਨਿਚੋੜ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਖਾਸ ਕੰਮ ਨੂੰ ਕਰਨ ਲਈ ਇੱਕ ਗੈਰ-ਅਧਿਕਾਰਤ ਪ੍ਰਕਿਰਿਆ ਦੀ ਇਜਾਜ਼ਤ ਦੇਣ ਦੀ ਲੋੜ ਹੈ, ਪਰ ਉਸ ਉਦੇਸ਼ ਲਈ ਸੂਡ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਜਾਂ ਨਹੀਂ ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਤ ਬਣਾਉਣਾ, ਹਮਲੇ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕੁਝ ਕਾਰਜ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪ੍ਰਾਪਤ ਪੋਰਟ ਖੋਲ੍ਹਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ 80 ਕਹੋ, ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੂਟ ਵਜੋਂ ਚਲਾਉਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਇਸਨੂੰ CAP_NET_BIND_SERVICE ਸਮਰੱਥਾ ਦੇ ਸਕਦੇ ਹੋ।

main.go ਨਾਮਕ ਗੋ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਵਿਚਾਰ ਕਰੋ:

package main
import (
            "net/http"
            "log"
)
func main() {
     log.Fatalf("%v", http.ListenAndServe(":80", nil))
}

ਇਹ ਪ੍ਰੋਗਰਾਮ ਪੋਰਟ 80 'ਤੇ ਇੱਕ HTTP ਸਰਵਰ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ (ਇਹ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪ੍ਰਾਪਤ ਪੋਰਟ ਹੈ)। ਆਮ ਤੌਰ 'ਤੇ ਅਸੀਂ ਇਸਨੂੰ ਸੰਕਲਨ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਚਲਾਉਂਦੇ ਹਾਂ:

$ go build -o capabilities main.go
$ ./capabilities

ਹਾਲਾਂਕਿ, ਕਿਉਂਕਿ ਅਸੀਂ ਰੂਟ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਨਹੀਂ ਦੇ ਰਹੇ ਹਾਂ, ਇਹ ਕੋਡ ਪੋਰਟ ਨੂੰ ਬਾਈਡਿੰਗ ਕਰਨ ਵੇਲੇ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦੇਵੇਗਾ:

2019/04/25 23:17:06 listen tcp :80: bind: permission denied
exit status 1

capsh (ਸ਼ੈੱਲ ਮੈਨੇਜਰ) ਇੱਕ ਟੂਲ ਹੈ ਜੋ ਸਮਰੱਥਾ ਦੇ ਇੱਕ ਖਾਸ ਸੈੱਟ ਨਾਲ ਸ਼ੈੱਲ ਚਲਾਉਂਦਾ ਹੈ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਪੂਰੇ ਰੂਟ ਅਧਿਕਾਰ ਦੇਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਹਰ ਚੀਜ਼ ਦੇ ਨਾਲ cap_net_bind_service ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਕੇ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪ੍ਰਾਪਤ ਪੋਰਟ ਬਾਈਡਿੰਗ ਨੂੰ ਸਮਰੱਥ ਕਰ ਸਕਦੇ ਹੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ capsh ਵਿੱਚ ਨੱਥੀ ਕਰ ਸਕਦੇ ਹਾਂ:

# capsh --caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' 
   --keep=1 --user="nobody" 
   --addamb=cap_net_bind_service -- -c "./capabilities"

ਆਓ ਇਸ ਟੀਮ ਨੂੰ ਥੋੜ੍ਹਾ ਸਮਝੀਏ।

• capsh - ਇੱਕ ਸ਼ੈੱਲ ਦੇ ਤੌਰ ਤੇ capsh ਦੀ ਵਰਤੋਂ ਕਰੋ।
• —caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' - ਕਿਉਂਕਿ ਸਾਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ (ਅਸੀਂ ਰੂਟ ਦੇ ਤੌਰ ਤੇ ਨਹੀਂ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ), ਅਸੀਂ cap_net_bind_service ਅਤੇ ਅਸਲ ਵਿੱਚ ਉਪਭੋਗਤਾ ID ਨੂੰ ਬਦਲਣ ਦੀ ਯੋਗਤਾ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਾਂਗੇ ਰੂਟ ਟੂ ਕਿਸੇ ਵੀ ਨਹੀਂ, ਜਿਵੇਂ ਕਿ ਕੈਪ_ਸੈਟੁਇਡ ਅਤੇ ਕੈਪ_ਸੈਟਗਿਡ।
• —keep=1 — ਅਸੀਂ ਰੂਟ ਖਾਤੇ ਤੋਂ ਸਵਿੱਚ ਕਰਨ ਵੇਲੇ ਇੰਸਟਾਲ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ।
• —user=“ਕੋਈ ਨਹੀਂ” — ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਵਾਲਾ ਅੰਤਮ ਉਪਭੋਗਤਾ ਕੋਈ ਨਹੀਂ ਹੋਵੇਗਾ।
• —addamb=cap_net_bind_service — ਰੂਟ ਮੋਡ ਤੋਂ ਸਵਿਚ ਕਰਨ ਤੋਂ ਬਾਅਦ ਸੰਬੰਧਿਤ ਸਮਰੱਥਾਵਾਂ ਦੀ ਕਲੀਅਰਿੰਗ ਸੈੱਟ ਕਰੋ।
• - -c "./capabilities" - ਸਿਰਫ਼ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ।

ਲਿੰਕਡ ਸਮਰੱਥਾਵਾਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕਿਸਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਬਾਲ ਪ੍ਰੋਗਰਾਮਾਂ ਦੁਆਰਾ ਵਿਰਾਸਤ ਵਿੱਚ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਮੌਜੂਦਾ ਪ੍ਰੋਗਰਾਮ ਉਹਨਾਂ ਨੂੰ execve() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਚਲਾਉਂਦਾ ਹੈ. ਸਿਰਫ਼ ਉਹ ਸਮਰੱਥਾਵਾਂ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਬੰਧਿਤ ਹੋਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਜਾਂ ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਵਾਤਾਵਰਣ ਸਮਰੱਥਾਵਾਂ ਵਜੋਂ, ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲ ਸਕਦੀਆਂ ਹਨ।

ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚ ਰਹੇ ਹੋਵੋਗੇ ਕਿ --caps ਵਿਕਲਪ ਵਿੱਚ ਸਮਰੱਥਾ ਨਿਰਧਾਰਤ ਕਰਨ ਤੋਂ ਬਾਅਦ +eip ਦਾ ਕੀ ਅਰਥ ਹੈ। ਇਹ ਫਲੈਗ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਕਿ ਸਮਰੱਥਾ:

- ਕਿਰਿਆਸ਼ੀਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਪੀ);

- ਵਰਤੋਂ ਲਈ ਉਪਲਬਧ (e);

- ਬੱਚੇ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ (i) ਦੁਆਰਾ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲ ਸਕਦੇ ਹਨ।

ਕਿਉਂਕਿ ਅਸੀਂ cap_net_bind_service ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਸਾਨੂੰ ਇਹ ਈ ਫਲੈਗ ਨਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਫਿਰ ਅਸੀਂ ਕਮਾਂਡ ਵਿੱਚ ਸ਼ੈੱਲ ਸ਼ੁਰੂ ਕਰਾਂਗੇ। ਇਹ ਸਮਰੱਥਾਵਾਂ ਬਾਈਨਰੀ ਨੂੰ ਚਲਾਏਗਾ ਅਤੇ ਸਾਨੂੰ ਇਸਨੂੰ i ਫਲੈਗ ਨਾਲ ਮਾਰਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਇਆ ਜਾਵੇ (ਅਸੀਂ UID ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਅਜਿਹਾ ਕੀਤਾ) p ਨਾਲ. ਇਹ cap_net_bind_service+eip ਵਰਗਾ ਲੱਗਦਾ ਹੈ।

ਤੁਸੀਂ ss ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਤੀਜਾ ਦੇਖ ਸਕਦੇ ਹੋ. ਆਉ ਪੇਜ 'ਤੇ ਫਿੱਟ ਕਰਨ ਲਈ ਆਉਟਪੁੱਟ ਨੂੰ ਥੋੜਾ ਛੋਟਾ ਕਰੀਏ, ਪਰ ਇਹ 0 ਤੋਂ ਇਲਾਵਾ ਸੰਬੰਧਿਤ ਪੋਰਟ ਅਤੇ ਉਪਭੋਗਤਾ ID ਦਿਖਾਏਗਾ, ਇਸ ਕੇਸ ਵਿੱਚ 65:

# ss -tulpn -e -H | cut -d' ' -f17-
128 *:80 *:*
users:(("capabilities",pid=30040,fd=3)) uid:65534 ino:11311579 sk:2c v6only:0

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ ਕੈਪਸ਼ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਪਰ ਤੁਸੀਂ libcap ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸ਼ੈੱਲ ਲਿਖ ਸਕਦੇ ਹੋ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, man 3 libcap ਵੇਖੋ।

ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਲਿਖਣ ਵੇਲੇ, ਅਕਸਰ ਡਿਵੈਲਪਰ ਨੂੰ ਉਹਨਾਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਪਹਿਲਾਂ ਤੋਂ ਪਤਾ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਸਮੇਂ ਲੋੜੀਂਦੀਆਂ ਹਨ; ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਵੇਂ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੀਆਂ ਹਨ।

ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਸਮਝਣ ਲਈ, ਅਸੀਂ BCC ਸਮਰੱਥ ਟੂਲ ਲੈ ਸਕਦੇ ਹਾਂ, ਜੋ cap_capable ਕਰਨਲ ਫੰਕਸ਼ਨ ਲਈ kprobe ਸੈੱਟ ਕਰਦਾ ਹੈ:

/usr/share/bcc/tools/capable
TIME      UID  PID   TID   COMM               CAP    NAME           AUDIT
10:12:53 0 424     424     systemd-udevd 12 CAP_NET_ADMIN         1
10:12:57 0 1103   1101   timesync        25 CAP_SYS_TIME         1
10:12:57 0 19545 19545 capabilities       10 CAP_NET_BIND_SERVICE 1

ਅਸੀਂ cap_capable ਕਰਨਲ ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ-ਲਾਈਨਰ kprobe ਨਾਲ bpftrace ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹੀ ਚੀਜ਼ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ:

bpftrace -e 
   'kprobe:cap_capable {
      time("%H:%M:%S ");
      printf("%-6d %-6d %-16s %-4d %dn", uid, pid, comm, arg2, arg3);
    }' 
    | grep -i capabilities

ਇਹ ਹੇਠਾਂ ਦਿੱਤੇ ਵਰਗਾ ਕੁਝ ਆਉਟਪੁੱਟ ਕਰੇਗਾ ਜੇਕਰ ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ kprobe ਤੋਂ ਬਾਅਦ ਯੋਗ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ:

12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 10 1

ਪੰਜਵਾਂ ਕਾਲਮ ਉਹ ਸਮਰੱਥਾਵਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਇਸ ਆਉਟਪੁੱਟ ਵਿੱਚ ਗੈਰ-ਆਡਿਟ ਇਵੈਂਟ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਅਸੀਂ ਸਾਰੇ ਗੈਰ-ਆਡਿਟ ਜਾਂਚਾਂ ਨੂੰ ਦੇਖਦੇ ਹਾਂ ਅਤੇ ਅੰਤ ਵਿੱਚ ਆਡਿਟ ਫਲੈਗ (ਆਉਟਪੁੱਟ ਵਿੱਚ ਆਖਰੀ) 1. ਸਮਰੱਥਾ ਦੇ ਨਾਲ ਲੋੜੀਂਦੀ ਸਮਰੱਥਾ। ਇੱਕ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ CAP_NET_BIND_SERVICE ਹੈ, ਇਸ ਨੂੰ ਆਈਡੈਂਟੀਫਾਇਰ 10 ਦੇ ਨਾਲ include/uapi/linux/ability.h ਫਾਈਲ ਵਿੱਚ ਕਰਨਲ ਸੋਰਸ ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਥਿਰ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ:

/* Allows binding to TCP/UDP sockets below 1024 */
/* Allows binding to ATM VCIs below 32 */
#define CAP_NET_BIND_SERVICE 10<source lang="go">

ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਅਕਸਰ ਰਨਟਾਈਮ 'ਤੇ ਸਮਰੱਥ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਰਨਸੀ ਜਾਂ ਡੌਕਰ ਉਹਨਾਂ ਨੂੰ ਗੈਰ-ਪ੍ਰਾਪਤ ਮੋਡ ਵਿੱਚ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ ਜ਼ਿਆਦਾਤਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜੀਂਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਜਦੋਂ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੁਝ ਸਮਰੱਥਾਵਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਡੌਕਰ ਉਹਨਾਂ ਨੂੰ --cap-add ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ:

docker run -it --rm --cap-add=NET_ADMIN ubuntu ip link add dummy0 type dummy

ਇਹ ਕਮਾਂਡ ਕੰਟੇਨਰ ਨੂੰ CAP_NET_ADMIN ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰੇਗੀ, ਇਸ ਨੂੰ ਡਮੀ0 ਇੰਟਰਫੇਸ ਨੂੰ ਜੋੜਨ ਲਈ ਇੱਕ ਨੈਟਵਰਕ ਲਿੰਕ ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ।

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

Seccomp

Seccomp ਦਾ ਅਰਥ ਹੈ ਸਕਿਓਰ ਕੰਪਿਊਟਿੰਗ ਅਤੇ ਇਹ ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ ਲਾਗੂ ਇੱਕ ਸੁਰੱਖਿਆ ਪਰਤ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਕੁਝ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਹਾਲਾਂਕਿ Seccomp ਸਮਰੱਥਾਵਾਂ ਵਿੱਚ ਲੀਨਕਸ ਨਾਲ ਤੁਲਨਾਯੋਗ ਹੈ, ਕੁਝ ਸਿਸਟਮ ਕਾਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੀ ਇਸਦੀ ਯੋਗਤਾ ਉਹਨਾਂ ਦੇ ਮੁਕਾਬਲੇ ਇਸਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲਚਕਦਾਰ ਬਣਾਉਂਦੀ ਹੈ।

Seccomp ਅਤੇ Linux ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਆਪਸ ਵਿੱਚ ਨਿਵੇਕਲੇ ਨਹੀਂ ਹਨ ਅਤੇ ਅਕਸਰ ਦੋਵਾਂ ਪਹੁੰਚਾਂ ਤੋਂ ਲਾਭ ਲੈਣ ਲਈ ਇਕੱਠੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ CAP_NET_ADMIN ਸਮਰੱਥਾ ਦੇਣਾ ਚਾਹ ਸਕਦੇ ਹੋ ਪਰ ਇਸਨੂੰ ਸਾਕੇਟ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦੇ ਸਕਦੇ ਹੋ, ਸਵੀਕਾਰ ਕਰੋ ਅਤੇ ਸਵੀਕਾਰ ਕਰੋ4 ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਬਲੌਕ ਕਰੋ।

Seccomp ਫਿਲਟਰਿੰਗ ਵਿਧੀ SECOMP_MODE_FILTER ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰਨ ਵਾਲੇ BPF ਫਿਲਟਰਾਂ 'ਤੇ ਅਧਾਰਤ ਹੈ, ਅਤੇ ਸਿਸਟਮ ਕਾਲ ਫਿਲਟਰਿੰਗ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਪੈਕੇਟਾਂ ਲਈ।

Seccomp ਫਿਲਟਰ PR_SET_SECCOMP ਕਾਰਵਾਈ ਦੁਆਰਾ prctl ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੋਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਹ ਫਿਲਟਰ ਇੱਕ BPF ਪ੍ਰੋਗਰਾਮ ਦਾ ਰੂਪ ਲੈਂਦੇ ਹਨ ਜੋ seccomp_data ਢਾਂਚੇ ਦੁਆਰਾ ਦਰਸਾਏ ਹਰੇਕ Seccomp ਪੈਕੇਟ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਸੰਦਰਭ ਆਰਕੀਟੈਕਚਰ, ਸਿਸਟਮ ਕਾਲ ਦੇ ਸਮੇਂ ਪ੍ਰੋਸੈਸਰ ਨਿਰਦੇਸ਼ਾਂ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ, ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਛੇ ਸਿਸਟਮ ਕਾਲ ਆਰਗੂਮੈਂਟਸ, uint64 ਵਜੋਂ ਦਰਸਾਏ ਗਏ ਹਨ।

linux/seccomp.h ਫਾਈਲ ਵਿੱਚ ਕਰਨਲ ਸੋਰਸ ਕੋਡ ਤੋਂ seccomp_data ਢਾਂਚਾ ਅਜਿਹਾ ਦਿਸਦਾ ਹੈ:

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

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਸ ਢਾਂਚੇ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਅਸੀਂ ਸਿਸਟਮ ਕਾਲ, ਇਸਦੇ ਆਰਗੂਮੈਂਟਾਂ, ਜਾਂ ਦੋਵਾਂ ਦੇ ਸੁਮੇਲ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹਾਂ।

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

- SECOMP_RET_KILL_PROCESS - ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰ ਦਿੰਦਾ ਹੈ ਜੋ ਇਸ ਕਾਰਨ ਨਹੀਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।

- SECOMP_RET_KILL_THREAD - ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਮੌਜੂਦਾ ਥ੍ਰੈਡ ਨੂੰ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ ਜੋ ਇਸ ਕਾਰਨ ਨਹੀਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।

— SECOMP_RET_KILL — SECOMP_RET_KILL_THREAD ਲਈ ਉਪਨਾਮ, ਪਿਛੜੇ ਅਨੁਕੂਲਤਾ ਲਈ ਛੱਡਿਆ ਗਿਆ।

- SECOMP_RET_TRAP - ਸਿਸਟਮ ਕਾਲ ਦੀ ਮਨਾਹੀ ਹੈ, ਅਤੇ SIGSYS (ਬੈਡ ਸਿਸਟਮ ਕਾਲ) ਸਿਗਨਲ ਉਸ ਕੰਮ ਲਈ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਇਸਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ।

- SECOMP_RET_ERRNO - ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ SECOMP_RET_DATA ਫਿਲਟਰ ਰਿਟਰਨ ਮੁੱਲ ਦਾ ਹਿੱਸਾ errno ਮੁੱਲ ਦੇ ਤੌਰ 'ਤੇ ਉਪਭੋਗਤਾ ਸਪੇਸ ਨੂੰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਗਲਤੀ ਦੇ ਕਾਰਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਵੱਖ-ਵੱਖ ਗਲਤੀ ਮੁੱਲ ਵਾਪਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਗਲਤੀ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਦਿੱਤੀ ਗਈ ਹੈ।

- SECOMP_RET_TRACE - ptrace ਟਰੇਸਰ ਨੂੰ ਸੂਚਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ - PTRACE_O_TRACESECCOMP ਨੂੰ ਰੋਕਣ ਲਈ ਜਦੋਂ ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਉਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੇਖਣ ਅਤੇ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਟਰੇਸਰ ਕਨੈਕਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਵਾਪਸ ਆ ਜਾਂਦੀ ਹੈ, errno ਨੂੰ -ENOSYS 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਚਲਾਇਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ।

- SECOMP_RET_LOG - ਸਿਸਟਮ ਕਾਲ ਹੱਲ ਹੋ ਗਈ ਹੈ ਅਤੇ ਲੌਗ ਕੀਤੀ ਗਈ ਹੈ।

- SECOMP_RET_ALLOW - ਸਿਸਟਮ ਕਾਲ ਦੀ ਸਿਰਫ਼ ਇਜਾਜ਼ਤ ਹੈ।

ptrace ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਹੈ ਜੋ ਟਰੇਸੀ ਨਾਮਕ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਟਰੇਸਿੰਗ ਮਕੈਨਿਜ਼ਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਹੈ, ਜਿਸ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਨਿਯੰਤਰਣ ਕਰਨ ਦੀ ਯੋਗਤਾ ਹੈ। ਟਰੇਸ ਪ੍ਰੋਗਰਾਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਟਰੇਸੀ ਦੇ ਮੈਮੋਰੀ ਰਜਿਸਟਰਾਂ ਨੂੰ ਸੋਧ ਸਕਦਾ ਹੈ। Seccomp ਸੰਦਰਭ ਵਿੱਚ, ptrace ਦੀ ਵਰਤੋਂ SECOMP_RET_TRACE ਸਥਿਤੀ ਕੋਡ ਦੁਆਰਾ ਸ਼ੁਰੂ ਹੋਣ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸਲਈ ਟਰੇਸਰ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਰੋਕ ਸਕਦਾ ਹੈ ਅਤੇ ਆਪਣਾ ਤਰਕ ਲਾਗੂ ਕਰ ਸਕਦਾ ਹੈ।

Seccomp ਗਲਤੀਆਂ

ਸਮੇਂ-ਸਮੇਂ 'ਤੇ, Seccomp ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਕਈ ਤਰੁੱਟੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ, ਜੋ ਕਿ SECOMP_RET_ERRNO ਕਿਸਮ ਦੇ ਵਾਪਸੀ ਮੁੱਲ ਦੁਆਰਾ ਪਛਾਣੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਇੱਕ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕਰਨ ਲਈ, seccomp ਸਿਸਟਮ ਕਾਲ 1 ਦੀ ਬਜਾਏ -0 ਵਾਪਸ ਆਵੇਗੀ।

ਹੇਠ ਲਿਖੀਆਂ ਗਲਤੀਆਂ ਸੰਭਵ ਹਨ:

- EACCESS - ਕਾਲਰ ਨੂੰ ਸਿਸਟਮ ਕਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ। ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਵਾਪਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ CAP_SYS_ADMIN ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਨਹੀਂ ਹਨ ਜਾਂ prctl ਦੀ ਵਰਤੋਂ ਕਰਕੇ no_new_privs ਸੈੱਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ (ਅਸੀਂ ਇਸ ਬਾਰੇ ਬਾਅਦ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗੇ);

— EFAULT — ਪਾਸ ਕੀਤੇ ਆਰਗੂਮੈਂਟਾਂ (seccomp_data ਢਾਂਚੇ ਵਿੱਚ args) ਦਾ ਕੋਈ ਵੈਧ ਪਤਾ ਨਹੀਂ ਹੁੰਦਾ;

— EINVAL — ਇੱਥੇ ਚਾਰ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ:

- ਬੇਨਤੀ ਕੀਤੀ ਕਾਰਵਾਈ ਅਣਜਾਣ ਹੈ ਜਾਂ ਮੌਜੂਦਾ ਸੰਰਚਨਾ ਵਿੱਚ ਕਰਨਲ ਦੁਆਰਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ;

-ਨਿਸ਼ਚਿਤ ਫਲੈਗ ਬੇਨਤੀ ਕੀਤੀ ਕਾਰਵਾਈ ਲਈ ਵੈਧ ਨਹੀਂ ਹਨ;

-ਓਪਰੇਸ਼ਨ ਵਿੱਚ BPF_ABS ਸ਼ਾਮਲ ਹੈ, ਪਰ ਨਿਰਧਾਰਤ ਔਫਸੈੱਟ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਹਨ, ਜੋ ਕਿ seccomp_data ਢਾਂਚੇ ਦੇ ਆਕਾਰ ਤੋਂ ਵੱਧ ਹੋ ਸਕਦੀਆਂ ਹਨ;

-ਫਿਲਟਰ ਨੂੰ ਭੇਜੀਆਂ ਗਈਆਂ ਹਦਾਇਤਾਂ ਦੀ ਗਿਣਤੀ ਅਧਿਕਤਮ ਤੋਂ ਵੱਧ ਗਈ ਹੈ;

— ENOMEM — ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜੀਂਦੀ ਮੈਮੋਰੀ ਨਹੀਂ ਹੈ;

- EOPNOTSUPP - ਓਪਰੇਸ਼ਨ ਨੇ ਸੰਕੇਤ ਦਿੱਤਾ ਹੈ ਕਿ SECOMP_GET_ACTION_AVAIL ਨਾਲ ਕਾਰਵਾਈ ਉਪਲਬਧ ਸੀ, ਪਰ ਕਰਨਲ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਵਾਪਸੀ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ;

— ESRCH — ਇੱਕ ਹੋਰ ਸਟ੍ਰੀਮ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਵੇਲੇ ਇੱਕ ਸਮੱਸਿਆ ਆਈ ਹੈ;

- ENOSYS - SECOMP_RET_TRACE ਐਕਸ਼ਨ ਨਾਲ ਜੁੜਿਆ ਕੋਈ ਟਰੇਸਰ ਨਹੀਂ ਹੈ।

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

Seccomp ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਸੈਂਡਬੌਕਸ ਤਕਨਾਲੋਜੀ ਵਾਂਗ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਅਜਿਹਾ ਨਹੀਂ ਹੈ। Seccomp ਇੱਕ ਉਪਯੋਗਤਾ ਹੈ ਜੋ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਇੱਕ ਸੈਂਡਬੌਕਸ ਵਿਧੀ ਵਿਕਸਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਹੁਣ ਆਓ ਦੇਖੀਏ ਕਿ ਕਿਵੇਂ ਉਪਭੋਗਤਾ ਇੰਟਰਐਕਸ਼ਨ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਫਿਲਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਏ ਜਾਂਦੇ ਹਨ ਜਿਸਨੂੰ ਸੇਕਕੋਮ ਸਿਸਟਮ ਕਾਲ ਦੁਆਰਾ ਸਿੱਧਾ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ।

BPF Seccomp ਫਿਲਟਰ ਉਦਾਹਰਨ

ਇੱਥੇ ਅਸੀਂ ਦਿਖਾਵਾਂਗੇ ਕਿ ਪਹਿਲਾਂ ਵਿਚਾਰੀਆਂ ਗਈਆਂ ਦੋ ਕਾਰਵਾਈਆਂ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ, ਅਰਥਾਤ:

- ਅਸੀਂ ਇੱਕ Seccomp BPF ਪ੍ਰੋਗਰਾਮ ਲਿਖਾਂਗੇ, ਜੋ ਲਏ ਗਏ ਫੈਸਲਿਆਂ ਦੇ ਆਧਾਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਰਿਟਰਨ ਕੋਡਾਂ ਦੇ ਨਾਲ ਇੱਕ ਫਿਲਟਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾਵੇਗਾ;

— prctl ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਿਲਟਰ ਲੋਡ ਕਰੋ।

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਲੀਨਕਸ ਕਰਨਲ ਤੋਂ ਸਿਰਲੇਖਾਂ ਦੀ ਲੋੜ ਹੈ:

#include <errno.h>
#include <linux/audit.h>
#include <linux/bpf.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <linux/unistd.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <unistd.h>

ਇਸ ਉਦਾਹਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਰਨਲ ਨੂੰ CONFIG_SECCOMP ਅਤੇ CONFIG_SECCOMP_FILTER ਨਾਲ y 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੰਮ ਕਰਨ ਵਾਲੀ ਮਸ਼ੀਨ 'ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚੈੱਕ ਕਰ ਸਕਦੇ ਹੋ:

cat /proc/config.gz| zcat | grep -i CONFIG_SECCOMP

ਬਾਕੀ ਦਾ ਕੋਡ ਦੋ ਭਾਗਾਂ ਵਾਲਾ install_filter ਫੰਕਸ਼ਨ ਹੈ। ਪਹਿਲੇ ਭਾਗ ਵਿੱਚ BPF ਫਿਲਟਰਿੰਗ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਸਾਡੀ ਸੂਚੀ ਸ਼ਾਮਲ ਹੈ:

static int install_filter(int nr, int arch, int error) {
  struct sock_filter filter[] = {
    BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, arch))),
    BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3),
    BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, nr))),
    BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1),
    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (error & SECCOMP_RET_DATA)),
    BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW),
  };

ਨਿਰਦੇਸ਼ linux/filter.h ਫਾਈਲ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ BPF_STMT ਅਤੇ BPF_JUMP ਮੈਕਰੋ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੈੱਟ ਕੀਤੇ ਗਏ ਹਨ।
ਦੇ ਨਿਰਦੇਸ਼ ਦੁਆਰਾ ਜਾਣ ਦਿਓ.

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(structure seccomp_data, arch))) - ਸਿਸਟਮ BPF_LD ਤੋਂ BPF_W ਸ਼ਬਦ ਦੇ ਰੂਪ ਵਿੱਚ ਲੋਡ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਕੱਠਾ ਹੁੰਦਾ ਹੈ, ਪੈਕੇਟ ਡੇਟਾ ਇੱਕ ਨਿਸ਼ਚਿਤ ਔਫਸੈੱਟ BPF_ABS 'ਤੇ ਸਥਿਤ ਹੁੰਦਾ ਹੈ।

- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3) - BPF_JEQ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ BPF_K ਸੰਚਾਈ ਸਥਿਰਾਂਕ ਵਿੱਚ ਆਰਕੀਟੈਕਚਰ ਮੁੱਲ arch ਦੇ ਬਰਾਬਰ ਹੈ। ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਅਗਲੀ ਹਦਾਇਤ 'ਤੇ ਔਫਸੈੱਟ 0 'ਤੇ ਜੰਪ ਕਰੋ, ਨਹੀਂ ਤਾਂ ਔਫਸੈੱਟ 3 (ਇਸ ਮਾਮਲੇ ਵਿੱਚ) 'ਤੇ ਛਾਲ ਮਾਰੋ ਕਿਉਂਕਿ arch ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ।

- BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, nr))) - BPF_LD ਤੋਂ BPF_W ਸ਼ਬਦ ਦੇ ਰੂਪ ਵਿੱਚ ਲੋਡ ਅਤੇ ਇਕੱਠਾ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ BPF_ABS ਦੇ ਫਿਕਸਡ ਆਫਸੈੱਟ ਵਿੱਚ ਮੌਜੂਦ ਸਿਸਟਮ ਕਾਲ ਨੰਬਰ ਹੈ।

— BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1) — ਸਿਸਟਮ ਕਾਲ ਨੰਬਰ ਦੀ nr ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਨਾਲ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਉਹ ਬਰਾਬਰ ਹਨ, ਤਾਂ ਅਗਲੀ ਹਦਾਇਤ 'ਤੇ ਅੱਗੇ ਵਧਦਾ ਹੈ ਅਤੇ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ SECOMP_RET_ALLOW ਨਾਲ ਸਿਸਟਮ ਕਾਲ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

- BPF_STMT(BPF_RET + BPF_K, SECOMP_RET_ERRNO | (ਗਲਤੀ & SECCOMP_RET_DATA)) - ਪ੍ਰੋਗਰਾਮ ਨੂੰ BPF_RET ਨਾਲ ਸਮਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਗਲਤੀ ਵੇਰੀਏਬਲ ਤੋਂ ਨੰਬਰ ਦੇ ਨਾਲ ਇੱਕ ਗਲਤੀ SECOMP_RET_ERRNO ਪੈਦਾ ਕਰਦਾ ਹੈ।

- BPF_STMT(BPF_RET + BPF_K, SECOMP_RET_ALLOW) - ਪ੍ਰੋਗਰਾਮ ਨੂੰ BPF_RET ਨਾਲ ਖਤਮ ਕਰਦਾ ਹੈ ਅਤੇ SECCOMP_RET_ALLOW ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਿਸਟਮ ਕਾਲ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

SECOMP CBPF ਹੈ
ਤੁਸੀਂ ਸੋਚ ਰਹੇ ਹੋਵੋਗੇ ਕਿ ਕੰਪਾਇਲ ਕੀਤੇ ELF ਆਬਜੈਕਟ ਜਾਂ JIT ਕੰਪਾਇਲ ਕੀਤੇ C ਪ੍ਰੋਗਰਾਮ ਦੀ ਬਜਾਏ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਸੂਚੀ ਕਿਉਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।

ਇਸ ਦੇ ਦੋ ਕਾਰਨ ਹਨ।

• ਸਭ ਤੋਂ ਪਹਿਲਾਂ, Seccomp cBPF (ਕਲਾਸਿਕ BPF) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਨਾ ਕਿ eBPF, ਜਿਸਦਾ ਮਤਲਬ ਹੈ: ਇਸਦਾ ਕੋਈ ਰਜਿਸਟਰ ਨਹੀਂ ਹੈ, ਪਰ ਆਖਰੀ ਗਣਨਾ ਨਤੀਜੇ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਸਿਰਫ ਇੱਕ ਸੰਚਵਕ, ਜਿਵੇਂ ਕਿ ਉਦਾਹਰਣ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ।

• ਦੂਜਾ, Seccomp ਸਿੱਧੇ BPF ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਇੱਕ ਐਰੇ ਲਈ ਪੁਆਇੰਟਰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਹੋਰ ਕੁਝ ਨਹੀਂ। ਸਾਡੇ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਮੈਕਰੋ ਇਹਨਾਂ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮਰ-ਅਨੁਕੂਲ ਤਰੀਕੇ ਨਾਲ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।

ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਸ ਅਸੈਂਬਲੀ ਨੂੰ ਸਮਝਣ ਲਈ ਹੋਰ ਮਦਦ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਸੂਡੋਕੋਡ 'ਤੇ ਵਿਚਾਰ ਕਰੋ ਜੋ ਇਹੀ ਕੰਮ ਕਰਦਾ ਹੈ:

if (arch != AUDIT_ARCH_X86_64) {
    return SECCOMP_RET_ALLOW;
}
if (nr == __NR_write) {
    return SECCOMP_RET_ERRNO;
}
return SECCOMP_RET_ALLOW;

ਸਾਕਟ_ਫਿਲਟਰ ਬਣਤਰ ਵਿੱਚ ਫਿਲਟਰ ਕੋਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਕੋਡ ਅਤੇ ਫਿਲਟਰ ਦੀ ਗਣਨਾ ਕੀਤੀ ਲੰਬਾਈ ਵਾਲਾ ਇੱਕ sock_fprog ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਚਲਾਉਣ ਦੀ ਘੋਸ਼ਣਾ ਕਰਨ ਲਈ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਇਸ ਡੇਟਾ ਢਾਂਚੇ ਦੀ ਲੋੜ ਹੈ:

struct sock_fprog prog = {
   .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
   .filter = filter,
};

install_filter ਫੰਕਸ਼ਨ ਵਿੱਚ ਕਰਨ ਲਈ ਸਿਰਫ ਇੱਕ ਚੀਜ਼ ਬਚੀ ਹੈ - ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਆਪਣੇ ਆਪ ਲੋਡ ਕਰੋ! ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ prctl ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, PR_SET_SECCOMP ਨੂੰ ਸੁਰੱਖਿਅਤ ਕੰਪਿਊਟਿੰਗ ਮੋਡ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਇੱਕ ਵਿਕਲਪ ਵਜੋਂ ਲੈਂਦੇ ਹਾਂ। ਫਿਰ ਅਸੀਂ ਮੋਡ ਨੂੰ SECOMP_MODE_FILTER ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਿਲਟਰ ਲੋਡ ਕਰਨ ਲਈ ਕਹਿੰਦੇ ਹਾਂ, ਜੋ ਕਿ sock_fprog ਕਿਸਮ ਦੇ ਪ੍ਰੋਗ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ:

  if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
    perror("prctl(PR_SET_SECCOMP)");
    return 1;
  }
  return 0;
}

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਆਪਣੇ install_filter ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ, ਪਰ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਸਾਨੂੰ ਮੌਜੂਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ PR_SET_NO_NEW_PRIVS ਸੈੱਟ ਕਰਨ ਲਈ prctl ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਉਸ ਸਥਿਤੀ ਤੋਂ ਬਚਣ ਦੀ ਲੋੜ ਹੈ ਜਿੱਥੇ ਬਾਲ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਮਾਪਿਆਂ ਨਾਲੋਂ ਵਧੇਰੇ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ। ਇਸਦੇ ਨਾਲ, ਅਸੀਂ ਬਿਨਾਂ ਰੂਟ ਅਧਿਕਾਰਾਂ ਦੇ install_filter ਫੰਕਸ਼ਨ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੀਆਂ prctl ਕਾਲਾਂ ਕਰ ਸਕਦੇ ਹਾਂ।

ਹੁਣ ਅਸੀਂ install_filter ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ। ਚਲੋ X86-64 ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਸਬੰਧਤ ਸਾਰੀਆਂ ਰਾਈਟ ਸਿਸਟਮ ਕਾਲਾਂ ਨੂੰ ਬਲੌਕ ਕਰੀਏ ਅਤੇ ਸਿਰਫ਼ ਇੱਕ ਅਨੁਮਤੀ ਦਿਓ ਜੋ ਸਾਰੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਰੋਕਦੀ ਹੈ। ਫਿਲਟਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਪਹਿਲੇ ਆਰਗੂਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ:

int main(int argc, char const *argv[]) {
  if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
   perror("prctl(NO_NEW_PRIVS)");
   return 1;
  }
   install_filter(__NR_write, AUDIT_ARCH_X86_64, EPERM);
  return system(argv[1]);
 }

ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ। ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਲਈ ਅਸੀਂ ਜਾਂ ਤਾਂ clang ਜਾਂ gcc ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ, ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਇਹ ਵਿਸ਼ੇਸ਼ ਵਿਕਲਪਾਂ ਤੋਂ ਬਿਨਾਂ main.c ਫਾਈਲ ਨੂੰ ਕੰਪਾਇਲ ਕਰ ਰਿਹਾ ਹੈ:

clang main.c -o filter-write

ਜਿਵੇਂ ਕਿ ਨੋਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸਾਰੀਆਂ ਐਂਟਰੀਆਂ ਨੂੰ ਬਲੌਕ ਕਰ ਦਿੱਤਾ ਹੈ। ਇਸਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਕੁਝ ਆਊਟਪੁੱਟ ਕਰਦਾ ਹੈ - ls ਇੱਕ ਚੰਗੇ ਉਮੀਦਵਾਰ ਵਾਂਗ ਜਾਪਦਾ ਹੈ. ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਤਰ੍ਹਾਂ ਵਿਹਾਰ ਕਰਦੀ ਹੈ:

ls -la
total 36
drwxr-xr-x 2 fntlnz users 4096 Apr 28 21:09 .
drwxr-xr-x 4 fntlnz users 4096 Apr 26 13:01 ..
-rwxr-xr-x 1 fntlnz users 16800 Apr 28 21:09 filter-write
-rw-r--r-- 1 fntlnz users 19 Apr 28 21:09 .gitignore
-rw-r--r-- 1 fntlnz users 1282 Apr 28 21:08 main.c

ਸ਼ਾਨਦਾਰ! ਇਹ ਹੈ ਕਿ ਸਾਡੇ ਰੈਪਰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਵਰਤੋਂ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ: ਅਸੀਂ ਸਿਰਫ਼ ਉਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਾਂ ਜਿਸਦੀ ਅਸੀਂ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਜਾਂਚ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ:

./filter-write "ls -la"

ਜਦੋਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਪ੍ਰੋਗਰਾਮ ਪੂਰੀ ਤਰ੍ਹਾਂ ਖਾਲੀ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਅਸੀਂ ਇਹ ਦੇਖਣ ਲਈ ਸਟਰੇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਕੀ ਹੋ ਰਿਹਾ ਹੈ:

strace -f ./filter-write "ls -la"

ਕੰਮ ਦਾ ਨਤੀਜਾ ਬਹੁਤ ਛੋਟਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਇਸਦੇ ਅਨੁਸਾਰੀ ਭਾਗ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਰਿਕਾਰਡ EPERM ਗਲਤੀ ਨਾਲ ਬਲੌਕ ਕੀਤੇ ਗਏ ਹਨ - ਉਹੀ ਜੋ ਅਸੀਂ ਕੌਂਫਿਗਰ ਕੀਤਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਕੁਝ ਵੀ ਆਉਟਪੁੱਟ ਨਹੀਂ ਕਰਦਾ ਕਿਉਂਕਿ ਇਹ ਰਾਈਟ ਸਿਸਟਮ ਕਾਲ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚ ਸਕਦਾ:

[pid 25099] write(2, "ls: ", 4) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "write error", 11) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "n", 1) = -1 EPERM (Operation not permitted)

ਹੁਣ ਤੁਸੀਂ ਸਮਝ ਗਏ ਹੋ ਕਿ Seccomp BPF ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਗੱਲ ਦਾ ਚੰਗਾ ਵਿਚਾਰ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸ ਨਾਲ ਕੀ ਕਰ ਸਕਦੇ ਹੋ। ਪਰ ਕੀ ਤੁਸੀਂ ਆਪਣੀ ਪੂਰੀ ਸ਼ਕਤੀ ਨੂੰ ਵਰਤਣ ਲਈ cBPF ਦੀ ਬਜਾਏ eBPF ਨਾਲ ਉਹੀ ਚੀਜ਼ ਪ੍ਰਾਪਤ ਕਰਨਾ ਪਸੰਦ ਨਹੀਂ ਕਰੋਗੇ?

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

BPF LSM ਜਾਲ

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

ਲਿਖਣ ਦੇ ਸਮੇਂ, ਕਰਨਲ ਵਿੱਚ ਬੀਪੀਐਫ ਪ੍ਰੋਗਰਾਮਾਂ ਨਾਲ ਜੁੜੇ ਸੱਤ ਹੁੱਕ ਹੁੰਦੇ ਹਨ, ਅਤੇ SELinux ਇੱਕੋ ਇੱਕ ਬਿਲਟ-ਇਨ LSM ਹੈ ਜੋ ਉਹਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

ਟ੍ਰੈਪਸ ਲਈ ਸਰੋਤ ਕੋਡ ਫਾਈਲ ਵਿੱਚ ਕਰਨਲ ਟ੍ਰੀ ਵਿੱਚ ਸਥਿਤ ਹੈ include/linux/security.h:

extern int security_bpf(int cmd, union bpf_attr *attr, unsigned int size);
extern int security_bpf_map(struct bpf_map *map, fmode_t fmode);
extern int security_bpf_prog(struct bpf_prog *prog);
extern int security_bpf_map_alloc(struct bpf_map *map);
extern void security_bpf_map_free(struct bpf_map *map);
extern int security_bpf_prog_alloc(struct bpf_prog_aux *aux);
extern void security_bpf_prog_free(struct bpf_prog_aux *aux);

ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਅਮਲ ਦੇ ਵੱਖ-ਵੱਖ ਪੜਾਵਾਂ 'ਤੇ ਬੁਲਾਇਆ ਜਾਵੇਗਾ:

— security_bpf — ਚਲਾਈਆਂ BPF ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਸ਼ੁਰੂਆਤੀ ਜਾਂਚ ਕਰਦਾ ਹੈ;

- security_bpf_map - ਜਾਂਚ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਰਨਲ ਨਕਸ਼ੇ ਲਈ ਇੱਕ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ;

- security_bpf_prog - ਜਾਂਚ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਰਨਲ eBPF ਪ੍ਰੋਗਰਾਮ ਲਈ ਇੱਕ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ;

— security_bpf_map_alloc — ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ BPF ਨਕਸ਼ਿਆਂ ਦੇ ਅੰਦਰ ਸੁਰੱਖਿਆ ਖੇਤਰ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ;

- security_bpf_map_free - ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ BPF ਨਕਸ਼ਿਆਂ ਦੇ ਅੰਦਰ ਸੁਰੱਖਿਆ ਖੇਤਰ ਨੂੰ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ;

— security_bpf_prog_alloc — ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸੁਰੱਖਿਆ ਖੇਤਰ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਅੰਦਰ ਸ਼ੁਰੂ ਕੀਤਾ ਗਿਆ ਹੈ;

- security_bpf_prog_free - ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ BPF ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਅੰਦਰ ਸੁਰੱਖਿਆ ਖੇਤਰ ਨੂੰ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੁਣ, ਇਹ ਸਭ ਦੇਖ ਕੇ, ਅਸੀਂ ਸਮਝਦੇ ਹਾਂ: LSM BPF ਇੰਟਰਸੈਪਟਰਾਂ ਦੇ ਪਿੱਛੇ ਦਾ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਉਹ ਹਰੇਕ eBPF ਵਸਤੂ ਨੂੰ ਸੁਰੱਖਿਆ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਸਿਰਫ਼ ਉਚਿਤ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਵਾਲੇ ਹੀ ਕਾਰਡਾਂ ਅਤੇ ਪ੍ਰੋਗਰਾਮਾਂ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ।

ਸੰਖੇਪ

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

ਲੇਖਕਾਂ ਬਾਰੇ

ਡੇਵਿਡ ਕੈਲਾਵੇਰਾ Netlify 'ਤੇ CTO ਹੈ। ਉਸਨੇ ਡੌਕਰ ਸਹਾਇਤਾ ਵਿੱਚ ਕੰਮ ਕੀਤਾ ਅਤੇ Runc, Go ਅਤੇ BCC ਟੂਲਸ ਦੇ ਨਾਲ-ਨਾਲ ਹੋਰ ਓਪਨ ਸੋਰਸ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਇਆ। ਡੌਕਰ ਪ੍ਰੋਜੈਕਟਾਂ ਅਤੇ ਡੌਕਰ ਪਲੱਗਇਨ ਈਕੋਸਿਸਟਮ ਦੇ ਵਿਕਾਸ ਲਈ ਉਸਦੇ ਕੰਮ ਲਈ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਡੇਵਿਡ ਫਲੇਮ ਗ੍ਰਾਫਾਂ ਬਾਰੇ ਬਹੁਤ ਭਾਵੁਕ ਹੈ ਅਤੇ ਹਮੇਸ਼ਾਂ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।

ਲੋਰੇਂਜ਼ੋ ਫੋਂਟਾਨਾ Sysdig 'ਤੇ ਓਪਨ ਸੋਰਸ ਟੀਮ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਜਿੱਥੇ ਉਹ ਮੁੱਖ ਤੌਰ 'ਤੇ Falco 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ, ਇੱਕ ਕਲਾਊਡ ਨੇਟਿਵ ਕੰਪਿਊਟਿੰਗ ਫਾਊਂਡੇਸ਼ਨ ਪ੍ਰੋਜੈਕਟ ਜੋ ਕਿ ਕਰਨਲ ਮੋਡੀਊਲ ਅਤੇ eBPF ਰਾਹੀਂ ਕੰਟੇਨਰ ਰਨਟਾਈਮ ਸੁਰੱਖਿਆ ਅਤੇ ਅਸੰਗਤਤਾ ਖੋਜ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਉਹ ਡਿਸਟਰੀਬਿਊਟਡ ਸਿਸਟਮ, ਸਾਫਟਵੇਅਰ ਪਰਿਭਾਸ਼ਿਤ ਨੈੱਟਵਰਕਿੰਗ, ਲੀਨਕਸ ਕਰਨਲ, ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿਸ਼ਲੇਸ਼ਣ ਬਾਰੇ ਭਾਵੁਕ ਹੈ।

»ਕਿਤਾਬ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਇਸ 'ਤੇ ਮਿਲ ਸਕਦੇ ਹਨ ਪ੍ਰਕਾਸ਼ਕ ਦੀ ਵੈੱਬਸਾਈਟ
» ਵਿਸ਼ਾ-ਸੂਚੀ
» ਅੰਸ਼

Khabrozhiteley ਲਈ ਕੂਪਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 25% ਦੀ ਛੋਟ - ਲੀਨਕਸ

ਕਿਤਾਬ ਦੇ ਕਾਗਜ਼ੀ ਸੰਸਕਰਣ ਦੇ ਭੁਗਤਾਨ 'ਤੇ, ਇੱਕ ਇਲੈਕਟ੍ਰਾਨਿਕ ਕਿਤਾਬ ਈ-ਮੇਲ ਦੁਆਰਾ ਭੇਜੀ ਜਾਵੇਗੀ।

ਸਰੋਤ: www.habr.com