ડોસ્ફસ્કેશન શું છે? વિકાસકર્તાઓએ શા માટે ધ્યાન આપવું જોઈએ
અહીં એક ઝડપી ધમકીનો સ્નેપશોટ છે: કલ્પના કરો કે કોઈ PR ની સમીક્ષા કરી રહ્યા છો જે એક નાના ઉપયોગિતા અપડેટ જેવું લાગે છે. અંદર દફનાવવામાં આવેલા, એક યોગદાનકર્તાએ એક હાનિકારક સહાયક સ્ક્રિપ્ટ ઉમેરી. પરંતુ મર્જ પર, તે CI દરમિયાન ચાલે છે. pipeline અને એક લૂપ ટ્રિગર કરે છે જે શાંતિથી બધી મેમરીનો ઉપયોગ કરે છે, બિલ્ડ ક્રેશ થાય છે.
ડોસ્ફસ્કેશન એ એક પ્રકારનો આંતરિક ડિનાયલ-ઓફ-સર્વિસ (DoS) હુમલો છે જે કોડ ઓબ્ફસ્કેશન તકનીકોનો ઉપયોગ કરીને છુપાયેલ છે. તે અમલને તોડવા માટે રચાયેલ તર્કને જોડે છે, જેમ કે અનંત લૂપ્સ અથવા મેમરી બ્લોટ, યુક્તિઓ સાથે જે તેના વાસ્તવિક વર્તનને છુપાવે છે, જેના કારણે સમીક્ષાઓ અથવા ઓડિટ દરમિયાન તેને શોધવાનું મુશ્કેલ બને છે. આ કોઈ બાહ્ય હિટ નથી; તે પહેલાથી જ તમારા કોડની અંદર છે, તમારા બિલ્ડ અથવા પ્રોડક્શન રનને ઉડાવી દેવાની રાહ જોઈ રહ્યું છે.
શા માટે ચિંતા? તમારા સર્વરને ટ્રાફિકથી ભરી દેતા પરંપરાગત પ્રકારના ડિનાયલ ઓફ સર્વિસ હુમલાઓથી વિપરીત, ડોસફસ્કેશન સ્પષ્ટ દૃષ્ટિમાં છુપાયેલું રહે છે, ઘણીવાર કોડ સમીક્ષા અથવા પેકેજ ઓડિટ પસાર કરે છે. તે તમારામાં એક લોજિક બોમ્બ છે જે pipeline.
વાસ્તવિક ઉદાહરણ: An npm પેકેજ તેમાં એક છુપાયેલ અનંત લૂપ છે. તે ઇન્સ્ટોલેશનને સારી રીતે પસાર કરે છે, પરંતુ તમારી એપ્લિકેશન ક્રેશ થાય ત્યાં સુધી ઉત્પાદનમાં મેમરીને હોગ કરે છે. આ દર્શાવે છે કે કેવી રીતે અસ્પષ્ટ તકનીકો દ્વારા સંચાલિત ડોસફસ્કેશન, સેવાના અસ્વીકારના સૌથી નુકસાનકારક પ્રકારના હુમલાઓનું એક સ્ટીલ્થ પ્રકાર બની જાય છે.
લાક્ષણિક DoS વિરુદ્ધ Dosfuscation: જોખમમાં વાસ્તવિક તફાવત
ડોસ્ફસ્કેશન એ ડિનાયલ-ઓફ-સર્વિસ હુમલાઓનો એક પેટા પ્રકાર છે. તે નેટવર્ક ટ્રાફિક દ્વારા નહીં, પરંતુ અસ્પષ્ટ કોડ દ્વારા આંતરિક રીતે એક્ઝિક્યુટ કરીને સર્વિસ હુમલાઓના ડિનાયલના પરંપરાગત પ્રકારોથી અલગ પડે છે.
આની કલ્પના કરો: તમે GitHub માં PR ને મંજૂરી આપો છો. પરીક્ષણો પાસ થાય છે, બિલ્ડ શરૂ થાય છે, પછી તમારો રનર હેંગ થાય છે. તમે એક નિષ્ફળ GitHub Actions જોબને ડીબગ કરી રહ્યા છો જે સમય બહાર રાખે છે. બહાર આવ્યું છે કે, એક નાના ડિપેન્ડન્સીમાં એક ડોસ્ફસ્કેટેડ પેલોડે પોસ્ટઇન્સ્ટોલ સ્ક્રિપ્ટમાં જ એક અનંત લૂપ રજૂ કર્યો.
જ્યારે ડેવલપર્સ સેવા નકારવા વિશે વિચારે છે, ત્યારે તેઓ સામાન્ય રીતે બહારની પરિસ્થિતિનું ચિત્રણ કરે છે, જેમ કે API ને હથોડી મારતી દૂષિત વિનંતીઓનો ટોળો અથવા બોટનેટ બેન્ડવિડ્થને થાકી જાય છે. આ સેવા નકારવાના ક્લાસિક પ્રકારો છે, અને આપણામાંથી મોટાભાગના લોકો તેમના માટે તૈયાર છે. અમારી પાસે WAF છે, દર મર્યાદા લાગુ કરે છે, અને એક સ્કેલેબલ ઇન્ફ્રાસ્ટ્રક્ચર બનાવે છે જે ફટકો સહન કરી શકે છે.
જોકે, ડોસ્ફસ્કેશન બહારથી આવતું નથી. તે સીધા તમારા કોડબેઝમાં જોડાયેલું છે. તે ડિપેન્ડન્સીમાં છુપાય છે, CI દ્વારા છુપાય છે. pipelines, અને વસ્તુઓને ઉડાવી દેવા માટે અમલીકરણની રાહ જુએ છે. ફાયરવોલ ટ્યુનિંગની કોઈ માત્રા નથી અથવા DDoS શમન તેને બંધ કરશે કારણ કે તે ક્યારેય નેટવર્ક પર ફરતું નથી; તે પહેલેથી જ ઘરે છે.
આ ડોસ્ફસ્કેશનને સેવા નકારવાનું ખાસ કરીને ગુપ્ત સ્વરૂપ બનાવે છે. તે નેટવર્ક અવાજ સાથે પોતાને જાહેર કરતું નથી. તે અંદરથી, બિલ્ડ સમયે, રનટાઇમ દરમિયાન, અથવા જ્યારે કોઈ ચોક્કસ લોજિક શાખા હિટ થાય છે ત્યારે મારી નાખે છે. અને કારણ કે તે અદ્યતન અસ્પષ્ટ તકનીકોનો ઉપયોગ કરીને કોડમાં દફનાવવામાં આવ્યું છે, જ્યાં સુધી તમે ઊંડાણપૂર્વક ન જુઓ ત્યાં સુધી તમે તેને પકડી શકશો નહીં.
એ કારણે DevSecOps ટીમો પરિમિતિ સંરક્ષણથી આગળ વિચારવાની જરૂર છે. એપ્લિકેશન-સ્તર સુરક્ષા પણ એટલી જ મહત્વપૂર્ણ છે. જો તમારું ધ્યાન ફક્ત ખરાબ ટ્રાફિકને દૂર રાખવા પર હશે, તો તમે તમારા રેપોમાં પહેલાથી જ રહેલ પેલોડ ગુમાવશો.
કોડમાં DoS લોજિક છુપાવવા માટે હુમલાખોરો કેવી રીતે અસ્પષ્ટતાનો ઉપયોગ કરે છે
જ્યારે વર્કફ્લોનું કામ અપેક્ષા કરતાં ઘણો વધુ સમય લે છે, અથવા ખરાબ રીતે, ક્યારેય પૂર્ણ થતું નથી ત્યારે તમે આને ક્રિયામાં જોઈ શકો છો. એક ઉદાહરણમાં ડોકર કન્ટેનરમાં એક ટીમ દ્વારા પરીક્ષણો ચલાવવાનો સમાવેશ થાય છે GitHub ક્રિયાઓ. તૃતીય-પક્ષ મોડ્યુલ દ્વારા એક નાનો જાવાસ્ક્રિપ્ટ ટેસ્ટ હેલ્પર ઉમેરવામાં આવ્યો હતો. તેને અનંત મેમરી ફાળવણી લૂપ છુપાવવા માટે અસ્પષ્ટ કરવામાં આવ્યું હતું જેના કારણે નોડ પ્રક્રિયા પ્રતિભાવવિહીન બની ગઈ હતી.
CI વર્કફ્લોમાં અસ્પષ્ટ DoS પેલોડ્સ ઘણીવાર કોઈના ધ્યાન બહાર નીકળી જાય છે. ઉદાહરણ તરીકે, GitHub Actions pipeline કદાચ કોઈ હાનિકારક સ્ક્રિપ્ટ ચલાવી શકે છે જે એમ્બેડેડ અનંત લૂપને કારણે અચાનક કામ અટકી જાય છે.
આને વાસ્તવિક બનાવવા માટે, અહીં આપેલ છે કે રોજિંદા કોડમાં ડોસ્ફસ્કેટેડ પેલોડ કેવો દેખાઈ શકે છે.
જાવાસ્ક્રિપ્ટ ઉદાહરણ: હિડન ઇન્ફિનિટ લૂપ
આ છુપાયેલા તર્કનો ઉપયોગ કરીને મેમરીને અનિશ્ચિત સમય માટે ભરી દે છે, આખરે એપ્લિકેશન ક્રેશ થાય છે.
પાયથોન ઉદાહરણ: અસ્પષ્ટ CPU હોગ
આ base64-એન્કોડેડ લૂપ અવિરતપણે ચાલે છે, પહેલી નજરમાં શંકાસ્પદ લાગતા મેમરીને સાચવે છે.
પેલોડ્સ ક્યાં છુપાય છે: એક વાસ્તવિક દુનિયાના ડોસફસ્કેશન દૃશ્ય
ડોસ્ફસ્કેટેડ પેલોડ્સ ઘણીવાર સાદી દૃષ્ટિએ, તૃતીય-પક્ષ પેકેજોની અંદર, ઓપન-સોર્સમાં છુપાય છે pull requests, અથવા આંતરિક સ્ક્રિપ્ટોનો ચકાસણી વિના ફરીથી ઉપયોગ થાય છે. હુમલાખોરો વિકાસ ગતિ અને ઓટોમેશન પર આધાર રાખે છે જેથી તેઓ અજાણ્યા, તમારા શરીરમાં ઊંડાણપૂર્વક એમ્બેડ કરેલા લોજિક બોમ્બમાંથી પસાર થઈ શકે. pipeline.
આ કેવી રીતે થાય છે તે દર્શાવવા માટે એક વાસ્તવિક દૃશ્ય મદદ કરે છે:
તમે તમારા CI વર્કફ્લોને ચલાવવા માટે GitHub Actions નો ઉપયોગ કરી રહ્યા છો. તમારું .ગીથબ/વર્કફ્લો/બિલ્ડ.વાયએમએલ પ્રોજેક્ટ ડિપેન્ડન્સી ઇન્સ્ટોલ કરે છે. તેમાંથી એક ટ્રાન્ઝિટિવ npm પેકેજ છે, જે તમારા દ્વારા સીધા ઇન્સ્ટોલ કરવામાં આવતું નથી, પરંતુ ડિપેન્ડન્સીના ડિપેન્ડન્સી તરીકે. તે સ્ટ્રિંગ મેનિપ્યુલેશન જેવી નજીવી બાબતોમાં મદદ કરવાનો દાવો કરે છે.
પરંતુ પેકેજની અંદર, જે અસ્પષ્ટ તકનીકોનો ઉપયોગ કરીને છુપાયેલું છે, તે એક લોજિક બોમ્બ છે. તે એક અનંત મેમરી ફાળવણી લૂપ હોઈ શકે છે જે દરમિયાન ટ્રિગર થયો હતો પોસ્ટઇન્સ્ટોલ સ્ક્રિપ્ટ, અથવા તમારા પરીક્ષણોમાં રનટાઇમ આયાત. તે અમલ સુધી નિષ્ક્રિય રહે છે, કોઈ ચેતવણીઓ નથી, કોઈ ઓડિટ ફ્લેગ્સ નથી.
અચાનક, તમારું CI રનર ક્રેશ થઈ ગયું. CPU અને મેમરી સ્પાઇક. કામનો સમય સમાપ્ત થઈ ગયો. તમારું બિલ્ડ અથવા ડિપ્લોયમેન્ટ નિષ્ફળ ગયું.
આ ફક્ત કાલ્પનિક નથી. આવી ઘટનાઓ જંગલમાં જોવા મળી છે. તે દર્શાવે છે કે ડોસફસ્કેશન કેવી રીતે તમારા ટૂલચેનમાં વિશ્વાસનો ઉપયોગ કરે છે, ઓટોમેટેડ વર્કફ્લો, ઝડપી મર્જ અને પરોક્ષ નિર્ભરતાનો ઉપયોગ કરે છે.
આ પેલોડ્સ સામાન્ય રીતે ક્યાં છુપાવે છે?
- તૃતીય-પક્ષ પેકેજો: ખાસ કરીને npm, PyPI, અથવા Maven માંથી.
- ઓપન-સોર્સ પીઆર: મદદરૂપ અપડેટ્સ તરીકે છુપાવેલા ગુપ્ત તર્ક સાથે.
- આંતરિક સ્ક્રિપ્ટો: યોગ્ય માન્યતા અથવા સમીક્ષા વિના ફરીથી ઉપયોગમાં લેવાયેલા સ્નિપેટ્સ.
હુમલાખોરો શોધમાં વિલંબ કરવા માટે અસ્પષ્ટતાનો ઉપયોગ કરે છે, બાકીનું કામ કરવા માટે છીછરા કોડ સમીક્ષાઓ અને સ્વચાલિત નિર્ભરતા અપડેટ્સ પર આધાર રાખે છે.
તમારા કોડ અને ડિપેન્ડન્સીમાં ડોસફસ્કેશન કેવી રીતે શોધવું
વિચિત્ર તર્ક શોધવા માટે સ્થિર વિશ્લેષણનો ઉપયોગ કરો
એવા સાધનોનો ઉપયોગ કરો જે:
- સ્ક્રેમ્બલ્ડ કંટ્રોલ ફ્લો અથવા સ્ટ્રિંગ રિકન્સ્ટ્રક્શન જેવી અસ્પષ્ટ તકનીકો શોધો.
- ફ્લેગ લોજિક જે સરળ મોડ્યુલો માટે ખૂબ જટિલ છે.
- ડિનાયલ ઓફ સર્વિસ એટેકના પ્રકારો જેવા ફંક્શન અથવા સ્ક્રિપ્ટ પેટર્નને હાઇલાઇટ કરો.
ફક્ત વર્ઝન ચેક કરતાં વધુ ઉપયોગ કરીને ડિપેન્ડન્સી સ્કેન કરો
સંસ્કરણ નંબરો તપાસવાનું બંધ ન કરો:
- વાસ્તવિક કોડની અંદર જુઓ.
- તાજેતરના પેકેજ અપડેટ્સની સમીક્ષાને પ્રાથમિકતા આપો.
- એન્કોડેડ સ્ટ્રિંગ્સ, છુપાયેલા તર્ક અથવા ડોસફસ્કેશન માર્કર્સ શોધો.
શંકાસ્પદની મેન્યુઅલી સમીક્ષા કરો Pull Requests
ધ્યાન રાખો:
- સરળ અપડેટ્સમાં વધુ પડતા જટિલ ફેરફારો.
- નવા કોડમાં અસ્પષ્ટ અથવા વાંચી ન શકાય તેવું તર્ક.
- જાણીતી અસ્પષ્ટ તકનીકોનો પરિચય આપતા પીઆર.
જ્યારે દરેક વ્યક્તિ ધારે છે કે "આ ફક્ત એક નાનો ફેરફાર છે" ત્યારે ડોસફસ્કેશન શરૂ થાય છે.
ડોસફસ્કેશનને તમારા સંપર્કમાં આવવાથી કેવી રીતે અટકાવવું CI/CD
GitHub Actions, GitLab CI, અથવા CircleCI જેવા CI વાતાવરણમાં, નિવારણ એ એવા નિયંત્રણો સેટ કરવા વિશે છે જે અસ્પષ્ટ પેલોડ્સને વહેલા શોધી કાઢે છે અને અવરોધિત કરે છે. ઉદાહરણ તરીકે, શેલ સ્ક્રિપ્ટો ધરાવતા બધા વર્કફ્લો માટે PR સમીક્ષાઓ લાગુ કરો અથવા ઇન્સ્ટોલ કરો hooks, અને મોનિટર કરો .yml pipeline ચકાસાયેલ ન હોય તેવી તૃતીય-પક્ષ ક્રિયાઓ માટે રૂપરેખાંકનો.
CI/CD એક ડોસ્ફસ્કેશન પ્લેગ્રાઉન્ડ છે. તેને કેવી રીતે લોક કરવું તે અહીં છે:
- દરેક PR માં સ્ટેટિક સ્કેનર્સ ઉમેરો અને બનાવો.
- ફક્ત વિશ્વસનીય, ચકાસાયેલ સ્ત્રોતોમાંથી જ પેકેજોનો ઉપયોગ કરો.
- બિલ્ડ રિસોર્સ વપરાશને ટ્રૅક કરો; સ્પાઇક્સનો અર્થ છુપાયેલ તર્ક હોઈ શકે છે.
- દરેક નિર્ભરતાને ચેક કરેલ સાથે મેચ કરો SBOM.
- દસ્તાવેજીકૃત સમર્થન વિના સામાન્ય અસ્પષ્ટ તકનીકોના ઉપયોગ પર પ્રતિબંધ મૂકો.
હવે "ઇન્સ્ટોલ અને આશા" નહીં. નિવારણ એટલે હોવું guardrails તમારા કાર્યપ્રવાહમાં સમાવિષ્ટ. ડોસફ્યુસ્કેશનને વહેલા પકડવાથી સેવાના ઇનકારના સૌથી વિક્ષેપકારક પ્રકારના હુમલાઓ અટકાવી શકાય છે.
ઝાયજેનીની ભૂમિકા: પ્રોડક્શન શરૂ થાય તે પહેલાં જ ડોસ્ફ્યુસ્કેશનને પકડવું
ઝીગેની તમારા સમગ્ર ક્ષેત્રમાં સુરક્ષા ગુપ્ત માહિતીને એમ્બેડ કરીને, DevSecOps ટીમોને ડાઉનટાઇમ થાય તે પહેલાં ડોસફસ્કેશન રોકવામાં મદદ કરે છે. વિકાસ કાર્યપ્રવાહ. તે અસ્પષ્ટ તકનીકો શોધવા અને નીતિ-આધારિત અમલીકરણમાં નિષ્ણાત છે guardrails જે ચોરીછૂપીથી થતા સેવાના ઇનકારના હુમલાઓને ઉત્પાદન સુધી પહોંચતા અટકાવે છે.
પીઆર સમીક્ષાઓમાં
ઝાયજેની કોડ ડિફ્યુઝ સ્કેન કરે છે જેથી અસ્પષ્ટતાના સંકેતો ઓળખી શકાય જેમ કે:
- નો ઉપયોગ ઇવલ અથવા સમાન ગતિશીલ અમલ પદ્ધતિઓ.
- બેઝ64 અથવા હેક્સ-એન્કોડેડ સ્ટ્રિંગ્સનો હેતુ તર્ક છુપાવવાનો છે.
- શંકાસ્પદ નિયંત્રણ પ્રવાહ, જેમ કે અકુદરતી લૂપ્સ અથવા ગૂંચવણભર્યું લોજિક બ્રાન્ચિંગ.
આ પેટર્ન રીઅલ-ટાઇમ ચેતવણીઓ ટ્રિગર કરે છે pull request સમીક્ષાઓ, પછી ભલે તે પ્રથમ-પક્ષ કોડમાં હોય કે તૃતીય-પક્ષ કોડમાં, સુરક્ષા સમીક્ષકોને ડોઝફ્યુઝેશનને વહેલા પકડવામાં મદદ કરે છે.
અવલંબન વિશ્લેષણ દરમિયાન
Xygeni ફક્ત પેકેજ મેટાડેટા જ નહીં, પરંતુ નવા અથવા અપડેટ કરેલા નિર્ભરતાના વાસ્તવિક સ્ત્રોતનું વિશ્લેષણ કરે છે. તે હેલ્પર ફંક્શન્સ અથવા પોસ્ટઇન્સ્ટોલ સ્ક્રિપ્ટ્સમાં એમ્બેડેડ અસ્પષ્ટ તર્ક શોધી કાઢે છે, ઉચ્ચ-જોખમવાળા પેકેજોને ફ્લેગ કરે છે, ભલે તે સપાટી પર કાયદેસર દેખાય.
બિલ્ડ સમય પર CI/CD Pipelines
Xygeni વર્તનમાં વિસંગતતાઓ માટે CI જોબ્સનું નિરીક્ષણ કરે છે. જો કોઈ બિલ્ડ અચાનક અસામાન્ય CPU અથવા મેમરીનો ઉપયોગ કરે છે, તો Xygeni સ્પાઇકને તાજેતરમાં રજૂ કરાયેલા ચોક્કસ કોડ અથવા પેકેજો સાથે ટ્રેસ કરે છે. તે ડિલિવરીમાં વિક્ષેપ પાડે તે પહેલાં છુપાયેલા DoS પેલોડ્સને પકડવા માટે સ્ટેટિક તારણો સાથે રનટાઇમ વર્તણૂકને આપમેળે સાંકળે છે.
નીતિ અમલીકરણ સ્તર તરીકે
તમે જોખમી પેટર્નને સંપૂર્ણપણે અવરોધિત કરવા માટે Xygeni ને ગોઠવી શકો છો, જેમ કે:
- બેઝ64-એન્કોડેડ કોડ અથવા સમાવિષ્ટ નિર્ભરતાઓને પ્રતિબંધિત કરવી ઇવલ
- બધી પોસ્ટ-ઇન્સ્ટોલ સ્ક્રિપ્ટો માટે મેન્યુઅલ મંજૂરીની જરૂર છે
- પીઆર અથવા સીઆઈ નોકરીઓમાં અસ્પષ્ટ નિયંત્રણ પ્રવાહ માટે શૂન્ય-સહિષ્ણુતા નિયમો લાગુ કરવા
ઝાયજેની સાથે, સુરક્ષા સક્રિય બને છે. તે ટીમોને દૃશ્યતા, પ્રારંભિક ચેતવણીઓ અને ડોસફ્યુસ્કેશન પર આધાર રાખે છે તે પ્રકારની અસ્પષ્ટ તકનીકો સામે નીતિ-સ્તરનું અમલીકરણ આપે છે. દરેક તબક્કા, પીઆર, ડિપેન્ડન્સી સ્કેન અને સીઆઈ રનટાઇમમાં ઝાયજેનીને એમ્બેડ કરીને, તમે પોસ્ટમોર્ટમ બને તે પહેલાં ધમકીને પકડી શકો છો.
તો, ડોસ્ફસ્કેશન તમારા કોડને તમારી વિરુદ્ધ કરી દે છે
ડોસ્ફસ્કેશન માત્ર એક સૈદ્ધાંતિક જોખમ નથી; તે એક વાસ્તવિક અને વધતો જતો હુમલો વેક્ટર છે જે તમારી વિકાસ પ્રક્રિયાને હથિયારમાં ફેરવે છે. તે ઝડપી પ્રકાશનો, સ્વચાલિત ઇન્સ્ટોલ્સ અને મેન્યુઅલી ઓડિટ કરવા માટે ખૂબ જટિલ ડિપેન્ડન્સી ચેઇન્સ વચ્ચેના અંતરમાં ખીલે છે. આ ફક્ત સુરક્ષાનો મુદ્દો નથી; તે એક સોફ્ટવેર એન્જિનિયરિંગ પડકાર છે. અસ્પષ્ટ સેવાનો ઇનકાર પેલોડ્સ પરંપરાગત સંરક્ષણને બાયપાસ કરે છે, પોતાને સીધા કોડમાં એમ્બેડ કરીને, જ્યાં ફાયરવોલ અને ટ્રાફિક ફિલ્ટર્સ પહોંચી શકતા નથી.
વિકાસકર્તાઓ માટે, ઉપાય સરળ છે: જો તમે કોડ લખો છો, તો મંજૂરી આપો pull requests, અથવા મેનેજ કરો CI/CD pipelines, તમે આગળની હરોળ છો. સુરક્ષિત બિલ્ડ્સ ફક્ત સ્વચ્છ કોડ વિશે નથી; તેમને દરેક પગલા પર દૃશ્યતા, ચકાસણી અને નીતિ-સમર્થિત સુરક્ષાની જરૂર છે. pipeline.
ચેકલિસ્ટથી આગળ વધો. તમારા વર્કફ્લોમાં અસ્પષ્ટતા શોધને એકીકૃત કરો. CI સંસાધન ઉપયોગમાં base64 સ્ટ્રિંગ્સ, વિચિત્ર તર્ક અથવા અણધાર્યા સ્પાઇક્સ માટે જુઓ. ફક્ત માન્ય ન કરો શું તમે ઇન્સ્ટોલ કરો છો, પણ તે શું કરે છે. સારવાર pipeline પ્રોડક્શન કોડ જેવા રૂપરેખાંકનો. સ્વચાલિત guardrails. જે વિચિત્ર લાગે છે તેને ચિહ્નિત કરો, ભલે તે "કામ કરે".
કારણ કે ડોસફસ્કેશન બૂમ પાડતું નથી. તે રાહ જુએ છે. અને જો તમે તેને શોધી રહ્યા નથી, તો તે સરકી જશે.
