സുരക്ഷിത കോഡ് അവലോകനവും സ്റ്റാറ്റിക് അനാലിസിസും: കൃത്രിമബുദ്ധി ഉപയോഗിച്ച് കേടുപാടുകൾ കണ്ടെത്തൽ

നേട്ടങ്ങൾ:

• ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് രണ്ടാം കണ്ണായി ഉപയോഗിക്കാനുള്ള കഴിവ്, സന്ദർഭം നൽകി കോഡിലെ OWASP ക്ലാസ് കേടുപാടുകൾ (ഇഞ്ചക്ഷൻ, ഹാർഡ് സീക്രട്ട്, ആക്‌സസ് കൺട്രോൾ) ഫ്ലാഗ് ചെയ്യുക
• ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് സൃഷ്ടിക്കുന്ന തെറ്റായ പോസിറ്റീവുകൾ സന്ദർഭം ഉപയോഗിച്ച് ഇല്ലാതാക്കാനും ഓരോ കണ്ടെത്തലിനെയും സാധൂകരിക്കാതെ ഒരു യഥാർത്ഥ അപകടസാധ്യതയായി കണക്കാക്കുന്നത് തടയാനുമുള്ള കഴിവ്
• ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് നിർദ്ദേശിച്ച പരിഹാരം പുതിയ കേടുപാടുകൾ/ബഗുകൾ അവതരിപ്പിക്കുകയും ഓരോ പാച്ചും അവലോകനത്തിലൂടെയും ടെസ്റ്റിംഗ് ഗേറ്റിലൂടെയും കടന്നുപോകുകയും ചെയ്തേക്കാം എന്ന് തിരിച്ചറിയാനുള്ള കഴിവ്

സോഫ്‌റ്റ്‌വെയറിനുള്ളിലെ കേടുപാടുകൾ ഏറ്റവും ചെലവേറിയ കേടുപാടുകളിലൊന്നാണ്, കാരണം അവ ഉൽപ്പന്നത്തിൽ തുടക്കം മുതൽ ഉൾച്ചേർക്കുകയും ദശലക്ഷക്കണക്കിന് ഉപയോക്താക്കൾക്ക് വിതരണം ചെയ്യുകയും ചെയ്യുന്നു. സെക്യുർ കോഡ് അവലോകനം എന്നത് സോഴ്‌സ് കോഡ് ലൈൻ ബൈ ലൈനായി വായിക്കുകയും കേടുപാടുകൾ പിടിക്കുകയും ചെയ്യുന്ന പ്രക്രിയയാണ് - SQL കുത്തിവയ്പ്പ്, പ്രാമാണീകരണ അപകടസാധ്യത, ഹാർഡ്-കോഡുചെയ്‌ത പാസ്‌വേഡ്, തെറ്റായ അംഗീകാരം - അവ നിർമ്മാണത്തിലേക്ക് കടക്കുന്നതിന് മുമ്പ്. കൈകൊണ്ട് ചെയ്യുമ്പോൾ, അത് മന്ദഗതിയിലുള്ളതും ക്ഷീണിപ്പിക്കുന്നതുമാണ്; ഒരു വലിയ കോഡ് ബേസിൽ ഒരു അപകടസാധ്യത നഷ്ടപ്പെടുന്നത് എളുപ്പമാണ്.

