ચૂકી ગયેલો ચેક જે તમને મોંઘો પડી શકે છે: Requests.get અને ફ્લાસ્ક વિનંતી ફોર્મ
કલ્પના કરો: એક જુનિયર ડેવલપર કોઈ સુવિધા મોકલવા માટે દબાણ હેઠળ કામ કરી રહ્યો છે. તેઓ ફ્લાસ્ક એપ ખોલે છે, નવો રૂટ ઉમેરે છે, ક્વેરી પેરામીટર મેળવે છે અને આગળ વધે છે.
પહેલી નજરે, આ ફ્લાસ્ક વિનંતીનો ઉપયોગ બરાબર લાગે છે. પણ છોડી દો પ્રકાર=પૂર્ણાંક અને તમે દરવાજો ખોલો છો ઇન્જેક્શન હુમલા. આ એવા જોખમો છે જે કોડ સમીક્ષાઓમાંથી પસાર થઈ જાય છે કારણ કે "તે ફક્ત મૂલ્ય લાવે છે."
જ્યાં જોખમ છુપાયેલું છે Fલાસ્ક વિનંતી અને Fલાસ્ક વિનંતી ફોર્મ
બંને ફ્લાસ્ક.રિક્વેસ્ટ અને ફ્લાસ્ક.રિક્વેસ્ટ.ફોર્મ અવિશ્વસનીય પ્રવેશ બિંદુઓ છે. તેઓ જે પણ મૂલ્ય પરત કરે છે તે સીધું ક્લાયન્ટ તરફથી આવે છે અને તેને સંભવિત પ્રતિકૂળ તરીકે ગણવામાં આવવું જોઈએ.
આ ડેટાને માન્ય અથવા સેનિટાઇઝ કરવામાં નિષ્ફળતા ગંભીર સુરક્ષા સમસ્યાઓ તરફ દોરી શકે છે, જેમાં નીચેનાનો સમાવેશ થાય છે:
- એસક્યુએલ ઇન્જેક્શન
- ક્રોસ-સાઇટ સ્ક્રિપ્ટીંગ (XSS)
- ટેમ્પલેટ ઇન્જેક્શન
- શેલ કમાન્ડ ઇન્જેક્શન
આ જોખમો ફક્ત ડેટાબેઝ અથવા ફ્રન્ટ-એન્ડ રેન્ડરિંગ પર લાગુ પડતા નથી; હુમલાખોરો ટેમ્પ્લેટ્સમાં ઉપયોગમાં લેવાતા અથવા સબપ્રોસેસમાં પસાર થયેલા ઇનપુટ્સનો પણ ઉપયોગ કરી શકે છે.
સલામત સ્યુડો-કોડ પેટર્ન:
નિવારક CI/CD અમલીકરણ:
ભલે વાક્યરચના સુરક્ષિત લાગે, ટેમ્પ્લેટ્સ અથવા સિસ્ટમ આદેશોમાં કાચા અથવા અનચેક કરેલા મૂલ્યોનો ઉપયોગ ગંભીર ઇન્જેક્શન વેક્ટર બની શકે છે.
વ્યવહારુ ઇન્જેક્શન ફ્લો (સલામત સિમ્યુલેશન)
કાલ્પનિક, સલામત દૃશ્યનો ઉપયોગ કરીને, ઇન્જેક્શન ખામી સામાન્ય રીતે કેવી રીતે પ્રગટ થાય છે તે અહીં છે:
- વપરાશકર્તા એપ્લિકેશનને એક રચાયેલ ક્વેરી પેરામીટર મોકલે છે.
- એપ્લિકેશન આનો ઉપયોગ કરીને મૂલ્ય વાંચે છે વિનંતી.આર્ગ્સ.ગેટ() માન્યતા વિના.
- તે મૂલ્ય સીધા SQL ક્વેરી, ટેમ્પલેટ સ્ટ્રિંગ અથવા શેલ કમાન્ડમાં જોડાયેલું છે.
- સિસ્ટમ તે તર્કનો અમલ કરે છે, ઇન્જેક્ટેડ સામગ્રીથી અજાણ.
સ્યુડો-કોડ (અસુરક્ષિત, ફક્ત ઉદાહરણ તરીકે):
કાલ્પનિક લોગ ટ્રેસ:
ભલે આ ઉદાહરણ પ્લેસહોલ્ડર્સનો ઉપયોગ કરે છે, તે પ્રતિબિંબિત કરે છે કે ઇનપુટ હેન્ડલિંગમાં નાની ભૂલો કેવી રીતે ગંભીર નબળાઈઓ તરફ દોરી શકે છે.
સ્વયંસંચાલિત પરીક્ષણો આ ચૂકી શકે છે કારણ કે તેઓ સામાન્ય રીતે માન્ય ઇનપુટ પ્રકારો માટે પરીક્ષણ કરે છે, દૂષિત અથવા દૂષિત પ્રકારના નહીં.
ઉપયોગ કરીને નિર્ભરતામાં છુપાયેલા જોખમો ફ્લાસ્ક વિનંતી અને ફ્લાસ્ક વિનંતી ફોર્મ
તમારો કોડ સ્વચ્છ હોઈ શકે છે, પરંતુ તૃતીય-પક્ષ પેકેજો હજુ પણ તમને નુકસાન પહોંચાડી શકે છે.
કેટલાક ફ્લાસ્ક પ્લગઇન્સ અથવા લાઇબ્રેરીઓ આંતરિક રીતે ફ્લાસ્ક વિનંતી અથવા ફ્લાસ્ક વિનંતી ફોર્મને માન્યતા વિના કૉલ કરે છે.
કાલ્પનિક પેકેજો સાથેનું ઉદાહરણ:
In CI/CD, ઓટોમેટેડ ડિપેન્ડન્સી અપડેટ્સ શાંતિથી અસુરક્ષિત વિનંતીઓ.ગેટ કોલ્સ અથવા સંવેદનશીલ ઇનપુટ હેન્ડલિંગ પેટર્ન રજૂ કરી શકે છે.
કેટલું અસુરક્ષિત ફ્લાસ્ક વિનંતી ઉપયોગ સ્લિપ ભૂતકાળના કોડ સમીક્ષાઓ
ઝડપી ગતિવાળા વાતાવરણમાં, નાની પણ ખતરનાક ભૂલો ઘણીવાર ધ્યાન બહાર રહેતી નથી, ખાસ કરીને જ્યારે ફેરફાર હાનિકારક લાગે છે.
ઉદાહરણ pull request તફાવત:
સમીક્ષકની ટિપ્પણી:
"સારું લાગે છે, તે ફક્ત એક પરિમાણ મેળવી રહ્યું છે."
આ પ્રકારની દેખરેખ સામાન્ય છે કારણ કે:
- જ્ઞાનાત્મક પૂર્વગ્રહ: સમીક્ષકો ધારી શકે છે કે request.args.get() મૂળભૂત રીતે સુરક્ષિત છે.
- સમય દબાણ: સમયમર્યાદા પૂરી થાય ત્યારે સુરક્ષા તપાસ પાછળ રહી જાય છે.
- ભિન્ન પરિચિતતા: ફેરફાર નજીવો લાગે છે, તેથી તેની ઊંડી તપાસ થતી નથી.
સ્પષ્ટ નિયમો અથવા સ્વચાલિત અમલીકરણ વિના, આ સૂક્ષ્મ જોખમો ઉત્પાદનમાં ધ્યાન વગર સરકી જાય છે.
નિવારણ જે કામ કરે છે
ઇન્જેક્શનના જોખમોને ઘટાડવા માટે, ઇનપુટ માન્યતા, સ્વચાલિત સ્કેનિંગ અને પરીક્ષણ કવરેજને જોડો.
કાસ્ટિંગ અને વ્હાઇટલિસ્ટિંગ સાથે ઇનપુટ માન્યતા:
કાસ્ટિંગ મૂલ્યને સલામત પ્રકાર પર દબાણ કરે છે, જ્યારે વ્હાઇટલિસ્ટિંગ ફક્ત જાણીતા-સારા મૂલ્યો જ આગળ વધે છે તેની ખાતરી કરે છે.
સ્ટેટિક એપ્લિકેશન સુરક્ષા પરીક્ષણ (SAST) માં CI/CD:
આ પગલું અમાન્ય શોધવામાં મદદ કરે છે વિનંતી.આર્ગ્સ.ગેટ() or વિનંતી.ફોર્મ.ગેટ() ઉત્પાદન સુધી પહોંચે તે પહેલાં કોલ.
સેનિટાઇઝેશન લાગુ કરવા માટે યુનિટ ટેસ્ટ:
આ પરીક્ષણો ખાતરી કરે છે કે એપ્લિકેશન દૂષિત અથવા દૂષિત ઇનપુટને સતત નકારે છે.
DevSecOps માં એકીકરણ Pipelines
મિડલવેર અમલીકરણ:
@એપ.બેફોર_રિક્વેસ્ટ
તમારા કોડ અને તૃતીય-પક્ષ નિર્ભરતા બંનેને સ્કેન કરી રહ્યા છીએ ઉત્પાદન સુધી પહોંચે તે પહેલાં અસુરક્ષિત requests.get, flask request, અને flask request ફોર્મનો ઉપયોગ પકડવામાં મદદ કરે છે.
આ સમસ્યા ફ્લાસ્કથી આગળ વધે છે
અસુરક્ષિત ઇનપુટ હેન્ડલિંગ ફક્ત ફ્લાસ્ક માટે જ વિશિષ્ટ નથી, તે સમગ્ર વેબ ફ્રેમવર્કમાં અસ્તિત્વ ધરાવે છે. સદનસીબે, ઉકેલ સુસંગત છે: ઇનપુટ્સને વહેલા અને કડક રીતે માન્ય કરો.
જેંગો (સલામત સ્યુડો-કોડ):
FastAPI (પ્રકાર સંકેતોનો ઉપયોગ કરીને ડિઝાઇન દ્વારા સલામત):
બંને ઉદાહરણો ઇનપુટ પ્રકાર અને શ્રેણીને લાગુ કરે છે, ખાતરી કરે છે કે આવનારા ડેટા સંવેદનશીલ તર્ક સુધી પહોંચે તે પહેલાં વિશ્વસનીય છે.
ભલે તે ફ્લાસ્ક, જેંગો, કે ફાસ્ટએપીઆઈ હોય, દરેક વિનંતી પરિમાણ જો યોગ્ય રીતે માન્ય ન હોય તો તે સંભવિત ઇન્જેક્શન બિંદુ છે.
DevSecOps માં શોધ માટે Xygeni નો ઉપયોગ
DevSecOps વાતાવરણમાં, મેન્યુઅલ સમીક્ષાઓ પૂરતી નથી. ઝીગેની અસુરક્ષિત ફ્લાસ્ક વિનંતી, ફ્લાસ્ક વિનંતી ફોર્મ અને requests.get ઉપયોગની શોધને સ્વચાલિત કરે છે.
વ્યવહારુ DevSecOps એપ્લિકેશનો:
- સ્ટેટિક સ્કેન: કોઈપણને ફ્લેગ કરે છે વિનંતી.આર્ગ્સ.ગેટ() વગર પ્રકાર=, અને ફ્લાસ્ક વિનંતી ફોર્મ કોલ્સ જેમાં માન્યતાનો અભાવ છે.
- નિર્ભરતા વિશ્લેષણ: પરોક્ષ કોલ્સ દ્વારા દેખાતા અસુરક્ષિત પેટર્ન માટે લાઇબ્રેરીઓનું નિરીક્ષણ કરે છે.
- અસુરક્ષિત મર્જને અવરોધિત કરી રહ્યા છીએ: CI/CD જો નવો કોડ જોખમી requests.get અથવા અમાન્ય ફોર્મ ઍક્સેસ રજૂ કરે છે તો નિષ્ફળ જાય છે.
- મૂળભૂત અમલીકરણ: કોલ્સ અસુરક્ષિત કોલ્સ તરફ પાછા ફરતા અટકાવવા માટે ફેરફારોને ટ્રેક કરે છે.
આ તપાસને સ્વચાલિત કરવાથી માનવ ભૂલનું જોખમ ઓછું થાય છે અને ડિલિવરી ધીમી કર્યા વિના સુરક્ષાને સતત રાખે છે.
તો, માન્ય કરો, સેનિટાઇઝ કરો, ઓટોમેટ કરો
અહીં મુખ્ય વાત છે: requests.get, flask request, અને flask request form બધું જ છે ડિફૉલ્ટ રૂપે અવિશ્વસનીય. જો તમે કોઈ કાર્યવાહી નહીં કરો તો તેઓ ખુશીથી દૂષિત ડેટા પહોંચાડશે.
તમારા ત્રણ નિયમો:
- માન્ય કાસ્ટિંગ અને વ્હાઇટલિસ્ટનો ઉપયોગ કરીને ઇનપુટ્સ.
- સાનિટાઇઝ ડેટા સંવેદનશીલ કામગીરીને સ્પર્શે તે પહેલાં.
- સ્વયંચાલિત તમારા ચેક ઇન કરો pipeline જમાવટ પહેલાં અસુરક્ષિત કોડ રોકવા માટે.
એક જ અસુરક્ષિત ફ્લાસ્ક વિનંતી હેન્ડલર, અનચેક કરેલ ફ્લાસ્ક વિનંતી ફોર્મ ફીલ્ડ, અથવા અનગાર્ડેડ requests.get કૉલ તમારી એપ્લિકેશન સાથે ચેડા કરી શકે છે. દરેક પરિમાણને સંભવિત પ્રતિકૂળ તરીકે ગણો, અને તમારા DevSecOps ને pipeline દરેક વખતે નિયમોનો અમલ કરો.
