ലൈവ് ആകുന്നതിന് മുമ്പ് ഡെവലപ്പർമാർ അറിഞ്ഞിരിക്കേണ്ട കാര്യങ്ങൾ
AppSec പിശകുകൾ ഇപ്പോഴും നിർമ്മാണത്തിലേക്ക് വഴുതി വീഴുന്നു, പ്രത്യേകിച്ചും അവ വ്യക്തമായ കാഴ്ചയിൽ മറഞ്ഞിരിക്കുമ്പോൾ. അവശേഷിക്കുന്ന CTF ടോക്കൺ ആയാലും, അസാധുവായ CSRF ടോക്കൺ ആയാലും, അല്ലെങ്കിൽ ഓപ്പൺ സോഴ്സ് പാക്കേജുകളിൽ മറഞ്ഞിരിക്കുന്ന രഹസ്യങ്ങൾ ആയാലും, അപകടസാധ്യതകൾ യഥാർത്ഥമാണ്. ഡെവലപ്പർമാർ പലപ്പോഴും ഈ പ്രശ്നങ്ങൾ ഡെവലപ്പർ പരിതസ്ഥിതികളിൽ നിരുപദ്രവകരമാണെന്ന് അനുമാനിക്കുന്നു, പക്ഷേ ആക്രമണകാരികൾ താഴ്ന്ന നിലയിലുള്ള ഫലം ഇഷ്ടപ്പെടുന്നു. തത്സമയമാകുന്നതിന് മുമ്പ് നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട കാര്യങ്ങൾ ഇതാ.
ഷിപ്പിംഗ് രഹസ്യങ്ങൾ നിർത്തുക: ഒരു സിടിഎഫ് ടോക്കൺ പോലും ഒരു സുരക്ഷാ അപകടമാകുന്നത് എന്തുകൊണ്ട്?
"ഇത് പരീക്ഷണത്തിന് വേണ്ടി മാത്രമുള്ളതാണ്" എന്ന് കരുതി നിങ്ങൾ എപ്പോഴെങ്കിലും ഒരു Google CTF ടോക്കണോ ഡമ്മി സീക്രട്ടോ ഒരു റെപ്പോയിൽ ഉപേക്ഷിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഒറ്റയ്ക്കല്ല. പക്ഷേ അത് സുരക്ഷിതമല്ല. സുരക്ഷാ വെല്ലുവിളികളിൽ പോലും, യഥാർത്ഥ ലോകത്തിലെ ലംഘനങ്ങളിൽ തുറന്നുകാണിച്ച ടോക്കണുകൾ എങ്ങനെ ഉപയോഗിച്ചുവെന്ന് പൊതു ഉദാഹരണങ്ങൾ കാണിക്കുന്നു.
കോഡിൽ അവശേഷിക്കുന്ന രഹസ്യങ്ങൾ അപകടകരമാണ്.:
- അവ പലപ്പോഴും ബിൽഡ് ലോഗുകളിലോ ഡോക്കർ ഇമേജുകളിലോ ആണ് എത്തുന്നത്.
- നിങ്ങൾ വിചാരിക്കുന്നതിലും കൂടുതൽ തവണ അവ പരിതസ്ഥിതികളിൽ വീണ്ടും ഉപയോഗിക്കപ്പെടുന്നു.
- റെപ്പോ വിസിബിലിറ്റിയുമായോ സിഐ ആർട്ടിഫാക്റ്റുകളുമായോ ജോടിയാക്കുമ്പോൾ ഒരു സിടിഎഫ് ടോക്കൺ പോലും ചൂഷണം ചെയ്യാൻ കഴിയും.
ഉദാഹരണം: വിശദമായ ഔട്ട്പുട്ട് കാരണം ഒരു GitHub Action പൊതു ലോഗുകളിൽ ടെസ്റ്റ് ക്രെഡൻഷ്യലുകൾ ചോർത്തി. അതൊരു നിർമ്മാണ രഹസ്യമായിരുന്നില്ല., പക്ഷേ അത് ആക്രമണകാരികൾക്ക് ഒരു ബ്ലൂപ്രിന്റ് നൽകി.
അസാധുവായ CSRF ടോക്കൺ: ഒരു നിശബ്ദ ആപ്പ് ബ്രേക്കർ
ക്രോസ്-സൈറ്റ് റിക്വസ്റ്റ് ഫോർജറി (CSRF) എന്നത് ഒരു ഉപയോക്താവിന്റെ ബ്രൗസറിനെ കബളിപ്പിച്ച്, അവ ആധികാരികമാക്കപ്പെട്ട ഒരു വെബ് ആപ്ലിക്കേഷനിലേക്ക് അനാവശ്യ അഭ്യർത്ഥനകൾ നടത്തുന്നതിന് പ്രേരിപ്പിക്കുന്ന ഒരു ആക്രമണമാണ്. ഫോം സമർപ്പണങ്ങൾ അല്ലെങ്കിൽ API കോളുകൾ പോലുള്ള ഏതെങ്കിലും സ്റ്റേറ്റ്-ചേഞ്ചിംഗ് അഭ്യർത്ഥനയ്ക്കൊപ്പം അയയ്ക്കേണ്ട ഒരു ടോക്കൺ സൃഷ്ടിച്ചുകൊണ്ടാണ് CSRF സംരക്ഷണം സാധാരണയായി പ്രവർത്തിക്കുന്നത്. ടോക്കൺ നഷ്ടപ്പെട്ടാലോ അസാധുവാണെങ്കിലോ, അഭ്യർത്ഥന തടയപ്പെടും.
ആധുനിക ആപ്പുകളിൽ, പ്രത്യേകിച്ച് സിംഗിൾ-പേജ് ആപ്ലിക്കേഷനുകളിൽ (SPA-കൾ) അല്ലെങ്കിൽ API-ഫസ്റ്റ് ബാക്കെൻഡുകളിൽ, ഈ സജ്ജീകരണം നിശബ്ദമായി പരാജയപ്പെടുകയോ ശരിയായി നടപ്പിലാക്കിയില്ലെങ്കിൽ ഫലപ്രദമല്ലാതാകുകയോ ചെയ്യാം.
ഇന്ന് CSRF സംരക്ഷണത്തെ തകർക്കുന്നത് എന്താണ്:
- തെറ്റായി കോൺഫിഗർ ചെയ്ത SameSite കുക്കി ആട്രിബ്യൂട്ടുകൾ.
- ഓത്ത് ഫ്ലോകൾ ഡൊമെയ്നുകൾ അല്ലെങ്കിൽ മൈക്രോസർവീസുകൾക്കിടയിൽ വിഭജിച്ചിരിക്കുന്നു.
- ശേഷം ടോക്കൺ പുതുക്കലിന്റെ അഭാവം login സംസ്ഥാന മാറ്റങ്ങൾ.
CSRF തകർക്കാൻ നിങ്ങൾക്ക് ഒരു ക്ഷുദ്ര സ്ക്രിപ്റ്റ് ആവശ്യമില്ല. മോശം സെഷൻ കൈകാര്യം ചെയ്യൽ മാത്രമാണ് ഇതിന് വേണ്ടത്. ഒരു ആപ്പ് അതിന്റെ SameSite കുക്കിയെ വീണ്ടും മൂല്യനിർണ്ണയം ചെയ്യുന്നതിൽ പരാജയപ്പെട്ടു. login, ഒരു ഉപയോക്താവ് ഒരു സംരക്ഷിത റൂട്ടിൽ എത്തുന്നതുവരെ ടോക്കൺ പൊരുത്തക്കേടുകൾ ശ്രദ്ധിക്കപ്പെടാതെ കടന്നുപോകാൻ അനുവദിക്കുന്നു.
പ്രധാനമായും, അസാധുവായ ഒരു CSRF ടോക്കൺ സന്ദേശം പ്രത്യക്ഷപ്പെടുന്നത് ഒരു ചെറിയ ഫ്രണ്ട് എൻഡ് പ്രശ്നം മാത്രമല്ല; സെഷൻ ഫ്ലോയിലോ ടോക്കൺ മാനേജ്മെന്റിലോ ഒരു യഥാർത്ഥ ദുർബലതയെ ഇത് സൂചിപ്പിക്കാം. CTF പരിതസ്ഥിതികളിലോ ഡെവലപ്മെന്റ് ടെസ്റ്റിംഗിലോ മാത്രം ദൃശ്യമാകുന്ന ഒന്നല്ല, പ്രൊഡക്ഷൻ സിസ്റ്റങ്ങളിലെ വ്യാപകമായ ഒരു പ്രശ്നമാണിത്.
രഹസ്യ ചോർച്ചകൾ Pipelineഎസ്: എന്തുകൊണ്ട് CI/CD നിങ്ങളുടെ ആദ്യ ആക്രമണ ഉപരിതലമാണോ - CTF ടോക്കൺ
നിങ്ങളുടെ സി.ഐ. pipeline കോഡ്, കോൺഫിഗുകൾ, ടെസ്റ്റുകൾ, ലോഗുകൾ എന്നിങ്ങനെ എല്ലാം പ്രോസസ്സ് ചെയ്യുന്നു. രഹസ്യങ്ങൾ മിക്കപ്പോഴും വെളിപ്പെടുന്നത് ഇവിടെയാണ്.
സാധാരണ ചോർച്ച പോയിന്റുകൾ:
- ഹാർഡ്കോഡ് ചെയ്ത രഹസ്യങ്ങൾ in .എംവ് ഫയലുകൾ.
- വെർബോസ് ഇൻസ്റ്റാൾ സ്ക്രിപ്റ്റുകൾ (ഉദാ. npm ഇൻസ്റ്റാളുചെയ്യുക) കുത്തിവച്ച ടോക്കണുകൾ ലോഗിംഗ് ചെയ്യുന്നു.
- തെറ്റായി കോൺഫിഗർ ചെയ്ത റണ്ണേഴ്സ് അല്ലെങ്കിൽ ക്രെഡൻഷ്യലുകൾ ആക്സസ് ചെയ്യുന്ന മൂന്നാം കക്ഷി പ്രവർത്തനങ്ങൾ.
ഒരു ഡെവലപ്പർ ഒരിക്കൽ ഒരു സിടിഎഫ് ടോക്കൺ ഡീബഗ്ഗിംഗിനായി. ഇത് മൂന്ന് ലയനങ്ങളെ അതിജീവിച്ചു, ലോഗുകളിൽ എത്തി, സെർച്ച് എഞ്ചിനുകൾ സൂചികയിലാക്കിയ ശേഷം ഓട്ടോമേറ്റഡ് സ്കാനറുകളിൽ കണ്ടെത്തി.
ശുപാർശ ചെയ്യുന്ന നിയന്ത്രണങ്ങൾ:
- ഇതിനായുള്ള പരാജയ-ക്ഷമ നയങ്ങൾ .എംവ് രഹസ്യങ്ങൾ commits.
- ലോഗ് സാനിറ്റൈസേഷൻ ഡിഫോൾട്ടായി പ്രാപ്തമാക്കിയിരിക്കുന്നു.
- Gitleaks, TruffleHog, അല്ലെങ്കിൽ നേറ്റീവ് GitHub രഹസ്യ കണ്ടെത്തൽ പോലുള്ള തത്സമയ സ്കാനറുകൾ.
ആശ്രിതത്വങ്ങളും ചോർന്നേക്കാം: ഓപ്പൺ സോഴ്സ്, തേർഡ്-പാർട്ടി പാക്കേജ് അപകടസാധ്യതകൾ
ഓപ്പൺ സോഴ്സ് പാക്കേജുകൾ രഹസ്യങ്ങളിൽ നിന്ന് മുക്തമല്ല. ചിലതിൽ അബദ്ധത്തിൽ ഉൾച്ചേർത്ത യഥാർത്ഥ കീകൾ പോലും അടങ്ങിയിരിക്കുന്നു. അടുത്തിടെയുള്ളത് ഗൂഗിൾ സിടിഎഫ് നല്ല ഉദ്ദേശ്യമുള്ള പാക്കേജുകൾക്ക് പോലും അപകടസാധ്യത എങ്ങനെ കൊണ്ടുവരാൻ കഴിയുമെന്ന് ചിത്രീകരിക്കുന്ന, ഈ കൃത്യമായ വെക്റ്ററിനെ ചലഞ്ച് അനുകരിച്ചു.
കാട്ടിലെ ഉദാഹരണങ്ങൾ:
- നോഡ്_മൊഡ്യൂളുകൾ/ഉദാഹരണം-ക്രെഡിറ്റ്സ്.ജെസൺ പ്രൊഡക്ഷൻ ഫോർമാറ്റുമായി പൊരുത്തപ്പെടുന്ന OAuth ടെസ്റ്റ് ടോക്കണുകൾ അടങ്ങിയിരിക്കുന്നു.
- .env.ഡീബഗ് ലോക്കൽ ഡെവലപ്മെന്റ് സമയത്ത് API കീകൾ ഉപയോഗിച്ച് അബദ്ധത്തിൽ പ്രസിദ്ധീകരിച്ച ഫയലുകൾ.
- ആന്തരിക പരിതസ്ഥിതികൾക്കായുള്ള JWT-കൾ അല്ലെങ്കിൽ ക്ലൗഡ് ക്രെഡൻഷ്യലുകൾ ഉൾപ്പെടെയുള്ള യൂണിറ്റ് ടെസ്റ്റ് ഫിക്ചറുകൾ.
- എളുപ്പത്തിലുള്ള ടെസ്റ്റ് ഓർക്കസ്ട്രേഷനായി യഥാർത്ഥ ടോക്കണുകളോ രഹസ്യങ്ങളോ ഉൾച്ചേർക്കുന്ന ശേഷിക്കുന്ന ടെസ്റ്റ് ഹാർനെസുകൾ.
ഇവ അപൂർവമായ അപവാദങ്ങളല്ല; അവ വ്യവസ്ഥാപിതമായി കണക്കാക്കപ്പെടുന്ന തരത്തിൽ പലപ്പോഴും സംഭവിക്കാറുണ്ട്. പൊതു പാക്കേജുകളിലെ രഹസ്യങ്ങൾ സ്കാനിംഗ് ഉപകരണങ്ങൾ പതിവായി ഫ്ലാഗ് ചെയ്യുകയും മാനുവൽ കോഡ് അവലോകനങ്ങളിൽ പലപ്പോഴും അവഗണിക്കുകയും ചെയ്യുന്നു.
തുടർച്ചയായ സ്കാനിംഗ് എന്തുകൊണ്ട് പ്രധാനമാണ്:
- മൂന്നാം കക്ഷി പാക്കേജുകൾ മുൻകൂർ അറിയിപ്പില്ലാതെ മാറ്റാൻ കഴിയും. ഒരു ചെറിയ പതിപ്പ് ബമ്പ് പോലും സെൻസിറ്റീവ് ഡാറ്റയുള്ള ഒരു പുതിയ ഫയൽ അവതരിപ്പിച്ചേക്കാം.
- മാനുവൽ പരിശോധന അളക്കാൻ കഴിയില്ല; ഉൾച്ചേർത്ത രഹസ്യങ്ങൾ സ്കെയിലിൽ കണ്ടെത്താനുള്ള ഏക മാർഗം ഓട്ടോമേറ്റഡ് ഉപകരണങ്ങൾ മാത്രമാണ്.
- ഓട്ടോമേറ്റഡ് നയങ്ങൾ ഉപയോഗിക്കുക, അത് രഹസ്യങ്ങൾക്കായി ഡിപൻഡൻസികൾ ആവർത്തിച്ച് സ്കാൻ ചെയ്യുക, ഉള്ളിൽ പോലും node_modules, ടെസ്റ്റ് ഡാറ്റ, അല്ലെങ്കിൽ .എംവ് പുരാവസ്തുക്കൾ.
ബിൽഡ് പോളിസികൾ പൊതു പാക്കേജുകളെ ഇന്റേണൽ കോഡിന്റെ അതേ സൂക്ഷ്മപരിശോധനയോടെ പരിഗണിക്കണം, കാരണം ഒരു എംബഡഡ് സിടിഎഫ് ടോക്കൺ അല്ലെങ്കിൽ അവശിഷ്ടം .എംവ് ഫയൽ മാത്രമാണ് വേണ്ടത്.
DevOps പ്രതിരോധ നടപടികൾ: സുരക്ഷിതം CI/CD സ്കെയിൽ ചെയ്യുന്ന ഡിഫോൾട്ടുകൾ
നിങ്ങളുടെ സുരക്ഷിതമാക്കുന്നു pipeline ഉപകരണങ്ങളെക്കുറിച്ച് മാത്രമല്ല; ഇത് ഓട്ടോമേറ്റഡ് നയങ്ങൾ സജ്ജീകരിക്കുന്നതിനെക്കുറിച്ചും guardrails ഉൽപ്പാദനത്തിലേക്ക് എത്തുന്നതിനുമുമ്പ് അപകടകരമായ പാറ്റേണുകൾ പിടിക്കുന്നവർ. യഥാർത്ഥ ലോകം CI/CD ശുചിതപരിപാലനം തുടർച്ചയായ നടപ്പാക്കലും പ്രതിരോധത്തിന് മുൻഗണന നൽകുന്ന സ്ഥിരസ്ഥിതികൾ വ്യക്തമാക്കലും ആവശ്യമാണ്.
സുരക്ഷിതത്വത്തിനായുള്ള വിപുലീകരിച്ച രീതികൾ pipelines:
- രഹസ്യ സ്കാനിംഗ് at commit കാലം: എല്ലാം പരിശോധിക്കുക commitമണല് pull requests രഹസ്യങ്ങൾക്ക്, പ്രത്യേകിച്ച് .env ഫയലുകൾ, config.js, YAML ഫയലുകളും a-യോട് സാമ്യമുള്ള ടോക്കൺ പാറ്റേണുകളും സിടിഎഫ് ടോക്കൺലംഘനങ്ങൾ കണ്ടെത്തുമ്പോൾ ബ്ലോക്ക് യാന്ത്രികമായി ലയിക്കുന്നു.
- പരാജയപ്പെടുന്ന നയ നിർവ്വഹണം: ബിൽഡുകൾ പരാജയപ്പെടാൻ ഒരു CI ജോലിയുടെ അവസാനം വരെ കാത്തിരിക്കരുത്. രഹസ്യങ്ങളോ തെറ്റായ കോൺഫിഗറേഷനുകളോ കണ്ടെത്തുമ്പോൾ നേരത്തെ അവസാനിപ്പിക്കുന്ന നയങ്ങൾ സജ്ജമാക്കുക. ഇത് സമയം ലാഭിക്കുകയും മോശം കോഡ് കൂടുതൽ പുരോഗമിക്കുന്നത് തടയുകയും ചെയ്യുന്നു. pipeline.
- ലോഗ് പരിശോധനയും തിരുത്തലും: ലോഗുകൾ രഹസ്യങ്ങൾ ചോർത്തുന്നതിന്റെ ഒരു സാധാരണ ഉറവിടമാണ്. പോലുള്ള സെൻസിറ്റീവ് മൂല്യങ്ങൾക്കായി ലോഗ് സ്ക്രബ്ബിംഗ് അല്ലെങ്കിൽ മാസ്കിംഗ് നടപ്പിലാക്കുക അംഗീകാരം: ഹെഡറുകൾ, കുക്കികൾ, API ടോക്കണുകൾ. സമാനമായ പാറ്റേണുകൾക്കായുള്ള ഓഡിറ്റ് ലോഗുകൾ ഗൂഗിൾ സിടിഎഫ് ഐഡന്റിഫയറുകൾ അല്ലെങ്കിൽ ആന്തരിക ടോക്കണുകൾ.
- CSRF സംരക്ഷണ കവറേജ്: സെഷൻ ഫ്ലോകളെ സാധൂകരിക്കുന്ന ഓട്ടോമേറ്റഡ് ടെസ്റ്റുകൾ സംയോജിപ്പിക്കുകയും SameSite, ക്രോസ്-ഒറിജിൻ സാഹചര്യങ്ങളിൽ കുക്കികളും CSRF ടോക്കണുകളും സ്ഥിരമായി പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുക. സിസ്റ്റം ഒരു അസാധുവായ CSRF ടോക്കൺ.
- നിർബന്ധിത രഹസ്യ ഭ്രമണം: PR-കൾ ലയിപ്പിക്കുമ്പോഴോ ചോർച്ചകൾ കണ്ടെത്തുമ്പോഴോ രഹസ്യങ്ങളും ടോക്കണുകളും തിരിക്കണം. ഉൽപ്പാദനത്തിലോ CI പരിതസ്ഥിതികളിലോ പഴകിയ രഹസ്യങ്ങൾ നിലനിൽക്കാതിരിക്കാൻ കീ റൊട്ടേഷൻ വർക്ക്ഫ്ലോകൾ ഓട്ടോമേറ്റ് ചെയ്യുക.
- ഡെവലപ്പിൽ റെഡ്-ടീം സിമുലേഷനുകൾ ഒഴിവാക്കുക.: പരീക്ഷണ ആവശ്യങ്ങൾക്കായി പോലും, dev അല്ലെങ്കിൽ CI ഫ്ലോകളിലേക്ക് കോൺക്രീറ്റ് ആക്രമണ കമാൻഡുകളോ പേലോഡുകളോ ചേർക്കുന്നത് ഒഴിവാക്കുക. കണ്ടെത്തൽ യുക്തി പ്രദർശിപ്പിക്കുകയാണെങ്കിൽ, സ്യൂഡോകോഡ് ഉപയോഗിക്കുക (ഉദാ., // ഉദാഹരണ ടോക്കൺ=ABC123) കൂടാതെ അതിനെ ഒരു നോൺ-ഫങ്ഷണൽ പ്ലെയ്സ്ഹോൾഡറായി അടയാളപ്പെടുത്തുക. ടെസ്റ്റുകളിൽ പോലും യഥാർത്ഥ എക്സ്പ്ലോയിറ്റ് വാക്യഘടന ദുരുപയോഗം ചെയ്യുന്നത് പൊതു ലോഗുകളിലോ ഓഡിറ്റുകളിലോ പ്രതികൂലമായേക്കാം.
സുരക്ഷാ അവബോധം യഥാർത്ഥ സാഹചര്യങ്ങളിൽ ശുചിത്വം നടപ്പിലാക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കണം: commit-സമയ സ്കാനിംഗ്, രഹസ്യ തടയൽ, സെഷൻ മൂല്യനിർണ്ണയം, കൃത്രിമ ആക്രമണ സിമുലേഷനുകളല്ല. കോഡ് അവലോകനത്തിന് ശേഷമുള്ള ഒരു ഘട്ടമല്ല, സുരക്ഷയെ നിങ്ങളുടെ ടീം എങ്ങനെ നിർമ്മിക്കുന്നു എന്നതിന്റെ ഭാഗമാക്കുക എന്നതാണ് ലക്ഷ്യം. ടോക്കൺ സ്കാനിംഗ് മുതൽ CSRF വാലിഡേഷൻ വരെ എല്ലാം ഒരേപോലെ ആയിരിക്കണം. pipelineനിങ്ങളുടെ കോഡ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും ചെയ്യുന്ന ഉപയോക്തൃ പിന്തുണകൾ.
സ്കെയിലിൽ അപകടസാധ്യതകൾ കണ്ടെത്തൽ: DevSecOps നടപ്പിലാക്കാൻ Xygeni എങ്ങനെ സഹായിക്കുന്നു
സുരക്ഷിതമായ DevSecOps-ന്റെ ഭാഗമായി pipeline, സൈജെനി അത്യാവശ്യ സുരക്ഷാ പരിശോധനകൾ ഓട്ടോമേറ്റ് ചെയ്യുന്ന ഒരു എൻഫോഴ്സ്മെന്റ് ലെയറായി പ്രവർത്തിക്കുന്നു. CI/CD ജീവിതചക്രം. നല്ല ശീലങ്ങളെ മാറ്റിസ്ഥാപിക്കുകയല്ല ഇതിന്റെ പങ്ക്, മറിച്ച് വൈവിധ്യമാർന്ന പരിതസ്ഥിതികളിൽ അവ തുടർച്ചയായി, അളവിൽ, പ്രയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക എന്നതാണ്.
സൈജെനി പ്രധാന നിയന്ത്രണങ്ങൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നു pipeline, അതുപോലെ:
- സ്കാൻ ചെയ്യുന്നു pull requests നിർമ്മിക്കുകയും ചെയ്യുന്നു വെളിപ്പെടുത്തിയ രഹസ്യങ്ങൾക്ക്, എ പോലുള്ള ടോക്കണുകൾ ഉൾപ്പെടെ സിടിഎഫ് ടോക്കൺ അല്ലെങ്കിൽ ടെസ്റ്റ് ആർട്ടിഫാക്റ്റുകളിൽ മറഞ്ഞിരിക്കുന്ന ക്രെഡൻഷ്യലുകൾ.
- വിന്യാസങ്ങൾ തടയൽ if .എംവ് ഫയലുകളോ അറിയപ്പെടുന്ന സെൻസിറ്റീവ് പാറ്റേണുകളോ ഇതിൽ കാണപ്പെടുന്നു commits, ബിൽഡുകൾ, അല്ലെങ്കിൽ ആശ്രിതത്വങ്ങൾ.
- നിർബന്ധിത രഹസ്യ ഭ്രമണം നടപ്പിലാക്കുന്നു ഒരു രഹസ്യം കണ്ടെത്തുമ്പോൾ ലയിപ്പിക്കുമ്പോൾ, പഴകിയതോ വിട്ടുവീഴ്ച ചെയ്തതോ ആയ ടോക്കണുകൾ നിലനിൽക്കില്ലെന്ന് ഉറപ്പാക്കുന്നു.
- CSRF തെറ്റായ കോൺഫിഗറേഷനുകൾ തിരിച്ചറിയൽ, ഒരു കാരണമായേക്കാവുന്ന പാറ്റേണുകൾ ഉൾപ്പെടെ അസാധുവായ CSRF ടോക്കൺ പിശക്, സെഷൻ തെറ്റായ ക്രമീകരണങ്ങൾ ഫ്ലാഗുചെയ്യൽ, അല്ലെങ്കിൽ SameSite പ്രശ്നങ്ങൾ.
- CI-നേറ്റീവ് ഇന്റഗ്രേഷൻ പ്ലാറ്റ്ഫോമുകളിലുടനീളം (GitHub, GitLab, Jenkins, Bitbucket), ഡെവലപ്പർമാരെ മന്ദഗതിയിലാക്കാതെ നിലവിലുള്ള വർക്ക്ഫ്ലോകൾക്കുള്ളിൽ സുരക്ഷാ നയങ്ങൾ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു.
ഈ നിയന്ത്രണങ്ങൾ ഉണ്ടായിരിക്കുന്നത് നല്ലതല്ല; അവ മാനുവൽ അവലോകനങ്ങൾക്കും ഉൽപ്പാദന സുരക്ഷയ്ക്കും ഇടയിലുള്ള വിടവ് നികത്തുന്നു. സുരക്ഷാ നിയമങ്ങൾ നേരിട്ട് CI p-യിൽ ഉൾപ്പെടുത്തുന്നതിലൂടെഐപ്ലൈൻ ഉപയോഗിച്ച്, ടീമുകൾ അവരുടെ ഉപകരണങ്ങളോ ശീലങ്ങളോ മാറ്റാതെ തന്നെ ബ്ലൈൻഡ് സ്പോട്ടുകൾ കുറയ്ക്കുന്നു.
അന്തിമ ചെക്ക്ലിസ്റ്റ്: തത്സമയമാകുന്നതിന് മുമ്പ്
| പ്രീ-ലോഞ്ച് സുരക്ഷാ പരിശോധന | എന്താണ് സാധൂകരിക്കേണ്ടത് |
|---|---|
| ഹാർഡ്കോഡ് ചെയ്ത രഹസ്യങ്ങളോ ശേഷിക്കുന്ന CTF ടോക്കണോ ഇല്ല. | എല്ലാ കോഡും ചരിത്രവും ഏതെങ്കിലും ടെസ്റ്റ് ടോക്കണുകളിൽ നിന്നോ CTF ടോക്കണുകളിൽ നിന്നോ ക്രെഡൻഷ്യലുകളിൽ നിന്നോ മുക്തമാണെന്ന് ഉറപ്പാക്കുക. |
| CSRF സംരക്ഷണം പൂർണ്ണമായും സാധൂകരിക്കപ്പെട്ടിരിക്കുന്നു. | പരിശോധന loginഅസാധുവായ CSRF ടോക്കൺ പിശകുകൾ അല്ലെങ്കിൽ SameSite പ്രശ്നങ്ങൾ പോലുള്ള പ്രശ്നങ്ങൾക്ക് /session ഫ്ലോകൾ. |
| CI/CD pipeline അണുവിമുക്തമാക്കി | .env ഫയൽ ബ്ലോക്ക് ചെയ്യുക commits, ലോഗുകൾ സ്കാൻ ചെയ്യുക, ബിൽഡ് ഘട്ടങ്ങളിൽ രഹസ്യ എക്സ്പോഷർ തടയുക. |
| എല്ലാ ഡിപൻഡൻസികളും സ്കാൻ ചെയ്തു | എംബഡഡ് സീക്രട്ട്സിനോ ടെസ്റ്റ് ഡാറ്റയ്ക്കോ വേണ്ടി മൂന്നാം കക്ഷി പാക്കേജുകളും നോഡ്_മൊഡ്യൂളുകളും പരിശോധിക്കുക. |
| വിന്യാസത്തിനു ശേഷമുള്ള നിരീക്ഷണം സജീവമാണ് | ടോക്കൺ ദുരുപയോഗം, പ്രത്യേകിച്ച് റോഗ് ഓതറൈസേഷൻ ഹെഡറുകൾ അല്ലെങ്കിൽ ടോക്കൺ പുനരുപയോഗം എന്നിവ നിരീക്ഷിക്കുക. |
| CI നയങ്ങൾ വഴിയുള്ള നിർവ്വഹണം (Google CTF ശുചിത്വം) | രഹസ്യങ്ങൾ കണ്ടെത്തിയാൽ PR-കൾ തടയുന്നതിനും നിർബന്ധിത ഭ്രമണത്തിനും ഓട്ടോമേറ്റഡ് നിയമങ്ങൾ പ്രയോഗിക്കുക. |
യഥാർത്ഥ AppSec അപകടസാധ്യത വെറും ചൂഷണങ്ങളെക്കുറിച്ചല്ല. നമ്മൾ പിടിക്കുന്നത് നിർത്തുന്ന ദൈനംദിന തെറ്റുകളെക്കുറിച്ചാണ്. പ്രധാനപ്പെട്ടിടത്ത് നിന്ന് ആരംഭിക്കുക: നിങ്ങളുടെ കോഡും നിങ്ങളുടെ pipeline.