രണ്ട് കാരണങ്ങളാൽ കോഡ് അവലോകനത്തിൽ AI ശക്തമാണ്: കോഡ് ഒരു ഭാഷയാണ്, കൂടാതെ പാറ്റേൺ തിരിച്ചറിയുന്നതിൽ AI മികച്ചതാണ്. AI-ക്ക് അപകടകരമായ പാറ്റേണുകൾ ഒരു കോഡിൽ പെട്ടെന്ന് ഫ്ലാഗ് ചെയ്യാൻ കഴിയും (ഉപയോക്തൃ ഇൻപുട്ട് നേരിട്ട് അന്വേഷണത്തിലേക്ക് ഇടുക, എൻക്രിപ്റ്റ് ചെയ്യാത്ത ഡാറ്റ സംഭരണം, നഷ്ടപ്പെട്ട ഇൻപുട്ട് മൂല്യനിർണ്ണയം), ഓരോന്നും അപകടകരമാകുന്നത് എന്തുകൊണ്ടെന്ന് വിശദീകരിക്കുകയും ഒരു പരിഹാരം നിർദ്ദേശിക്കുകയും ചെയ്യുന്നു. എന്നാൽ AI കോഡിൻ്റെ മുഴുവൻ പ്രവർത്തന സന്ദർഭവും കാണുന്നില്ല (ഇൻപുട്ട് മറ്റൊരു ലെയറിൽ ക്ലിയർ ചെയ്തേക്കാം), അത് നിലവിലില്ലാത്ത (തെറ്റായ പോസിറ്റീവ്) ഒരു അപകടസാധ്യത കണ്ടുപിടിച്ചേക്കാം അല്ലെങ്കിൽ ഒരു യഥാർത്ഥ അപകടസാധ്യത (തെറ്റായ നെഗറ്റീവ്) നഷ്‌ടപ്പെടുത്തിയേക്കാം, ഏറ്റവും പ്രധാനമായി, അത് നിർദ്ദേശിക്കുന്ന "പരിഹാരം" ഒരു പുതിയ അപകടസാധ്യത അല്ലെങ്കിൽ ബഗ് അവതരിപ്പിച്ചേക്കാം. കോഡ് അവലോകനത്തിലെ രണ്ടാമത്തെ കണ്ണും പോയിൻ്ററും ആണ് AI; ഒരു കണ്ടെത്തൽ യഥാർത്ഥ അപകടമാണോ എന്നും അത് ശരിയാണോ സുരക്ഷിതമാണോ എന്നും ഡവലപ്പറും സുരക്ഷാ വിദഗ്ധരും തീരുമാനിക്കുന്നു.

കോഡ് അവലോകനത്തിൻ്റെ ഘട്ടങ്ങൾ

1. വ്യാപ്തിയും സന്ദർഭവും നൽകുക. ഏത് ഭാഷ, ഏത് ചട്ടക്കൂട്, ഈ കോഡ് എവിടെയാണ് ഇൻപുട്ട് എടുക്കുന്നത്, എവിടെ ഔട്ട്പുട്ട് നൽകുന്നു, ഏത് ലെയറിലാണ് ഇത് പ്രവർത്തിക്കുന്നത്? സന്ദർഭമില്ലാതെയുള്ള കോഡ് അവലോകനം തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ടാക്കുന്നു.
2. അപകടകരമായ പാറ്റേണുകൾക്കായി സ്കാൻ ചെയ്യുക. അറിയപ്പെടുന്ന AI ദുർബലത ക്ലാസുകൾക്കായി തിരയുക (OWASP ടോപ്പ് 10 പോലുള്ളവ): കുത്തിവയ്പ്പ്, പ്രാമാണീകരണം, സെൻസിറ്റീവ് ഡാറ്റ വെളിപ്പെടുത്തൽ, ആക്സസ് നിയന്ത്രണം.
3. ഓരോ കണ്ടെത്തലും ന്യായീകരിക്കുക. ഓരോ ഫ്ലാഗിനും: ഏത് ലൈൻ, ഏത് ദുർബലത ക്ലാസ്, അത് എങ്ങനെ ചൂഷണം ചെയ്യാം, എന്താണ് തെളിവ്. ന്യായീകരിക്കാത്ത കണ്ടെത്തൽ ഗൗരവമായി എടുക്കുന്നില്ല.
4. തെറ്റായ പോസിറ്റീവ് ഇല്ലാതാക്കുക. ഇൻപുട്ട് യഥാർത്ഥത്തിൽ മായ്‌ക്കുന്നുണ്ടോ, ആ പാത ശരിക്കും ആക്‌സസ് ചെയ്യാനാകുമോ - സന്ദർഭം ഉപയോഗിച്ച് പരിശോധിക്കുക.
5. തിരുത്തൽ പരിശോധിക്കുക. AI ശുപാർശ ചെയ്യുന്ന പാച്ച് യഥാർത്ഥത്തിൽ അപകടസാധ്യത അടയ്ക്കുന്നുവെന്നും പുതിയ കേടുപാടുകൾ/ബഗുകൾ അവതരിപ്പിക്കുന്നില്ലെന്നും പരിശോധനയിൽ വിജയിച്ചിട്ടുണ്ടെന്നും സ്ഥിരീകരിക്കുക.
6. മനുഷ്യ അംഗീകാരം. ഡെവലപ്പർ + സുരക്ഷാ വിദഗ്ധൻ കണ്ടെത്തലും പരിഹരിക്കലും അവലോകനം ചെയ്യുന്നു; അങ്ങനെയാണ് അത് കോഡ് ശേഖരത്തിൽ പ്രവേശിക്കുന്നത്.

