ਹੇ ਹਬਰ!

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

ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਕਈ ਡੌਕਰ ਸੁਰੱਖਿਆ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਤਿਆਰ ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਛੋਟੇ ਡੈਮੋ ਸਟੈਂਡ ਨੂੰ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ ਬਾਰੇ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਾਂਗਾ। ਤੁਸੀਂ ਡੌਕਰਫਾਈਲ ਚਿੱਤਰਾਂ ਅਤੇ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਵੇਂ ਵਿਵਸਥਿਤ ਕਰਨਾ ਹੈ ਇਸ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਲਈ ਸਮੱਗਰੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਹਰੇਕ ਦਾ ਵਿਕਾਸ ਅਤੇ ਲਾਗੂ ਕਰਨ ਦਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਵੱਖਰਾ ਹੈ, ਇਸ ਲਈ ਹੇਠਾਂ ਮੈਂ ਕਈ ਸੰਭਵ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।

ਸੁਰੱਖਿਆ ਜਾਂਚ ਸਹੂਲਤਾਂ

ਇੱਥੇ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਸਹਾਇਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਹਨ ਜੋ ਡੌਕਰ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ 'ਤੇ ਜਾਂਚ ਕਰਦੀਆਂ ਹਨ। ਉਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਦਾ ਵਰਣਨ ਪਹਿਲਾਂ ਹੀ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ ਕੀਤਾ ਜਾ ਚੁੱਕਾ ਹੈ (https://habr.com/ru/company/swordfish_security/blog/518758/#docker-security), ਅਤੇ ਇਸ ਸਮੱਗਰੀ ਵਿੱਚ ਮੈਂ ਉਹਨਾਂ ਵਿੱਚੋਂ ਤਿੰਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਨਾ ਚਾਹਾਂਗਾ, ਜੋ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ ਬਣਾਏ ਗਏ ਡੌਕਰ ਚਿੱਤਰਾਂ ਲਈ ਸੁਰੱਖਿਆ ਲੋੜਾਂ ਦੇ ਵੱਡੇ ਹਿੱਸੇ ਨੂੰ ਕਵਰ ਕਰਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਇੱਕ ਉਦਾਹਰਣ ਵੀ ਦਿਖਾਵਾਂਗਾ ਕਿ ਸੁਰੱਖਿਆ ਜਾਂਚਾਂ ਕਰਨ ਲਈ ਇਹਨਾਂ ਤਿੰਨ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਇੱਕ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਕਿਵੇਂ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਹੈਡੋਲਿੰਟ
https://github.com/hadolint/hadolint

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

ਡੌਕਲ
https://github.com/goodwithtech/dockle

ਇੱਕ ਕੰਸੋਲ ਉਪਯੋਗਤਾ ਜੋ ਇੱਕ ਚਿੱਤਰ (ਜਾਂ ਇੱਕ ਚਿੱਤਰ ਦੇ ਸੁਰੱਖਿਅਤ ਟਾਰ ਆਰਕਾਈਵ ਦੇ ਨਾਲ) ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ ਜੋ ਕਿਸੇ ਖਾਸ ਚਿੱਤਰ ਦੀ ਸ਼ੁੱਧਤਾ ਅਤੇ ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ, ਇਸ ਦੀਆਂ ਲੇਅਰਾਂ ਅਤੇ ਸੰਰਚਨਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੀ ਹੈ - ਕਿਹੜੇ ਉਪਭੋਗਤਾ ਬਣਾਏ ਗਏ ਹਨ, ਕਿਹੜੀਆਂ ਹਦਾਇਤਾਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਕਿਹੜੀਆਂ ਵੌਲਯੂਮ ਮਾਊਂਟ ਕੀਤੇ ਗਏ ਹਨ, ਇੱਕ ਖਾਲੀ ਪਾਸਵਰਡ ਦੀ ਮੌਜੂਦਗੀ, ਆਦਿ. d. ਹੁਣ ਤੱਕ ਚੈਕਾਂ ਦੀ ਗਿਣਤੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਸਾਡੀਆਂ ਆਪਣੀਆਂ ਕਈ ਜਾਂਚਾਂ ਅਤੇ ਸਿਫ਼ਾਰਸ਼ਾਂ 'ਤੇ ਅਧਾਰਤ ਹੈ। CIS (ਇੰਟਰਨੈੱਟ ਸੁਰੱਖਿਆ ਲਈ ਕੇਂਦਰ) ਬੈਂਚਮਾਰਕ ਡੌਕਰ ਲਈ.


