રૂટકિટ શું છે?
રૂટકીટ હવે ફક્ત નીચલા સ્તરનો માલવેર નથી. તેના મૂળમાં, તે ગુપ્ત છે માલવેર જે અનધિકૃત ઍક્સેસ આપે છે જ્યારે પોતાના અસ્તિત્વને છુપાવે છે. પરંપરાગત સંદર્ભોમાં, રૂટકિટ્સ કર્નલ સ્પેસ અથવા સિસ્ટમ સેવાઓમાં રહે છે. જો કે, આજે, તેઓ તમારા રિપોઝીટરીઝ, CI સિસ્ટમ્સ અને પેકેજ મેનિફેસ્ટમાં પણ રહે છે, જે સ્પષ્ટ દૃષ્ટિથી છુપાયેલા હોય છે, કોડ અખંડિતતા સાથે ચેડા કરે છે અને બિલ્ડ સિસ્ટમ્સને ચેપ લગાડે છે.
સિસ્ટમ રૂટકિટ્સથી રિપોઝીટરી રૂટકિટ્સ સુધી
સિસ્ટમ એન્જિનિયરો કર્નલ રૂટકીટ્સ પર પરસેવો પાડતા હતા. આ સિસ્ટમ પર સંપૂર્ણ નિયંત્રણ આપતા હતા, સિસ્ટમકોલ્સને અટકાવતા હતા, પ્રક્રિયાઓ છુપાવતા હતા અને કોડની અખંડિતતાને જોખમમાં મૂકતા હતા. હવે, વિકાસકર્તા-કેન્દ્રિત દૃશ્ય ધારો: એક દૂષિત વ્યક્તિ તમારામાં રૂટકીટ દાખલ કરે છે ગિટ રેપો or નિર્ભરતા વૃક્ષ. આ રીપોઝીટરી રૂટકિટ એ કોડ છે જે તમારા બિલ્ડ આઉટપુટમાં ચાલાકી કરે છે અથવા બેકડોરમાં ઘૂસી જાય છે, તમારા પેકેજ આર્ટિફેક્ટ્સનો ભાગ બને છે, સિસ્ટમ તેને ચલાવે તે પહેલાં જ. રૂટકિટ તમારા સ્ત્રોત, નિર્ભરતા અને CI/CD વહે છે.
કોડબેઝ અને ડિપેન્ડન્સીમાં રૂટકિટ્સ કેવી રીતે છુપાય છે
ચાલો ટેન્જિબલ રૂટકિટ એટેક વેક્ટર્સને અનપેક કરીએ જે ડેવલપર્સે જોવું જ જોઈએ:
- અસ્પષ્ટ અથવા ગેરમાર્ગે દોરનારું commits
કલ્પના એ commit જે "ફિક્સ ટાઇપો" કહે છે પરંતુ વાસ્તવમાં એક લોડર ઇન્જેક્ટ કરે છે જે રનટાઇમ પર દૂષિત પેલોડ્સને ડિક્રિપ્ટ કરે છે. રૂટકીટ શોધ મુશ્કેલ છે જ્યારે commit સંદેશાઓ હેતુ છુપાવે છે. - બદલાયેલ અથવા પાછળના દરવાજાવાળી લાઇબ્રેરીઓ
એક સામાન્ય યુટિલિટી ફંક્શનને સૂક્ષ્મ રીતે બેકડોર્ડ વર્ઝનથી બદલવામાં આવે છે. તે પરીક્ષણો પાસ કરે છે પરંતુ કલાકો પછી રિમોટ સર્વર પર રહસ્યો લૉગ કરે છે. લાઇબ્રેરી પરિચિત લાગે છે, તેમ છતાં કોડ ઇન્ટિગ્રિટી તૂટી ગઈ છે. - સમાધાન પામેલા તૃતીય-પક્ષ પેકેજો અને ટ્રાન્ઝિટિવ ડિપેન્ડન્સીઝ
તમે ઇન્સ્ટોલ કર્યું લિબ-ક્રિપ્ટો@2.0.1; અપસ્ટ્રીમ, કોઈએ ઝેર આપ્યું હોય તેવું વર્ઝન 2.0.0 માલવેર સાથે. હવે તમારા pipeline આકસ્મિક રીતે રૂટકીટ ખેંચી લે છે, અથવા તેનાથી પણ ખરાબ, તમારી લોકફાઇલ ડ્રિફ્ટ થઈ ગઈ અને તમે દૂષિત કોડ ખેંચી લીધો. - સ્લીપિંગ કોડ અને લોજિક બોમ્બ
કોડ અઠવાડિયા કે મહિનાઓ સુધી સૌમ્ય રહે છે, પછી જાગે છે. ઉદાહરણ તરીકે:
આજે પરીક્ષણો પાસ થાય છે, અને તમને કોડની અખંડિતતા નિષ્ફળ જતી જોવા મળતી નથી જ્યાં સુધી ખૂબ મોડું ન થઈ જાય.
DevOps માં રૂટકીટ ડિટેક્શન શા માટે મહત્વનું છે
તમારામાં રૂટકિટ્સ pipeline અને રિપોઝ વાસ્તવિક વિકાસકર્તા વર્કફ્લોને ધમકી આપે છે:
- ચેડાં કરાયેલા બાંધકામો જે ધ્યાન બહાર આવે છે: જો રૂટકીટ hooks તમારી બિલ્ડ સ્ક્રિપ્ટમાં, એક દૂષિત કહો ઇન્સ્ટોલેશન પછી or setup.py, તમારું CI પસાર થઈ જશે, અને તમે જાણ્યા વગર ચેડા થયેલા આર્ટિફેક્ટ્સને આગળ ધપાવો છો.
- અસંગત અથવા પુનઃઉત્પાદન ન કરી શકાય તેવા નિર્માણ: રૂટકીટને કારણે ડેવલપર મશીનો અને CI એજન્ટોમાં બિલ્ડમાં તફાવત આવી શકે છે. આ તફાવત કોડ ઇન્ટિગ્રિટી માટે જોખમી છે, પરંતુ જો તમે તેની તપાસ કરી રહ્યા હોવ તો જ.
- રિલીઝ દરમિયાન સતત સમાધાન: એકવાર એમ્બેડ થઈ ગયા પછી, તે બ્રાન્ચ મર્જ, ચેરી-પિક્સ અને ભવિષ્યના રિલીઝમાં ટકી શકે છે. વધુ ખરાબ, તે અપડેટ્સમાં પોતાને ઇન્જેક્ટ કરી શકે છે, તમારી સપ્લાય ચેઇનને દૂષિત કરી શકે છે.
- Pipeline ડેવલપર વાતાવરણમાં ઝેર અને બાજુની હિલચાલ: રૂટકીટ CI રૂપરેખાઓ, શેર કરેલા રનર્સ અને શેર્ડ ઓળખપત્રો સાથે ડેવલપર મશીનો દ્વારા ફેલાઈ શકે છે. કોડની અખંડિતતા ફક્ત કોડમાં જ નહીં, પરંતુ સમગ્ર વાતાવરણમાં પણ ભંગ થાય છે.
પ્રાયોગિક રૂટકિટ શોધ Pipelines
તમારી રૂટકીટ શોધ રમતને વધારવા માટે અહીં વિકાસકર્તા-મૈત્રીપૂર્ણ, કાર્યક્ષમ તકનીકો છે:
• મહત્વપૂર્ણ ફાઇલો માટે હેશ માન્યતા અને નિર્ભરતા
કી ફાઇલો માટે SHA‑256 (અથવા સમાન) ની ગણતરી કરો જેમ કે જરૂરિયાતો.txt, package-lock.json, અથવા ઉચ્ચ-સ્તરીય બિલ્ડ સ્ક્રિપ્ટો:
તે ફાઇલોમાં કોઈપણ ફેરફાર સંભવિત દૂષિત પ્રવાહનો સંકેત આપે છે.
• SBOM (સોફ્ટવેર બિલ ઓફ મટિરિયલ્સ) માન્યતા
પેદા SBOM Syft અથવા SPDX જેવા ટૂલ્સનો ઉપયોગ કરીને. તમારા બિલ્ડમાં કઈ ડિપેન્ડન્સી (અને વર્ઝન) છે તે બરાબર ટ્રૅક કરો. સરખામણી કરો. SBOMઅનપેક્ષિત અથવા દૂષિત ઉમેરાઓ શોધવા માટે બિલ્ડ્સમાં s.
• સહી કરેલ commits અને સહી ચકાસણી
દબાણ ગિટ commit -S અને CI માં સહીઓ તપાસો:
નવું, સહી વગરનું, અથવા શંકાસ્પદ રીતે સહી થયેલ commit સોર્સ-રુટકિટ પ્રોબ હોઈ શકે છે.
• બિલ્ડ અથવા રનટાઇમ દરમિયાન વર્તણૂક-આધારિત અસંગતતા શોધ
વિચિત્ર વર્તણૂક પકડવા માટે તમારા બિલ્ડને પ્રોફાઇલિંગ સાથે ઇન્સ્ટ્રુમેન્ટ કરો: ઉદાહરણ તરીકે, અનપેક્ષિત નેટવર્ક કોલ્સ દરમિયાન npm સ્થાપિત કરો or પાઇપ ઇન્સ્ટોલ કરો, અથવા સુરક્ષિત ડાયરોમાં ફાઇલ ફેરફારો:
ઇન્સ્ટોલેશન દરમિયાન અણધાર્યો આઉટબાઉન્ડ ટ્રાફિક રૂટકીટ લોડિંગ સ્ટેજ હોઈ શકે છે.
• અસ્પષ્ટ અથવા ઉચ્ચ-એન્ટ્રોપી કોડ સેગમેન્ટ્સ માટે સ્કેનિંગ
શંકાસ્પદ કોડ એન્ટ્રોપી અથવા નોન-ASCII/વાંચવા માટે મુશ્કેલ વિભાગોને ફ્લેગ કરતા સાધનોનો ઉપયોગ કરો pull requests. ઉદાહરણ તરીકે, માટે સ્કેન એકીકૃત કરો બેઝએક્સએનયુએમએક્સ બ્લોબ્સ અથવા વિચિત્ર એક્ઝિક્યુટિવ/ઇવલ ઉપયોગ. હાઇલાઇટ કરેલો કોડ સ્લીપિંગ લોડર અથવા એન્ક્રિપ્ટેડ પેલોડ હોઈ શકે છે.
સપ્લાય ચેઇનમાં કોડ ઇન્ટિગ્રિટી જાળવવી
લાંબા ગાળે, તમારે એવી પ્રથાઓની જરૂર પડશે જે રૂટકિટ શોધને બીજી પ્રકૃતિ બનાવે:
- ડિપેન્ડન્સી પિનિંગ અને લોકફાઇલ્સ: હંમેશા commit લોકફાઇલ્સ (પેકેજ-લોક.જેસન, આવશ્યકતાઓ.લોક, વગેરે). પિન વર્ઝન જેથી તમે આકસ્મિક રીતે પરિવર્તિત ટ્રાન્ઝિટિવ ડિપેન્ડન્સી ખેંચી ન લો અને રૂટકીટ લપસી જવાનું જોખમ ન લો.
- પ્રકાશનો અને પેકેજોનું ક્રિપ્ટોગ્રાફિક હસ્તાક્ષર: GPG અથવા તેના જેવા ઉપયોગ કરીને તમારા પોતાના બિલ્ડ આર્ટિફેક્ટ્સ પર સહી કરો. ગ્રાહકો સહીઓની ચકાસણી કરે છે; જો રૂટકીટ તમારા પ્રકાશન સાથે ચેડા કરે છે, તો ચકાસણી નિષ્ફળ જાય છે અને વિશ્વાસની સાંકળ તોડે છે.
- ની નિયમિત સમીક્ષા તૃતીય-પક્ષ અને સંક્રમિત ફેરફારો: નવી અથવા બદલાયેલી નિર્ભરતાને ચિહ્નિત કરતા ડિપેન્ડન્સી-મોનિટરિંગ ટૂલ્સનો ઉપયોગ કરો. સાથે જોડો SBOM ઇન્જેક્ટેડ અથવા બદલાયેલા મોડ્યુલો શોધવા માટે અલગ પડે છે.
- નિર્ભરતા ડ્રિફ્ટ માટે સતત દેખરેખ અથવા અનધિકૃત ફેરફારો: સ્વયંચાલિત SBOM તમારા CI માં તફાવત: જો અણધારી ડિપેન્ડન્સી દેખાય તો બિલ્ડ નિષ્ફળ જાય છે. સમય જતાં ડિપેન્ડન્સી ડ્રિફ્ટને ટ્રેક કરો, અને જો કંઈક અપેક્ષિત સ્થિતિથી ભટકે છે તો ચેતવણી આપો: દા.ત., રૂટકીટ commit અથવા નિર્ભરતાને બદલી.
ઉપસંહાર
રૂટકિટ્સ હવે ફક્ત સિસ્ટમ એડમિન્સ અને કર્નલ સુધી મર્યાદિત નથી; તેઓ વિકાસના હૃદયમાં સ્થાનાંતરિત થયા છે: તમારા રિપોઝ, બિલ્ડ્સ અને CI pipelines. ડેવલપર્સે રૂટકીટ શોધ અને કોડ ઇન્ટિગ્રિટીને મુખ્ય એપ્સેક ચિંતાઓ તરીકે ગણવી જોઈએ. હેશ વેલિડેશનનો ઉપયોગ કરીને, SBOM ઓડિટ, સહી કરેલ commits, વર્તણૂક વિસંગતતા શોધ અને નિર્ભરતા સ્વચ્છતા, તમે કોડમાં રહેતા રૂટકિટ્સ સામે વ્યવહારુ સંરક્ષણ બનાવો છો.
જેવું સાધન ઝીગેનીસોફ્ટવેર સપ્લાય-ચેઇન હાર્ડનિંગ પર ધ્યાન કેન્દ્રિત કરીને, DevSecOps ટીમોને કોડ ઇન્ટિગ્રિટી જાળવવા અને વર્કફ્લોની શરૂઆતમાં રૂટકીટ ધમકીઓ શોધવા માટે સશક્ત બનાવી શકે છે. તે ડેવલપર-ફર્સ્ટ સુરક્ષા માટે એક મહત્વપૂર્ણ સાથી છે, જે તમારા રેપો, બિલ્ડ અથવા ઉત્પાદનમાં ફેલાતા પહેલા તેને રોકવામાં મદદ કરે છે.