നിബന്ധനകൾ: SAST (സ്റ്റാറ്റിക് ആപ്ലിക്കേഷൻ സെക്യൂരിറ്റി ടെസ്റ്റിംഗ് — സോഴ്സ് കോഡ് പ്രവർത്തിപ്പിക്കാതെ തന്നെ വിശകലനം ചെയ്യുന്ന സ്റ്റാറ്റിക് സെക്യൂരിറ്റി ടെസ്റ്റിംഗ്). DAST (ഡൈനാമിക് — പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനെ ബാഹ്യമായി പരിശോധിക്കുന്ന ഡൈനാമിക് ടെസ്റ്റിംഗ്). ഏറ്റവും സാധാരണമായ വെബ് ആപ്ലിക്കേഷൻ കേടുപാടുകളുടെ സ്റ്റാൻഡേർഡ് ലിസ്റ്റാണ് OWASP ടോപ്പ് 10. ഇൻജക്ഷൻ എന്നത് ഉപയോക്തൃ ഇൻപുട്ടിനെ ഒരു കമാൻഡ്/ക്വറി (ഉദാ. SQL കുത്തിവയ്പ്പ്) ആയി വ്യാഖ്യാനിക്കുന്നതിലൂടെ ഉണ്ടാകുന്ന ഒരു അപകടസാധ്യതയാണ്. കോഡിൽ നിന്ന് ഇൻപുട്ടിനെ വേർതിരിച്ചുകൊണ്ട് കുത്തിവയ്പ്പ് തടയുന്ന ശരിയായ രീതിയാണ് പാരാമീറ്ററൈസ്ഡ് ചോദ്യം.

പൊതുവായ ദുർബലത ക്ലാസുകളുടെ പട്ടിക

ദുർബലത ക്ലാസ്

ലക്ഷണം (കോഡിൽ)

ശരിയായ പരിഹാരം

AI യുടെ കെണി

SQL കുത്തിവയ്പ്പ്

അന്വേഷണത്തിലേക്ക് ഇൻപുട്ടിൽ ചേരുന്നു

പാരാമീറ്റർ ചെയ്‌ത ചോദ്യം

സാനിറ്റൈസേഷൻ അവഗണിക്കാം

ഹാർഡ് കോഡ് രഹസ്യം

കോഡിലെ പാസ്‌വേഡ്/കീ

സീക്രട്ട് സേഫ് (വോൾട്ട്), എൻവി

തെറ്റായ പോസിറ്റീവ് (സാമ്പിൾ/ടെസ്റ്റ്)

ദുർബലമായ ആധികാരികത

നിയന്ത്രണം/തെറ്റായ നിയന്ത്രണം

ശക്തമായ, കേന്ദ്രീകൃത നിയന്ത്രണം

സന്ദർഭം നഷ്ടപ്പെടുന്നു

തെറ്റായ ആക്സസ് നിയന്ത്രണം

അംഗീകാര പരിശോധനയില്ല

സെർവർ സൈഡ് അംഗീകാരം

സങ്കീർണ്ണമായ ഒഴുക്ക് മനസ്സിലാകുന്നില്ല

സെൻസിറ്റീവ് ഡാറ്റ വെളിപ്പെടുത്തൽ

പാസ്‌വേഡ് രഹിത സംഭരണം/ലോഗിംഗ്

എൻക്രിപ്ഷൻ, മാസ്കിംഗ്

വിമർശനം അറിയാൻ കഴിയില്ല

സുരക്ഷിതമല്ലാത്ത സീരിയലൈസേഷൻ

വിശ്വസനീയമല്ലാത്ത ഡാറ്റ ഡീസീരിയലൈസ് ചെയ്യുക

സുരക്ഷിത പാഴ്‌സിംഗ്