ਤ੍ਰਿਵੀ
https://github.com/aquasecurity/trivy

ਇਸ ਸਹੂਲਤ ਦਾ ਉਦੇਸ਼ ਦੋ ਕਿਸਮਾਂ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਨੂੰ ਲੱਭਣਾ ਹੈ - OS ਬਿਲਡਾਂ (ਐਲਪਾਈਨ, ਰੈੱਡਹੈਟ (ਈਐਲ), ਸੈਂਟਰੋਸ, ਡੇਬੀਅਨ ਜੀਐਨਯੂ, ਉਬੰਟੂ ਦੁਆਰਾ ਸਮਰਥਿਤ) ਅਤੇ ਨਿਰਭਰਤਾ (Gemfile.lock, Pipfile.lock, composer.lock, ਪੈਕੇਜ) ਨਾਲ ਸਮੱਸਿਆਵਾਂ। -lock.json , yarn.lock, cargo.lock)। ਟ੍ਰੀਵੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਇੱਕ ਚਿੱਤਰ ਅਤੇ ਇੱਕ ਸਥਾਨਕ ਚਿੱਤਰ ਦੋਵਾਂ ਨੂੰ ਸਕੈਨ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਡੌਕਰ ਚਿੱਤਰ ਨਾਲ ਟ੍ਰਾਂਸਫਰ ਕੀਤੀ .tar ਫਾਈਲ ਦੇ ਅਧਾਰ ਤੇ ਵੀ ਸਕੈਨ ਕਰ ਸਕਦਾ ਹੈ।

ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਵਿਕਲਪ

ਇੱਕ ਅਲੱਗ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵਰਣਿਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਅਜ਼ਮਾਉਣ ਲਈ, ਮੈਂ ਕੁਝ ਸਰਲ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸਾਰੀਆਂ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਨਿਰਦੇਸ਼ ਪ੍ਰਦਾਨ ਕਰਾਂਗਾ।

ਮੁੱਖ ਵਿਚਾਰ ਇਹ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ ਕਿ ਤੁਸੀਂ ਡੌਕਰਫਾਈਲਾਂ ਅਤੇ ਡੌਕਰ ਚਿੱਤਰਾਂ ਦੀ ਆਟੋਮੈਟਿਕ ਸਮਗਰੀ ਤਸਦੀਕ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ ਬਣਾਏ ਗਏ ਹਨ.

ਚੈੱਕ ਆਪਣੇ ਆਪ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਕਦਮਾਂ ਦੇ ਸ਼ਾਮਲ ਹਨ:

1. ਲਿੰਟਰ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੌਕਰਫਾਈਲ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਸ਼ੁੱਧਤਾ ਅਤੇ ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈਡੋਲਿੰਟ
2. ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅੰਤਮ ਅਤੇ ਵਿਚਕਾਰਲੇ ਚਿੱਤਰਾਂ ਦੀ ਸ਼ੁੱਧਤਾ ਅਤੇ ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰਨਾ ਡੌਕਲ
3. ਬੇਸ ਚਿੱਤਰ ਵਿੱਚ ਜਨਤਕ ਤੌਰ 'ਤੇ ਜਾਣੀਆਂ ਗਈਆਂ ਕਮਜ਼ੋਰੀਆਂ (CVE) ਦੀ ਮੌਜੂਦਗੀ ਅਤੇ ਕਈ ਨਿਰਭਰਤਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ - ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਤ੍ਰਿਵੀ

ਬਾਅਦ ਵਿੱਚ ਲੇਖ ਵਿੱਚ ਮੈਂ ਇਹਨਾਂ ਕਦਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਤਿੰਨ ਵਿਕਲਪ ਦੇਵਾਂਗਾ:
ਪਹਿਲਾ ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ GitLab ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ CI/CD ਪਾਈਪਲਾਈਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਹੈ (ਇੱਕ ਟੈਸਟ ਉਦਾਹਰਨ ਨੂੰ ਵਧਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਵਰਣਨ ਦੇ ਨਾਲ)।
ਦੂਜਾ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ.
ਤੀਜੇ ਵਿੱਚ ਡੌਕਰ ਚਿੱਤਰਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨ ਲਈ ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।
ਤੁਸੀਂ ਉਹ ਵਿਕਲਪ ਚੁਣ ਸਕਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ, ਇਸਨੂੰ ਆਪਣੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਤੁਹਾਡੀਆਂ ਲੋੜਾਂ ਮੁਤਾਬਕ ਢਾਲ ਸਕਦੇ ਹੋ।

ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਫਾਈਲਾਂ ਅਤੇ ਵਾਧੂ ਨਿਰਦੇਸ਼ ਵੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਥਿਤ ਹਨ: https://github.com/Swordfish-Security/docker_cicd

GitLab CI/CD ਵਿੱਚ ਏਕੀਕਰਣ

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

GitLab ਇੰਸਟਾਲ ਕਰਨਾ
1. ਡੌਕਰ ਸਥਾਪਿਤ ਕਰੋ:

sudo apt-get update && sudo apt-get install docker.io

2. ਮੌਜੂਦਾ ਉਪਭੋਗਤਾ ਨੂੰ ਡੌਕਰ ਸਮੂਹ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਸੂਡੋ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਡੌਕਰ ਨਾਲ ਕੰਮ ਕਰ ਸਕੋ:

sudo addgroup <username> docker

3. ਆਪਣਾ IP ਲੱਭੋ:

ip addr

4. ਕੰਟੇਨਰ ਵਿੱਚ ਗਿੱਟਲੈਬ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਲਾਂਚ ਕਰੋ, ਹੋਸਟਨਾਮ ਵਿੱਚ IP ਐਡਰੈੱਸ ਨੂੰ ਆਪਣੇ ਖੁਦ ਦੇ ਨਾਲ ਬਦਲੋ:

docker run --detach 
--hostname 192.168.1.112 
--publish 443:443 --publish 80:80 
--name gitlab 
--restart always 
--volume /srv/gitlab/config:/etc/gitlab 
--volume /srv/gitlab/logs:/var/log/gitlab 
--volume /srv/gitlab/data:/var/opt/gitlab 
gitlab/gitlab-ce:latest

ਅਸੀਂ ਇੰਤਜ਼ਾਰ ਕਰਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ GitLab ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਸਥਾਪਨਾ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰ ਲੈਂਦੀ (ਤੁਸੀਂ ਲੌਗ ਫਾਈਲ ਆਉਟਪੁੱਟ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਨਿਗਰਾਨੀ ਕਰ ਸਕਦੇ ਹੋ: docker logs -f gitlab)।

5. ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਆਪਣਾ ਸਥਾਨਕ IP ਖੋਲ੍ਹੋ ਅਤੇ ਇੱਕ ਪੰਨਾ ਦੇਖੋ ਜੋ ਤੁਹਾਨੂੰ ਰੂਟ ਉਪਭੋਗਤਾ ਲਈ ਪਾਸਵਰਡ ਬਦਲਣ ਲਈ ਕਹਿੰਦਾ ਹੈ:

ਇੱਕ ਨਵਾਂ ਪਾਸਵਰਡ ਸੈੱਟ ਕਰੋ ਅਤੇ GitLab 'ਤੇ ਜਾਓ।

6. ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ, ਉਦਾਹਰਨ ਲਈ cicd-ਟੈਸਟ ਅਤੇ ਇਸਨੂੰ ਸਟਾਰਟ ਫਾਈਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ README.md:

7. ਹੁਣ ਸਾਨੂੰ GitLab Runner ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ: ਇੱਕ ਏਜੰਟ ਜੋ ਬੇਨਤੀ ਕਰਨ 'ਤੇ ਸਾਰੇ ਜ਼ਰੂਰੀ ਓਪਰੇਸ਼ਨ ਚਲਾਏਗਾ।
ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਡਾਉਨਲੋਡ ਕਰੋ (ਇਸ ਕੇਸ ਵਿੱਚ, ਲੀਨਕਸ 64-ਬਿੱਟ ਲਈ):

sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

8. ਇਸਨੂੰ ਚਲਾਉਣਯੋਗ ਬਣਾਓ:

sudo chmod +x /usr/local/bin/gitlab-runner

9. ਰਨਰ ਲਈ ਇੱਕ OS ਉਪਭੋਗਤਾ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਸੇਵਾ ਸ਼ੁਰੂ ਕਰੋ:

sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash
sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
sudo gitlab-runner start

ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ:

local@osboxes:~$ sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
Runtime platform arch=amd64 os=linux pid=8438 revision=0e5417a3 version=12.0.1
local@osboxes:~$ sudo gitlab-runner start
Runtime platform arch=amd64 os=linux pid=8518 revision=0e5417a3 version=12.0.1