അപൂർവ പാറ്റേൺ നഷ്ടപ്പെടുന്നു

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - യഥാർത്ഥ കുത്തിവയ്പ്പ് പിടിക്കുന്നു. ഒരു ഡെവലപ്പർക്ക് AI ഒരു ഡാറ്റ ആക്സസ് ഫംഗ്ഷൻ പരിശോധിക്കുന്നു. ഉപയോക്താവിൽ നിന്നുള്ള userId മൂല്യം നേരിട്ട് SQL ടെക്‌സ്‌റ്റിലേക്ക് സംയോജിപ്പിച്ചിരിക്കുന്ന വരിയെ AI അടയാളപ്പെടുത്തുകയും "ഇത് ക്ലാസിക് SQL ഇഞ്ചക്ഷൻ ആണ്, ഇതിനെ ഒരു പാരാമീറ്ററൈസ്ഡ് അന്വേഷണമാക്കി മാറ്റുക" എന്ന് പറയുകയും ചെയ്യുന്നു; സാമ്പിൾ തിരുത്തൽ നൽകുന്നു. ഇൻപുട്ട് മറ്റെവിടെയെങ്കിലും അണുവിമുക്തമാക്കിയിട്ടില്ലെന്ന് ഡവലപ്പർ സ്ഥിരീകരിക്കുന്നു, ഇത് ഒരു യഥാർത്ഥ അപകടസാധ്യതയാണെന്ന് പരിശോധിച്ചുറപ്പിക്കുന്നു, നിർദ്ദേശിച്ച പാരാമീറ്ററൈസ്ഡ് ചോദ്യം നടപ്പിലാക്കുന്നു, കൂടാതെ ഒരു ടെസ്റ്റ് എഴുതുന്നു. AI അപകടസാധ്യത ഉയർത്തിക്കാട്ടി; പരിശോധനയും തിരുത്തൽ പരിശോധനയും ഡെവലപ്പറിൽ നിന്നാണ് വന്നത്.

കേസ് 2 - തെറ്റായ പോസിറ്റീവ് സ്ഥിര രഹസ്യം. AI ഒരു ഫയലിൽ പാസ്‌വേഡ് = "test1234" ലൈൻ കാണുകയും "നിർണ്ണായകമായ: ഹാർഡ്‌കോഡഡ് പാസ്‌വേഡ്" എന്ന് പറയുകയും ചെയ്യുന്നു. ഡെവലപ്പർ സന്ദർഭം പരിശോധിക്കുന്നു: ഇതൊരു യൂണിറ്റ് ടെസ്റ്റ് ഫയലാണ്, ഒരു ഡമ്മി ടെസ്റ്റ് ഡാറ്റയാണ്, പ്രൊഡക്ഷനിലേക്ക് റിലീസ് ചെയ്യാത്തതും യഥാർത്ഥ സിസ്റ്റത്തിലേക്ക് പോർട്ട് ചെയ്തിട്ടില്ലാത്തതുമാണ്. കണ്ടെത്തൽ തെറ്റായ പോസിറ്റീവ് ആണ്. ഡെവലപ്പർ ഇത് രേഖപ്പെടുത്തുന്നു, പക്ഷേ ഇത് ഒരു യഥാർത്ഥ രഹസ്യമല്ലാത്തതിനാൽ നടപടിയെടുക്കുന്നില്ല. പാഠം: AI-യുടെ "കാഠിന്യമുള്ള രഹസ്യം" അടയാളം സന്ദർഭത്തിനനുസരിച്ച് ഇല്ലാതാക്കണം; എല്ലാ ചരടുകളും ഒരു രഹസ്യമല്ല.

കേസ് 3 - പുതിയ കേടുപാടുകൾ പരിഹരിക്കുക. ഒരു XSS (ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ്) കേടുപാടുകൾ പരിഹരിക്കാൻ AI നിർദ്ദേശിക്കുന്നു; എന്നാൽ അദ്ദേഹം നിർദ്ദേശിക്കുന്ന കോഡ് തെറ്റായ സ്ഥലത്ത് ഇൻപുട്ട് മായ്‌ക്കുകയും മറ്റൊരു ഏരിയയിലെ ഔട്ട്‌പുട്ട് എൻകോഡിംഗ് ഒഴിവാക്കുകയും ചെയ്യുന്നു; തൽഫലമായി, വിടവ് പൂർണ്ണമായും അടയ്ക്കുന്നില്ല. സുരക്ഷാ വിദഗ്‌ദ്ധൻ ഫിക്സ് ചെയ്‌തത് അവലോകനം ചെയ്യുകയും കോഡിംഗ് നഷ്‌ടപ്പെട്ടതായി ശ്രദ്ധിക്കുകയും ശരിയായ ലെയറിൽ അത് ശരിയാക്കുകയും ചെയ്യുന്നു. പാഠം: AI ശുപാർശ ചെയ്യുന്ന പാച്ച് സ്വയമേവ സുരക്ഷിതമല്ല; എല്ലാ പരിഹാരങ്ങളും അവലോകനം ചെയ്യുകയും പരീക്ഷിക്കുകയും ചെയ്യുന്നു.

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായ പ്രോംപ്റ്റ്:

ഈ കോഡിൽ എന്തെങ്കിലും പഴുതുണ്ടോ, അത് പരിഹരിക്കുക: [കോഡ്]