10. ਹੁਣ ਅਸੀਂ ਰਨਰ ਨੂੰ ਰਜਿਸਟਰ ਕਰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਇਹ ਸਾਡੇ GitLab ਉਦਾਹਰਨ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰ ਸਕੇ।
ਅਜਿਹਾ ਕਰਨ ਲਈ, Settings-CI/CD ਪੰਨਾ ਖੋਲ੍ਹੋ (http://OUR_IP_ADDRESS/root/cicd-test/-/settings/ci_cd) ਅਤੇ ਰਨਰ ਟੈਬ 'ਤੇ URL ਅਤੇ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਟੋਕਨ ਲੱਭੋ:

11. URL ਅਤੇ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਟੋਕਨ ਨੂੰ ਬਦਲ ਕੇ ਰਨਰ ਰਜਿਸਟਰ ਕਰੋ:

sudo gitlab-runner register 
--non-interactive 
--url "http://<URL>/" 
--registration-token "<Registration Token>" 
--executor "docker" 
--docker-privileged 
--docker-image alpine:latest 
--description "docker-runner" 
--tag-list "docker,privileged" 
--run-untagged="true" 
--locked="false" 
--access-level="not_protected"

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

ਪਾਈਪਲਾਈਨ ਸੰਰਚਨਾ

1. ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਫਾਈਲਾਂ ਸ਼ਾਮਲ ਕਰੋ mydockerfile.df (ਇਹ ਇੱਕ ਟੈਸਟ ਡੌਕਰਫਾਈਲ ਹੈ ਜਿਸਦੀ ਅਸੀਂ ਜਾਂਚ ਕਰਾਂਗੇ) ਅਤੇ GitLab CI/CD ਪ੍ਰਕਿਰਿਆ ਸੰਰਚਨਾ ਫਾਈਲ .gitlab-cicd.yml, ਜੋ ਸਕੈਨਰਾਂ ਲਈ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ (ਫਾਇਲ ਨਾਮ ਵਿੱਚ ਬਿੰਦੀ ਨੂੰ ਨੋਟ ਕਰੋ)।

YAML ਸੰਰਚਨਾ ਫਾਈਲ ਵਿੱਚ ਤਿੰਨ ਉਪਯੋਗਤਾਵਾਂ (ਹੈਡੋਲਿੰਟ, ਡੌਕਲ ਅਤੇ ਟ੍ਰੀਵੀ) ਨੂੰ ਚਲਾਉਣ ਲਈ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਹਨ ਜੋ ਚੁਣੀ ਗਈ ਡੌਕਰਫਾਈਲ ਅਤੇ DOCKERFILE ਵੇਰੀਏਬਲ ਵਿੱਚ ਦਰਸਾਏ ਚਿੱਤਰ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਗੇ। ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਫਾਈਲਾਂ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਲਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ: https://github.com/Swordfish-Security/docker_cicd/

ਤੋਂ ਅੰਸ਼ mydockerfile.df (ਇਹ ਉਪਯੋਗਤਾ ਦੇ ਸੰਚਾਲਨ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਮਨਮਾਨੇ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਦੇ ਨਾਲ ਇੱਕ ਐਬਸਟਰੈਕਟ ਫਾਈਲ ਹੈ)। ਫਾਈਲ ਦਾ ਸਿੱਧਾ ਲਿੰਕ: mydockerfile.df

mydockerfile.df ਦੀਆਂ ਸਮੱਗਰੀਆਂ

FROM amd64/node:10.16.0-alpine@sha256:f59303fb3248e5d992586c76cc83e1d3700f641cbcd7c0067bc7ad5bb2e5b489 AS tsbuild
COPY package.json .
COPY yarn.lock .
RUN yarn install
COPY lib lib
COPY tsconfig.json tsconfig.json
COPY tsconfig.app.json tsconfig.app.json
RUN yarn build
FROM amd64/ubuntu:18.04@sha256:eb70667a801686f914408558660da753cde27192cd036148e58258819b927395
LABEL maintainer="Rhys Arkins <[email protected]>"
LABEL name="renovate"
...
COPY php.ini /usr/local/etc/php/php.ini
RUN cp -a /tmp/piik/* /var/www/html/
RUN rm -rf /tmp/piwik
RUN chown -R www-data /var/www/html
ADD piwik-cli-setup /piwik-cli-setup
ADD reset.php /var/www/html/
## ENTRYPOINT ##
ADD entrypoint.sh /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
USER root

ਸੰਰਚਨਾ YAML ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ (ਫਾਇਲ ਖੁਦ ਇੱਥੇ ਸਿੱਧੇ ਲਿੰਕ ਰਾਹੀਂ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ: .gitlab-ci.yml):

.gitlab-ci.yml ਦੀ ਸਮੱਗਰੀ

variables:
    DOCKER_HOST: "tcp://docker:2375/"
    DOCKERFILE: "mydockerfile.df" # name of the Dockerfile to analyse   
    DOCKERIMAGE: "bkimminich/juice-shop" # name of the Docker image to analyse
    # DOCKERIMAGE: "knqyf263/cve-2018-11235" # test Docker image with several CRITICAL CVE
    SHOWSTOPPER_PRIORITY: "CRITICAL" # what level of criticality will fail Trivy job
    TRIVYCACHE: "$CI_PROJECT_DIR/.cache" # where to cache Trivy database of vulnerabilities for faster reuse
    ARTIFACT_FOLDER: "$CI_PROJECT_DIR"
 
services:
    - docker:dind # to be able to build docker images inside the Runner
 
stages:
    - scan
    - report
    - publish
 
HadoLint:
    # Basic lint analysis of Dockerfile instructions
    stage: scan
    image: docker:git
 
    after_script:
    - cat $ARTIFACT_FOLDER/hadolint_results.json
 
    script:
    - export VERSION=$(wget -q -O - https://api.github.com/repos/hadolint/hadolint/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/hadolint/hadolint/releases/download/v${VERSION}/hadolint-Linux-x86_64 && chmod +x hadolint-Linux-x86_64
     
    # NB: hadolint will always exit with 0 exit code
    - ./hadolint-Linux-x86_64 -f json $DOCKERFILE > $ARTIFACT_FOLDER/hadolint_results.json || exit 0
 
    artifacts:
        when: always # return artifacts even after job failure       
        paths:
        - $ARTIFACT_FOLDER/hadolint_results.json
 
Dockle:
    # Analysing best practices about docker image (users permissions, instructions followed when image was built, etc.)
    stage: scan   
    image: docker:git
 
    after_script:
    - cat $ARTIFACT_FOLDER/dockle_results.json
 
    script:
    - export VERSION=$(wget -q -O - https://api.github.com/repos/goodwithtech/dockle/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/goodwithtech/dockle/releases/download/v${VERSION}/dockle_${VERSION}_Linux-64bit.tar.gz && tar zxf dockle_${VERSION}_Linux-64bit.tar.gz
    - ./dockle --exit-code 1 -f json --output $ARTIFACT_FOLDER/dockle_results.json $DOCKERIMAGE   
     
    artifacts:
        when: always # return artifacts even after job failure       
        paths:
        - $ARTIFACT_FOLDER/dockle_results.json
 
Trivy:
    # Analysing docker image and package dependencies against several CVE bases
    stage: scan   
    image: docker:git
 
    script:
    # getting the latest Trivy
    - apk add rpm
    - export VERSION=$(wget -q -O - https://api.github.com/repos/knqyf263/trivy/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/knqyf263/trivy/releases/download/v${VERSION}/trivy_${VERSION}_Linux-64bit.tar.gz && tar zxf trivy_${VERSION}_Linux-64bit.tar.gz
     
    # displaying all vulnerabilities w/o failing the build
    - ./trivy -d --cache-dir $TRIVYCACHE -f json -o $ARTIFACT_FOLDER/trivy_results.json --exit-code 0 $DOCKERIMAGE    
    
    # write vulnerabilities info to stdout in human readable format (reading pure json is not fun, eh?). You can remove this if you don't need this.
    - ./trivy -d --cache-dir $TRIVYCACHE --exit-code 0 $DOCKERIMAGE    
 
    # failing the build if the SHOWSTOPPER priority is found
    - ./trivy -d --cache-dir $TRIVYCACHE --exit-code 1 --severity $SHOWSTOPPER_PRIORITY --quiet $DOCKERIMAGE
         
    artifacts:
        when: always # return artifacts even after job failure
        paths:
        - $ARTIFACT_FOLDER/trivy_results.json
 
    cache:
        paths:
        - .cache
 
Report:
    # combining tools outputs into one HTML
    stage: report
    when: always
    image: python:3.5
     
    script:
    - mkdir json
    - cp $ARTIFACT_FOLDER/*.json ./json/
    - pip install json2html
    - wget https://raw.githubusercontent.com/shad0wrunner/docker_cicd/master/convert_json_results.py
    - python ./convert_json_results.py
     
    artifacts:
        paths:
        - results.html

ਜੇ ਜਰੂਰੀ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ .tar ਆਰਕਾਈਵ ਦੇ ਰੂਪ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਵੀ ਸਕੈਨ ਕਰ ਸਕਦੇ ਹੋ (ਹਾਲਾਂਕਿ, ਤੁਹਾਨੂੰ YAML ਫਾਈਲ ਵਿੱਚ ਉਪਯੋਗਤਾਵਾਂ ਲਈ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ)

ਨੋਟ: ਟ੍ਰੀਵੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ Rpm и Git. ਨਹੀਂ ਤਾਂ, ਇਹ RedHat-ਅਧਾਰਿਤ ਚਿੱਤਰਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨ ਅਤੇ ਕਮਜ਼ੋਰੀ ਡੇਟਾਬੇਸ ਲਈ ਅੱਪਡੇਟ ਪ੍ਰਾਪਤ ਕਰਨ ਵੇਲੇ ਗਲਤੀਆਂ ਪੈਦਾ ਕਰੇਗਾ।

2. ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਫਾਈਲਾਂ ਨੂੰ ਜੋੜਨ ਤੋਂ ਬਾਅਦ, ਸਾਡੀ ਸੰਰਚਨਾ ਫਾਈਲ ਵਿੱਚ ਦਿੱਤੀਆਂ ਹਦਾਇਤਾਂ ਦੇ ਅਨੁਸਾਰ, GitLab ਆਪਣੇ ਆਪ ਬਿਲਡ ਅਤੇ ਸਕੈਨ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰ ਦੇਵੇਗੀ। CI/CD → ਪਾਈਪਲਾਈਨ ਟੈਬ 'ਤੇ ਤੁਸੀਂ ਹਦਾਇਤਾਂ ਦੀ ਪ੍ਰਗਤੀ ਦੇਖ ਸਕਦੇ ਹੋ।

ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡੇ ਕੋਲ ਚਾਰ ਕੰਮ ਹਨ. ਉਹਨਾਂ ਵਿੱਚੋਂ ਤਿੰਨ ਸਕੈਨਿੰਗ ਨਾਲ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਨਜਿੱਠਦੇ ਹਨ, ਅਤੇ ਆਖਰੀ ਇੱਕ (ਰਿਪੋਰਟ) ਸਕੈਨਿੰਗ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਖਿੰਡੇ ਹੋਏ ਫਾਈਲਾਂ ਤੋਂ ਇੱਕ ਸਧਾਰਨ ਰਿਪੋਰਟ ਇਕੱਠੀ ਕਰਦੀ ਹੈ।

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

ਤੁਹਾਡੀਆਂ ਖਾਸ ਲੋੜਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਇੱਕ ਐਗਜ਼ਿਟ ਕੋਡ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਜਦੋਂ ਇਹ ਉਪਯੋਗਤਾਵਾਂ ਕਿਸੇ ਖਾਸ ਗੰਭੀਰਤਾ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦੀਆਂ ਹਨ, ਤਾਂ ਉਹ ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵੀ ਰੋਕਦੀਆਂ ਹਨ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਬਿਲਡ ਤਾਂ ਹੀ ਬੰਦ ਹੋ ਜਾਵੇਗਾ ਜੇਕਰ ਟ੍ਰੀਵੀ ਉਸ ਨਾਜ਼ੁਕਤਾ ਦੇ ਨਾਲ ਇੱਕ ਕਮਜ਼ੋਰੀ ਦਾ ਪਤਾ ਲਗਾਉਂਦੀ ਹੈ ਜੋ ਅਸੀਂ ਸ਼ੌਸਟੌਪਰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਦਰਸਾਈ ਹੈ। .gitlab-ci.yml.


ਹਰੇਕ ਉਪਯੋਗਤਾ ਦਾ ਨਤੀਜਾ ਹਰੇਕ ਸਕੈਨਿੰਗ ਕਾਰਜ ਦੇ ਲੌਗ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਆਰਟੀਫੈਕਟ ਭਾਗ ਵਿੱਚ ਸਿੱਧੇ json ਫਾਈਲਾਂ ਵਿੱਚ, ਜਾਂ ਇੱਕ ਸਧਾਰਨ HTML ਰਿਪੋਰਟ ਵਿੱਚ (ਹੇਠਾਂ ਇਸ ਬਾਰੇ ਹੋਰ):


3. ਉਪਯੋਗਤਾ ਰਿਪੋਰਟਾਂ ਨੂੰ ਥੋੜ੍ਹਾ ਹੋਰ ਮਨੁੱਖੀ-ਪੜ੍ਹਨ ਯੋਗ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕਰਨ ਲਈ, ਇੱਕ ਛੋਟੀ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਤਿੰਨ JSON ਫਾਈਲਾਂ ਨੂੰ ਇੱਕ HTML ਫਾਈਲ ਵਿੱਚ ਨੁਕਸ ਦੇ ਸਾਰਣੀ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇਹ ਸਕ੍ਰਿਪਟ ਇੱਕ ਵੱਖਰੇ ਰਿਪੋਰਟ ਟਾਸਕ ਦੁਆਰਾ ਲਾਂਚ ਕੀਤੀ ਗਈ ਹੈ, ਅਤੇ ਇਸਦਾ ਅੰਤਮ ਆਰਟੀਫੈਕਟ ਇੱਕ ਰਿਪੋਰਟ ਦੇ ਨਾਲ ਇੱਕ HTML ਫਾਈਲ ਹੈ। ਸਕ੍ਰਿਪਟ ਸਰੋਤ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਵੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਤੁਹਾਡੀਆਂ ਲੋੜਾਂ, ਰੰਗਾਂ ਆਦਿ ਦੇ ਅਨੁਕੂਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ

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

ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਚਲਾਉਣ ਲਈ, ਡੌਕਰ ਸਿਸਟਮ ਤੇ ਸਥਾਪਿਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਮੌਜੂਦਾ ਉਪਭੋਗਤਾ ਡੌਕਰ ਸਮੂਹ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟ ਖੁਦ ਇੱਥੇ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ: docker_sec_check.sh

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

ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ, ਸਾਰੀਆਂ ਉਪਯੋਗਤਾਵਾਂ ਨੂੰ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾਵੇਗਾ docker_tools, ਉਹਨਾਂ ਦੇ ਕੰਮ ਦੇ ਨਤੀਜੇ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹਨ docker_tools/json, ਅਤੇ ਰਿਪੋਰਟ ਦੇ ਨਾਲ HTML ਫਾਈਲ ਵਿੱਚ ਹੋਵੇਗਾ results.html.

ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟ ਆਉਟਪੁੱਟ

~/docker_cicd$ ./docker_sec_check.sh

[+] Setting environment variables
[+] Installing required packages
[+] Preparing necessary directories
[+] Fetching sample Dockerfile
2020-10-20 10:40:00 (45.3 MB/s) - ‘Dockerfile’ saved [8071/8071]
[+] Pulling image to scan
latest: Pulling from bkimminich/juice-shop
[+] Running Hadolint
...
Dockerfile:205 DL3015 Avoid additional packages by specifying `--no-install-recommends`
Dockerfile:248 DL3002 Last USER should not be root
...
[+] Running Dockle
...
WARN    - DKL-DI-0006: Avoid latest tag
        * Avoid 'latest' tag
INFO    - CIS-DI-0005: Enable Content trust for Docker
        * export DOCKER_CONTENT_TRUST=1 before docker pull/build
...
[+] Running Trivy
juice-shop/frontend/package-lock.json
=====================================
Total: 3 (UNKNOWN: 0, LOW: 1, MEDIUM: 0, HIGH: 2, CRITICAL: 0)

+---------------------+------------------+----------+---------+-------------------------+
|       LIBRARY       | VULNERABILITY ID | SEVERITY | VERSION |             TITLE       |
+---------------------+------------------+----------+---------+-------------------------+
| object-path         | CVE-2020-15256   | HIGH     | 0.11.4  | Prototype pollution in  |
|                     |                  |          |         | object-path             |
+---------------------+------------------+          +---------+-------------------------+
| tree-kill           | CVE-2019-15599   |          | 1.2.2   | Code Injection          |
+---------------------+------------------+----------+---------+-------------------------+
| webpack-subresource | CVE-2020-15262   | LOW      | 1.4.1   | Unprotected dynamically |
|                     |                  |          |         | loaded chunks           |
+---------------------+------------------+----------+---------+-------------------------+

juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)

...

juice-shop/package-lock.json
============================
Total: 5 (CRITICAL: 5)

...
[+] Removing left-overs
[+] Making the output look pretty
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.html

ਸਾਰੀਆਂ ਸਹੂਲਤਾਂ ਦੇ ਨਾਲ ਡੌਕਰ ਚਿੱਤਰ

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

1. ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਸੰਬੰਧਿਤ ਡੌਕਰ ਫਾਈਲ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਲਓ https://github.com/Swordfish-Security/docker_cicd/tree/master/Dockerfile.
2. ਅਸੀਂ ਇਸਨੂੰ ਅਸੈਂਬਲੀ ਲਈ ਲਾਂਚ ਕਰਦੇ ਹਾਂ:

docker build -t dscan:image -f docker_security.df .

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

docker run --rm -v $(pwd)/results:/results -v $(pwd)/docker_security.df:/Dockerfile -e DOCKERIMAGE="bkimminich/juice-shop" dscan:image

[+] Setting environment variables
[+] Running Hadolint
/Dockerfile:3 DL3006 Always tag the version of an image explicitly
[+] Running Dockle
WARN    - DKL-DI-0006: Avoid latest tag
        * Avoid 'latest' tag
INFO    - CIS-DI-0005: Enable Content trust for Docker
        * export DOCKER_CONTENT_TRUST=1 before docker pull/build
INFO    - CIS-DI-0006: Add HEALTHCHECK instruction to the container image
        * not found HEALTHCHECK statement
INFO    - DKL-LI-0003: Only put necessary files
        * unnecessary file : juice-shop/node_modules/sqlite3/Dockerfile
        * unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm64/Dockerfile
        * unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm/Dockerfile
[+] Running Trivy
...
juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)
...
[+] Making the output look pretty
[+] Starting the main module ============================================================
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.html

Результаты

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

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

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

ਸਰੋਤ: www.habr.com