ഈ നിർദ്ദേശം സന്ദർഭമൊന്നും നൽകുന്നില്ല (ഭാഷ, ചട്ടക്കൂട്, ഇൻപുട്ട് ഉറവിടം), ന്യായീകരണം ആവശ്യപ്പെടുന്നില്ല, തെറ്റായ പോസിറ്റീവ് ചോദ്യം ചെയ്യുന്നില്ല, കൂടാതെ AI നൽകുന്ന തിരുത്തൽ അന്ധമായി അംഗീകരിക്കാൻ തുറന്നിരിക്കുന്നു. AI യഥാർത്ഥ അപകടസാധ്യതയുടെയും നിലവിലില്ലാത്തതിൻ്റെയും സമ്മിശ്ര അടയാളങ്ങൾ.

ശക്തമായ നിർദ്ദേശം:

നിങ്ങളുടെ റോൾ: സുരക്ഷിതമായ കോഡ് അവലോകനത്തിൽ ഡെവലപ്പറുടെ രണ്ടാമത്തെ കണ്ണായ അസിസ്റ്റൻ്റ്. തീരുമാനമെടുക്കൽ; നേരിട്ട് പ്രയോഗിച്ച പരിഹാരം പരിഗണിക്കുക. കോഡ്: [ഭാഷ/ചട്ടക്കൂട് വ്യക്തമാക്കുക]. സന്ദർഭം: ഈ പ്രവർത്തനം [ഇൻപുട്ട് ഉറവിടം: ഉദാ. [ബാഹ്യ HTTP അഭ്യർത്ഥന] സ്വീകരിക്കുന്നു, [ഔട്ട്പുട്ട് ഡെസ്റ്റിനേഷൻ] എന്നതിലേക്ക് എഴുതുന്നു. നിങ്ങളുടെ ടാസ്‌ക്: (1) OWASP ക്ലാസ് ഉപയോഗിച്ച് സാധ്യമായ കേടുപാടുകൾ ഫ്ലാഗ് ചെയ്യുക, ലൈൻ നമ്പർ നൽകുക + എന്തിനാണ് അപകടസാധ്യത + എങ്ങനെ ചൂഷണം ചെയ്യാം + ഓരോന്നിനും തെളിവുകൾ നൽകുക, (2) ഓരോ കണ്ടെത്തലിനും കുറഞ്ഞത് 1 തെറ്റായ പോസിറ്റീവ് സാഹചര്യമെങ്കിലും എഴുതുക (ഉദാ. ഇൻപുട്ട് മറ്റൊരു ലെയറിൽ സാനിറ്റൈസ് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ), (3) ഒരു പരിഹാരം നിർദ്ദേശിക്കുക എന്നാൽ "[അവലോകനം + എഴുതുക]" അടയാളം; പരിഹരിക്കൽ പുതിയ കേടുപാടുകൾ/ബഗുകൾ അവതരിപ്പിക്കുന്നുണ്ടോ എന്നും വിലയിരുത്തുക. ഒരു വ്യാജ ദുർബലത ചേർക്കുന്നു.[code]

ശക്തമായ പ്രോംപ്റ്റ് സന്ദർഭം നൽകുന്നു, OWASP ക്ലാസും തെളിവുകളും ചോദിക്കുന്നു, തെറ്റായ പോസിറ്റീവും പരിഹാരത്തിൻ്റെ അപകടസാധ്യതകളും ചോദ്യം ചെയ്യുന്നു, മനുഷ്യ അവലോകനത്തെ പ്രേരിപ്പിക്കുന്നു.

പകർത്താവുന്ന പ്രോംപ്റ്റ് ടെംപ്ലേറ്റുകൾ

വൾനറബിലിറ്റി സ്കാൻ ടെംപ്ലേറ്റ് OWASP ടോപ്പ് 10-നുള്ള [ഭാഷ/ചട്ടക്കൂട്] കോഡ് പരിശോധിക്കുക. സാധ്യമായ ഓരോ കണ്ടെത്തലിനും: ലൈൻ നമ്പർ, ദുർബലത ക്ലാസ്, എന്തുകൊണ്ട് ഇത് അപകടകരമാണ്, സാമ്പിൾ ചൂഷണം, തെളിവുകളുടെ ശക്തി (ചിലത്/സാധ്യത/ദുർബലമായത്). സന്ദർഭം: ഇൻപുട്ട് [ഉറവിടം], ഔട്ട്പുട്ട് [ലക്ഷ്യം]. കെട്ടിച്ചമച്ച കണ്ടെത്തലുകൾ കൂട്ടിച്ചേർക്കുന്നു; നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ, "[പരിശോധിച്ചിരിക്കണം]" എന്ന് ടൈപ്പ് ചെയ്യുക. കോഡ്: [ഒട്ടിക്കുക]

തെറ്റായ പോസിറ്റീവ് എലിമിനേഷൻ പാറ്റേൺ ഇനിപ്പറയുന്ന കോഡ് കണ്ടെത്തലിനായി, യഥാർത്ഥ അപകടസാധ്യതയില്ലാത്ത സാഹചര്യങ്ങൾ ലിസ്റ്റ് ചെയ്യുക: ഇൻപുട്ട് മറ്റൊരു ലെയറിൽ ക്ലിയർ ചെയ്യാൻ കഴിയുമോ, ഈ പാത്ത് ആക്സസ് ചെയ്യാനാകുമോ, ഈ മൂല്യം ഒരു ടെസ്റ്റ്/സാമ്പിൾ ആണോ, ചട്ടക്കൂട് യാന്ത്രികമായി പരിരക്ഷിക്കപ്പെടുന്നു. ഓരോന്നിനും എങ്ങനെ സ്ഥിരീകരിക്കാമെന്ന് എഴുതുക. കണ്ടെത്തൽ: [ഒട്ടിക്കുക]

FIX Evaluation TEMPLATER ഇനിപ്പറയുന്ന അപകടസാധ്യതകൾ പരിഹരിക്കാൻ ശുപാർശ ചെയ്യുന്നു; തുടർന്ന് നിങ്ങളുടെ സ്വന്തം പരിഹാരം വിമർശിക്കുക: (1) ഇത് ശരിക്കും അപകടസാധ്യത അടയ്ക്കുന്നുണ്ടോ, (2) ഇത് ഒരു പുതിയ അപകടസാധ്യത/ബഗ് അവതരിപ്പിക്കുന്നുണ്ടോ, (3) ഞാൻ എന്ത് ടെസ്റ്റ് എഴുതണം (പോസിറ്റീവ്, നെഗറ്റീവ് കേസ്), (4) പ്രകടനം/പ്രവർത്തനപരമായ സ്വാധീനം. ഞാൻ തിരുത്തൽ അവലോകനം ചെയ്യുകയും പരിശോധിക്കുകയും ചെയ്യും. ദുർബലത + കോഡ്: [ഒട്ടിക്കുക]

ദുർബലത ക്ലാസിനായുള്ള സുരക്ഷിത പാറ്റേൺ ടീച്ചിംഗ് ടെംപ്ലേറ്റ് [ഉദാ. SQL ഇൻജക്ഷൻ] ഈ ഭാഷയിൽ/ചട്ടക്കൂടിൽ സുരക്ഷിതമായ ടൈപ്പിംഗ് പാറ്റേണും സാധാരണ തെറ്റായ പാറ്റേണുകളും താരതമ്യേന കാണിക്കുന്നു. പൊതുവായ നിയമം + കോഡ് ഉദാഹരണം നൽകുക; എന്നാൽ എൻ്റെ കോഡിൽ അത് നടപ്പിലാക്കുന്നതിന് മുമ്പ് നിങ്ങൾ സന്ദർഭം ചോദിക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു. ഭാഷ/ചട്ടക്കൂട്: [എഴുതുക]

സാധാരണ തെറ്റുകൾ

• സന്ദർഭമില്ലാതെ അവലോകനം ചെയ്യുക. ഭാഷ, ചട്ടക്കൂട്, ഇൻപുട്ട്/ഔട്ട്പുട്ട് സന്ദർഭം എന്നിവയില്ലാതെ, AI യഥാർത്ഥവും വ്യാജവുമായ കണ്ടെത്തലുകളെ ആശയക്കുഴപ്പത്തിലാക്കുന്നു; സന്ദർഭം നൽകുന്നത് ഉറപ്പാക്കുക.
• എല്ലാ അടയാളങ്ങളും യഥാർത്ഥ ബലഹീനതയായി തെറ്റിദ്ധരിക്കുന്നു. AI തെറ്റായ പോസിറ്റീവുകൾ ഉണ്ടാക്കുന്നു (ടെസ്റ്റ് ഡാറ്റ, ഇൻപുട്ട് മറ്റൊരു ലെയറിൽ വൃത്തിയാക്കി); ഓരോ കണ്ടെത്തലും സന്ദർഭത്തിനനുസരിച്ച് വേർതിരിക്കുക.
• AI-യുടെ തിരുത്തൽ അന്ധമായി പ്രയോഗിക്കുന്നു. ശുപാർശ ചെയ്യുന്ന പാച്ച് പുതിയ കേടുപാടുകൾ/ബഗുകൾ അവതരിപ്പിച്ചേക്കാം; പരീക്ഷകൾ അവലോകനം ചെയ്ത് എഴുതുക.
• തെറ്റായ നെഗറ്റീവ് വിശ്വസിക്കുന്നു. AI പറഞ്ഞാൽ പോലും "പരാധീനതകൾ ഇല്ല", നിർണായക പാതകൾ സ്വയം പരിശോധിക്കുക; സ്റ്റാറ്റിക് സ്കാനിംഗ് എല്ലാ അപകടസാധ്യതകളും കണ്ടെത്തുന്നില്ല.
• ബാഹ്യ ഉപകരണത്തിന് കോഡ്/രഹസ്യം നൽകുന്നു. സ്വകാര്യ കോഡും യഥാർത്ഥ രഹസ്യങ്ങളും (കീ, പാസ്‌വേഡ്) ബൗദ്ധിക സ്വത്തും ദുർബലതയുമാണ്; അജ്ഞാതമാക്കുക അല്ലെങ്കിൽ കോർപ്പറേറ്റ്, ഒറ്റപ്പെട്ട ഉപകരണങ്ങൾ ഉപയോഗിക്കുക.

നുറുങ്ങ്: AI റിവ്യൂ കോഡ് ഉള്ളപ്പോൾ, ഏറ്റവും കാര്യക്ഷമമായ ഫിൽട്ടർ ഓരോ കണ്ടെത്തലിനും "തെളിവുകളുടെ ശക്തി" (ചിലത്/സാധ്യത/ദുർബലമായത്) ആവശ്യപ്പെടുക എന്നതാണ്. "ദുർബലമായത്" എന്ന് അടയാളപ്പെടുത്തിയ മിക്ക കണ്ടെത്തലുകളും തെറ്റായ പോസിറ്റീവ് ആണ്; നിങ്ങളുടെ ഊർജം "ഉറപ്പുള്ളവർ"ക്കായി നീക്കിവയ്ക്കുന്നു.

മുൻകരുതൽ: AI-യുടെ നിർദ്ദിഷ്ട സുരക്ഷാ ഫിക്സ് പരീക്ഷിക്കാതെ വെയർഹൗസിൽ പ്രവേശിക്കരുത്. ഒരു തെറ്റായ "പരിഹാരം" രണ്ടും അപകടസാധ്യത തുറന്നിടുകയും ഉൽപ്പാദനത്തിൽ ഒരു പ്രവർത്തനപരമായ പിശകിലേക്ക് നയിക്കുകയും ചെയ്യും; ഓരോ പാച്ചും അവലോകനത്തിലൂടെയും ടെസ്റ്റിംഗ് ഗേറ്റിലൂടെയും കടന്നുപോകുന്നു.

ചുരുക്കത്തിൽ

നിർമ്മാണത്തിലേക്ക് കടക്കുന്നതിന് മുമ്പ് കേടുപാടുകൾ കണ്ടെത്തുന്നതിനുള്ള ഏറ്റവും വിലകുറഞ്ഞ മാർഗമാണ് സുരക്ഷിത കോഡ് അവലോകനം, കോഡ് ഒരു ഭാഷയായതിനാൽ, AI ഇവിടെ ശക്തമായ രണ്ടാമത്തെ കണ്ണായി മാറുന്നു: അപകടകരമായ പാറ്റേണുകൾ ഫ്ലാഗ് ചെയ്യുന്നു, അപകടസാധ്യത വിശദീകരിക്കുന്നു, പരിഹാരങ്ങൾ നിർദ്ദേശിക്കുന്നു. എന്നാൽ AI മുഴുവൻ പ്രവർത്തന സന്ദർഭവും കാണുന്നില്ല, തെറ്റായ പോസിറ്റീവുകളും തെറ്റായ നെഗറ്റീവുകളും സൃഷ്ടിക്കുന്നു, കൂടാതെ അത് ശുപാർശ ചെയ്യുന്ന പാച്ച് പുതിയ കേടുപാടുകൾ അവതരിപ്പിച്ചേക്കാം. അതിനാൽ അവലോകനത്തിന് ആറ് ഘട്ടങ്ങളുണ്ട് (സന്ദർഭം, സ്ക്രീനിംഗ്, ന്യായീകരണം, തെറ്റായ പോസിറ്റീവ് ഒഴിവാക്കൽ, ഫിക്സ് വെരിഫിക്കേഷൻ, ഹ്യൂമൻ അപ്രൂവൽ) കൂടാതെ തീരുമാനം ഡെവലപ്പറുടെയും സുരക്ഷാ വിദഗ്ധൻ്റെയും പക്കലാണ്. മൂന്ന് തത്ത്വങ്ങൾ: സന്ദർഭമില്ലാതെ ഒരു കണ്ടെത്തലും വ്യാഖ്യാനിക്കപ്പെടുന്നില്ല, എല്ലാ അടയാളങ്ങളും സന്ദർഭം ഉപയോഗിച്ച് ഇല്ലാതാക്കുന്നു, ഒരു പരിഹാരവും പരിശോധിക്കപ്പെടാത്ത സംഭരണത്തിലേക്ക് പോകില്ല. കൂടാതെ കോഡ്/രഹസ്യം ഒരിക്കലും അജ്ഞാതമാക്കാതെ ഒരു ബാഹ്യ ഉപകരണത്തിന് നൽകില്ല.

ആപ്ലിക്കേഷൻ ടാസ്ക്

ഒരു സാമ്പിൾ കോഡ് സ്‌നിപ്പറ്റ് എടുക്കുക (ഒന്നുകിൽ നിങ്ങളുടെ സ്വന്തം കോഡിൽ നിന്ന് സെൻസിറ്റീവ് ഭാഗങ്ങൾ നീക്കം ചെയ്യുക അല്ലെങ്കിൽ കേടുപാടുകൾ ഉള്ള സാമ്പിൾ കോഡ്). "വൾനറബിലിറ്റി സ്കാനിംഗ്" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI അത് പരിശോധിക്കട്ടെ; ഓരോ കണ്ടെത്തലിനും "ഫാൾസ് പോസിറ്റീവ് എലിമിനേഷൻ" ടെംപ്ലേറ്റ് പ്രയോഗിച്ച് യഥാർത്ഥമായവ ഇല്ലാതാക്കുക. "റെമഡിയേഷൻ ഇവാലുവേഷൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഏറ്റവും ഗുരുതരമായ കണ്ടെത്തലിൻ്റെ തിരുത്തൽ എടുക്കുക, അത് സ്വയം അവലോകനം ചെയ്ത് ഒരു പോസിറ്റീവ് + ഒരു നെഗറ്റീവ് ടെസ്റ്റ് കേസ് എഴുതുക. എത്ര കണ്ടെത്തലുകൾ തെറ്റായ പോസിറ്റീവ് ആണെന്ന് ശ്രദ്ധിക്കുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] കോഡ് അവലോകനം ചെയ്യുന്നതിന് മുമ്പ് ഞാൻ ഭാഷയും ചട്ടക്കൂടും ഇൻപുട്ട്/ഔട്ട്പുട്ട് സന്ദർഭവും നൽകി.
• [ ] ഓരോ കണ്ടെത്തലിനും ഞാൻ ലൈൻ നമ്പർ, വൾനറബിലിറ്റി ക്ലാസ്, എക്സ്പ്ലോയിറ്റ് പാത്ത്, തെളിവുകൾ എന്നിവ ആവശ്യപ്പെട്ടു.
• [ ] ഞാൻ ഓരോ കണ്ടെത്തലും സന്ദർഭത്തിനൊത്ത് തെറ്റായ പോസിറ്റീവുകൾക്കായി പരിശോധിച്ചു.
• [ ] ഞാൻ AI യുടെ തിരുത്തൽ അന്ധമായി പ്രയോഗിച്ചില്ല; ഞാൻ പരിശോധിച്ച് ഒരു പരീക്ഷ എഴുതി.
• [ ] "കുഴപ്പങ്ങളൊന്നുമില്ല" എന്ന ഔട്ട്‌പുട്ട് ഉണ്ടായിരുന്നിട്ടും, ഞാൻ തന്നെ നിർണായക പാതകൾ പരിശോധിച്ചു.
• [ ] ഞാൻ കോഡ്/രഹസ്യങ്ങൾ അജ്ഞാതമാക്കി അല്ലെങ്കിൽ കോർപ്പറേറ്റ് ഒറ്റപ്പെട്ട ടൂളിംഗ് ഉപയോഗിച്ചു.
• [ ] ഡെവലപ്പർ + സുരക്ഷാ അംഗീകാരം വഴി ഞാൻ കണ്ടെത്തലും പരിഹരിക്കലും പാസ്സാക്കി.