സ്ട്രിപ്പ്ചാർ ആ ഇഞ്ചക്ഷൻ ആക്രമണം തടയാതിരുന്നത് എന്തുകൊണ്ട്

നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ സ്ട്രിപ്പ്ചാർ ഉപയോക്തൃ ഇൻപുട്ട് വൃത്തിയാക്കാൻ, നിങ്ങൾ ഒറ്റയ്ക്കല്ല. പല ഡെവലപ്പർമാരും ഇത്തരത്തിലുള്ള ഇൻപുട്ട് സാനിറ്റൈസേഷൻ കുത്തിവയ്പ്പ് ശ്രമങ്ങൾ തടയുക. ഒറ്റനോട്ടത്തിൽ, ഇത് യുക്തിസഹമായി തോന്നുന്നു, അപകടകരമായ പ്രതീകങ്ങൾ നീക്കംചെയ്യുന്നു, പേലോഡ് അപ്രത്യക്ഷമാകുന്നു. എന്നിരുന്നാലും, ഈ സമീപനം ഒരു തെറ്റായ സുരക്ഷാ ബോധം നൽകുന്നു. വാസ്തവത്തിൽ, ആക്രമണകാരികൾക്ക് ലളിതമായ ഫിൽട്ടറുകൾ മറികടക്കാൻ കഴിയും സ്ട്രിപ്പ്ചാർ ഉപയോഗിച്ച് അവ്യക്തമായ പേലോഡുകൾ, എൻകോഡിംഗുകൾ, അല്ലെങ്കിൽ സമർത്ഥമായ സന്ദർഭ സ്വിച്ചിംഗ്. അതുകൊണ്ടാണ് സ്മാർട്ട് ഡെവലപ്പർമാർ അവിടെ നിർത്താത്തത്. പകരം, അവർ ഉപയോഗിക്കുന്നത് പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ, ഇത് വേരിലെ കുത്തിവയ്പ്പ് ആക്രമണങ്ങളെ തടയുന്നു.

ഈ പോസ്റ്റിൽ, എന്തുകൊണ്ടെന്ന് നിങ്ങൾ മനസ്സിലാക്കും സ്ട്രിപ്പ്ചാർ യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിൽ പരാജയപ്പെടുന്നു, ആക്രമണകാരികൾ ഈ ഫിൽട്ടറുകൾ എങ്ങനെ ദുരുപയോഗം ചെയ്യുന്നു, സുരക്ഷിതമായ ബദലുകൾ ഏതൊക്കെയാണ് യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്നത്. ഞങ്ങൾ കോഡ് ഉദാഹരണങ്ങളിലൂടെ കടന്നുപോകും, സാധാരണ ബൈപാസ് ടെക്നിക്കുകൾ കാണിക്കും, എങ്ങനെയെന്ന് വിശദീകരിക്കും ഇൻപുട്ട് സാനിറ്റൈസേഷൻ എല്ലായ്പ്പോഴും ഘടനാപരമായ സംരക്ഷണങ്ങളുമായി ജോടിയാക്കണം, ഇതുപോലുള്ളവ പാരാമീറ്ററൈസ്ഡ് ക്വറികൾഅല്ലെങ്കിൽ നിങ്ങൾ ദുർബലരായി തുടരും.

എന്ത് സ്ട്രിപ്പ്ചാർ യഥാർത്ഥത്തിൽ ചെയ്യുന്നു (കൂടാതെ ഇല്ല)

നിരവധി ഡെവലപ്പർമാർ ഉപയോഗിക്കുന്നു stripchar അല്ലെങ്കിൽ ഉപയോക്തൃ ഇൻപുട്ടിൽ നിന്ന് സുരക്ഷിതമല്ലാത്ത പ്രതീകങ്ങൾ നീക്കം ചെയ്യുന്നതിനുള്ള സമാനമായ ഫംഗ്‌ഷനുകൾ. സാധാരണയായി, ഇത് വിരാമചിഹ്നങ്ങൾ, പ്രത്യേക ചിഹ്നങ്ങൾ അല്ലെങ്കിൽ അക്ഷരമാലയില്ലാത്ത എന്തും നീക്കം ചെയ്യുന്നു. ആദ്യം, അത് ഇതുപോലെ തോന്നും ഇൻപുട്ട് സാനിറ്റൈസേഷൻ, പക്ഷേ അത് യഥാർത്ഥ സംരക്ഷണമല്ല.

നമുക്ക് അതിനെ വിശകലനം ചെയ്യാം. ഇതുപോലുള്ള ഒരു ഫംഗ്ഷൻ:

				
					function stripchar(input) {
  return input.replace(/[^\w\s]/gi, '');
}

പോലുള്ള പ്രതീകങ്ങൾ നീക്കം ചെയ്യുന്നു ', ", അഥവാ ;. അപ്പോൾ, നിങ്ങൾ നൽകിയാൽ:

				
					'; DROP TABLE users; --

അത് ഇങ്ങനെ മാറുന്നു:

				
					DROP TABLE users

ഉപയോക്തൃ ഇൻപുട്ട് വൃത്തിയായി തോന്നിയാലും, ലോജിക് മാത്രം ഉപയോഗിച്ച് ആക്രമണകാരികൾക്ക് SQL പേലോഡുകൾ കുത്തിവയ്ക്കാൻ കഴിയും, പ്രത്യേകിച്ചും ആപ്ലിക്കേഷൻ സ്ട്രിംഗ് കോൺകറ്റനേഷൻ വഴി ചോദ്യങ്ങൾ നിർമ്മിക്കുമ്പോൾ. SQL കുത്തിവയ്പ്പ് യഥാർത്ഥത്തിൽ തടയാൻ, നിങ്ങൾ പാരാമീറ്ററൈസ്ഡ് ക്വറികളും സന്ദർഭ-അവബോധമുള്ള ഇൻപുട്ട് കൈകാര്യം ചെയ്യലും ഉപയോഗിക്കണം. പ്രതീക ഫിൽട്ടറുകൾ പോലുള്ളവ stripchar() പോരാ.

തീർച്ചയായും, ഒറ്റനോട്ടത്തിൽ നീക്കം ചെയ്ത ഇൻപുട്ട് സുരക്ഷിതമായി തോന്നിയേക്കാം. എന്നിരുന്നാലും, ഈ സമീപനം ക്ഷുദ്രകരമായ യുക്തിയെ നിർവീര്യമാക്കുന്നില്ല, അത് എഴുതുന്ന രീതിയെ മാത്രമേ മാറ്റുന്നുള്ളൂ. വാസ്തവത്തിൽ, ആക്രമണകാരികൾ പലപ്പോഴും പേലോഡുകൾ എൻകോഡ് ചെയ്തും, വൈറ്റ്‌സ്‌പെയ്‌സ് ചേർത്തും, നീക്കം ചെയ്‌ത പ്രതീകങ്ങൾ തന്ത്രപരമായി ഉപയോഗിച്ചും നിങ്ങളുടെ ഫിൽട്ടർ പൂർണ്ണമായും മറികടക്കുന്നതിലൂടെ ഇത് പ്രയോജനപ്പെടുത്തുന്നു.

കൂടാതെ, സ്ട്രിപ്പ്ചാർ നിർണായക സന്ദർഭം ഇല്ല. ഇൻപുട്ട് ഒരു ഡാറ്റാബേസിലേക്കോ, ഷെല്ലിലേക്കോ, ബ്രൗസറിലേക്കോ ആണോ പോകുന്നതെന്ന് അതിന് അറിയില്ല. അതായത് ശരിയായ എസ്കേപ്പിംഗ് അല്ലെങ്കിൽ എൻകോഡിംഗ് പ്രയോഗിക്കാൻ അതിന് കഴിയില്ല. ലക്ഷ്യസ്ഥാനം അറിയാതെ ഇൻപുട്ട് സാനിറ്റൈസ് ചെയ്യുന്നത് HTML-ൽ നിന്ന് രക്ഷപ്പെടുന്നത് പോലെയാണ്, യഥാർത്ഥ ഭീഷണി SQLi.

ഒടുവിൽ, സ്ട്രിപ്പ്ചാർ ഒന്നും വ്യാഖ്യാനിക്കുകയോ സുരക്ഷിതമാക്കുകയോ ചെയ്യുന്നില്ല, അത് സ്ട്രിംഗുകൾ എഡിറ്റ് ചെയ്യുക മാത്രമാണ് ചെയ്യുന്നത്. എഡിറ്റിംഗ് സുരക്ഷയല്ല. നിങ്ങൾക്ക് യഥാർത്ഥ സംരക്ഷണം വേണമെങ്കിൽ, ഘടനാപരവും സാധുതയുള്ളതും പാരാമീറ്ററൈസ് ചെയ്തതുമായ ചോദ്യങ്ങൾ ഉപയോഗിക്കുക. പൂർണ്ണവിരാമം.

വ്യത്യാസം കൂടുതൽ വ്യക്തമാക്കുന്നതിന്, സ്ട്രിപ്പ്ചാർ പാരാമീറ്ററൈസ് ചെയ്ത അന്വേഷണങ്ങളുമായി എങ്ങനെ താരതമ്യം ചെയ്യുന്നുവെന്ന് ഇതാ:

സ്ട്രിപ്പ്ചാർ vs പാരാമീറ്ററൈസ്ഡ് ക്വറീസ്: ഏതാണ് നിങ്ങളുടെ കോഡിനെ യഥാർത്ഥത്തിൽ സംരക്ഷിക്കുന്നത്?

സവിശേഷത	`stripchar()`	പാരാമീറ്ററൈസ് ചെയ്‌ത ചോദ്യങ്ങൾ
പരിരക്ഷണ നില	അടിസ്ഥാന സ്ട്രിംഗ് ക്ലീനപ്പ്. എൻകോഡിംഗ് അല്ലെങ്കിൽ ലോജിക് തന്ത്രങ്ങൾ ഉപയോഗിച്ച് എളുപ്പത്തിൽ മറികടക്കാം.	എല്ലാത്തരം SQL കുത്തിവയ്പ്പുകൾക്കും എതിരെ ശക്തമായ സംരക്ഷണം.
സന്ദർഭ അവബോധം	സന്ദർഭത്തിന് അനുസൃതമായി (SQL, HTML, ഷെൽ, മുതലായവ). എല്ലായിടത്തും ഒരേ നിയമം പ്രയോഗിക്കുന്നു.	പൂർണ്ണമായും സന്ദർഭ അവബോധം. ഓരോ പരിതസ്ഥിതിക്കും അനുയോജ്യമായ രക്ഷപ്പെടൽ ഉപയോഗിക്കുന്നു.
ഡെവലപ്പർ ശ്രമം	വേഗത്തിൽ നടപ്പിലാക്കാൻ കഴിയും, പക്ഷേ ദീർഘകാല ഉപയോഗത്തിന് വിശ്വസനീയമല്ല.	ശരിയായ സംയോജനം ആവശ്യമാണ്, എന്നാൽ കരുത്തുറ്റതും ഭാവിക്ക് അനുയോജ്യവുമാണ്.
ബൈപാസ് പ്രതിരോധം	താഴ്ന്നത് — ആക്രമണകാരികൾ വൈറ്റ്‌സ്‌പെയ്‌സ്, എൻകോഡിംഗ് അല്ലെങ്കിൽ ലോജിക് ഉപയോഗിച്ച് എളുപ്പത്തിൽ പൊരുത്തപ്പെടുന്നു.	ഉയർന്നത് — ഡാറ്റയിൽ നിന്ന് കോഡിനെ വേർതിരിക്കുകയും ഇൻജെക്ഷൻ വിശ്വസനീയമായി തടയുകയും ചെയ്യുന്നു.
സുരക്ഷാ ആത്മവിശ്വാസം	തെറ്റായ സുരക്ഷിതത്വബോധം - പ്രശ്നം പരിഹരിക്കാതെ മറച്ചുവെച്ചേക്കാം.	വിശ്വസനീയ വ്യവസായം standard സുരക്ഷിതമായ അന്വേഷണ നിർവ്വഹണത്തിനായി.

ആക്രമണകാരികൾ ഇൻപുട്ട് സാനിറ്റൈസേഷൻ എങ്ങനെ മറികടക്കുന്നു

ഡെവലപ്പർമാർ ആശ്രയിക്കുമ്പോൾ ഒരു സാധാരണ ദുർബലമായ ഒഴുക്ക് ഇങ്ങനെയാണ് കാണപ്പെടുന്നത് സ്ട്രിപ്പ്ചാർ ഇൻപുട്ട് സാനിറ്റൈസേഷനായി:

ആക്രമണകാരികൾക്ക് നിങ്ങളുടെ ഫിൽട്ടറുകൾ തകർക്കേണ്ട ആവശ്യമില്ല, അവർക്ക് വേണ്ടത് അവരെ ചുറ്റി സഞ്ചരിക്കുക. ഡെവലപ്പർമാർ ആശ്രയിക്കുമ്പോൾ സ്ട്രിപ്പ്ചാർ ഇൻപുട്ട് സാനിറ്റൈസേഷനായി, ഉദ്ധരണികൾ അല്ലെങ്കിൽ അർദ്ധവിരാമങ്ങൾ പോലുള്ള പ്രതീകങ്ങൾ നീക്കം ചെയ്യുന്നത് കുത്തിവയ്പ്പ് ശ്രമങ്ങളെ തടയുമെന്ന് അവർ പലപ്പോഴും കരുതുന്നു. എന്നിരുന്നാലും, ആക്രമണകാരികൾ വേഗത്തിൽ പൊരുത്തപ്പെടുന്നു. അവർ അവ്യക്തമായ പേലോഡുകൾ പ്രത്യേകിച്ച് സന്ദർഭം ഇല്ലാത്ത ഫിൽട്ടറുകളിൽ, regex-അധിഷ്ഠിത ഫിൽട്ടറുകളിലൂടെ അവ വഴുതിവീഴുന്നു.

ഉദാഹരണത്തിന്, നിങ്ങൾ ഇൻപുട്ട് ഇതുപോലെ സാനിറ്റൈസ് ചെയ്യാൻ ശ്രമിക്കുന്നുവെന്ന് കരുതുക:

				
					const input = stripchar(userInput);
// safe to use? maybe not.
db.query("SELECT * FROM users WHERE name = '" + input + "'");

ഉപയോക്താവിന് ഒരു ക്ലാസിക് സമർപ്പിക്കാൻ കഴിയില്ലെങ്കിൽ പോലും ' OR 1=1 --, അവർക്ക് യൂണിക്കോഡ് തന്ത്രങ്ങൾ, സ്ട്രിംഗ് കോൺകറ്റനേഷൻ, അല്ലെങ്കിൽ ഇപ്പോഴും പ്രവർത്തിക്കുന്ന തകർന്ന വാക്യഘടന എന്നിവ ഉപയോഗിക്കാം. ഇതുപോലുള്ള പേലോഡുകൾ പലപ്പോഴും പ്രവർത്തിക്കുന്നു:

				
					0x27206F7220313D31--

അഥവാ:

				
					'+UNION+SELECT+null,null,null--

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

SQL ഇൻജെക്ഷൻ കൂടാതെ, സ്ട്രിപ്പ്ചാർ ഷെൽ കമാൻഡുകൾ, ഫയൽ പാത്തുകൾ, അല്ലെങ്കിൽ ജാവാസ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ പോലുള്ള മറ്റ് സന്ദർഭങ്ങളിലും ഇത് പരാജയപ്പെടുന്നു. ഇൻപുട്ട് എവിടെ ഉപയോഗിക്കണമെന്ന് അതിന് അവബോധമില്ലാത്തതിനാൽ, ശരിയായ എസ്കേപ്പിംഗ് അല്ലെങ്കിൽ വാലിഡേഷൻ പ്രയോഗിക്കാൻ ഇതിന് കഴിയില്ല.

തൽഫലമായി, ഇൻപുട്ട് സാനിറ്റൈസേഷൻ കൂടെ സ്ട്രിപ്പ്ചാർ മറികടക്കാൻ എളുപ്പമാണ്. യഥാർത്ഥ സുരക്ഷ വരുന്നത് സന്ദർഭ അവബോധ നിയന്ത്രണങ്ങൾ, പ്രത്യേകിച്ച് പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ അത് ലോജിക് കുത്തിവയ്പ്പിനെ പൂർണ്ണമായും തടയുന്നു.

പകരം നിങ്ങൾ പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ ഉപയോഗിക്കേണ്ടത് എന്തുകൊണ്ട്?

കുത്തിവയ്പ്പ് ആക്രമണങ്ങൾ യഥാർത്ഥത്തിൽ നിർത്തണമെങ്കിൽ, നിങ്ങൾ സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് ചോദ്യങ്ങൾ നിർമ്മിക്കുന്നത് നിർത്തുക. അവിടെയാണ് പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ അകത്തേക്ക് വരൂ. അൺലൈക്ക് ചെയ്യുക സ്ട്രിപ്പ്ചാർ, അവ ഫിൽട്ടർ ചെയ്യുന്നില്ല, അവ ഡാറ്റയിൽ നിന്ന് കോഡ് വേർതിരിക്കുക എഞ്ചിൻ തലത്തിൽ.

തകർന്ന ചോദ്യം വീണ്ടും നോക്കാം:

				
					const input = stripchar(userInput);
const query = "SELECT * FROM users WHERE name = '" + input + "'";

ഇത് അപകടകരമാണ്, കാരണം ഇൻപുട്ട് നേരിട്ട് SQL-ലേക്ക് കുത്തിവയ്ക്കപ്പെടുന്നു. പ്രതീക സ്ട്രിപ്പിംഗ് ഉപയോഗിച്ചാലും, ദുരുപയോഗം ചെയ്യപ്പെടാൻ സാധ്യതയുള്ള ഒരു സ്ട്രിംഗ് നിങ്ങൾ ഇപ്പോഴും നിർമ്മിക്കുകയാണ്. പകരം, ഇതുപോലുള്ള ഒരു പാരാമീറ്ററൈസ്ഡ് അന്വേഷണം ഉപയോഗിക്കുക:

				
					const query = "SELECT * FROM users WHERE name = ?";
db.execute(query, [userInput]);

ഇവിടെ, ഡാറ്റാബേസ് ഡ്രൈവർക്ക് അത് അറിയാം userInput ഡാറ്റയാണ്, എക്സിക്യൂട്ടബിൾ അല്ലാത്ത കോഡ്. ഇൻപുട്ടിൽ ഉദ്ധരണികൾ, അർദ്ധവിരാമങ്ങൾ, അല്ലെങ്കിൽ ഹെക്സ്-എൻകോഡ് ചെയ്ത പേലോഡുകൾ എന്നിവ അടങ്ങിയിട്ടുണ്ടെങ്കിൽപ്പോലും, അത് അതിൽ നിന്ന് യാന്ത്രികമായി രക്ഷപ്പെടുകയും ഇൻജക്ഷൻ തടയുകയും ചെയ്യുന്നു.

പൈത്തണിൽ:

				
					cursor.execute("SELECT * FROM users WHERE name = %s", (user_input,))

പി‌ഡി‌ഒ ഉള്ള പി‌എച്ച്പിയിൽ:

				
					$stmt = $pdo->prepare("SELECT * FROM users WHERE name = :name");
$stmt->execute(['name' => $input]);

ഈ ഉദാഹരണങ്ങളിലെല്ലാം, പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ ഏതൊക്കെ കഥാപാത്രങ്ങളാണ് അപകടകരമെന്ന് ഊഹിക്കാതെ തന്നെ കുത്തിവയ്പ്പ് തടയുക. നിങ്ങൾക്ക് ആവശ്യമില്ല. സ്ട്രിപ്പ്ചാർ, നിങ്ങൾക്ക് ഘടനാപരമായ, സന്ദർഭ അവബോധമുള്ള അന്വേഷണ നിർമ്മാണം ആവശ്യമാണ്.

കൂടാതെ, ഈ സാങ്കേതികത അവ്യക്തമായ പേലോഡുകൾ, യൂണിക്കോഡ് തന്ത്രങ്ങൾ, എൻകോഡിംഗ് ബൈപാസുകൾ എന്നിവ തടയുന്നു, XSS ദുർബലതകൾ. സൈജെനി പോലുള്ള ഉപകരണങ്ങൾ ഈ ഭീഷണികളെ നേരത്തേ കണ്ടെത്തുന്നു SAST വിശകലനം.

ചുരുക്കത്തിൽ, യഥാർത്ഥ പ്രതിരോധങ്ങൾ ഫിൽട്ടറുകളെ ആശ്രയിക്കുന്നില്ല. അവ പ്രോട്ടോക്കോളുകൾ, വിശ്വസനീയമായ API-കൾ, പൂർണ്ണ സന്ദർഭം എന്നിവയെ ആശ്രയിച്ചിരിക്കുന്നു. നിങ്ങൾ ഫ്രെയിംവർക്കുകളോ ഡൈനാമിക് സർവീസ് ഇഞ്ചക്ഷനോ ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ കോഡ്ബേസിലൂടെ ഇൻപുട്ടുകൾ എങ്ങനെ വ്യാപിക്കുന്നുവെന്ന് അറിഞ്ഞിരിക്കുക. സുരക്ഷിത ആശ്രിതത്വ കുത്തിവയ്പ്പ് സങ്കീർണ്ണമായ പ്രവാഹങ്ങൾ പോലും പുതിയ ആക്രമണ പ്രതലങ്ങൾ തുറക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു.

ആശ്രയിക്കരുത് സ്ട്രിപ്പ്ചാർ. യഥാർത്ഥ പ്രതിരോധങ്ങൾ നടപ്പിലാക്കാൻ സൈജെനി ഉപയോഗിക്കുക.

നിങ്ങൾ ഉപയോഗിച്ചാലും പാരാമീറ്ററൈസ്ഡ് ക്വറികൾ, നിങ്ങളുടെ മുഴുവൻ കോഡ്ബേസും ഇതേ പോലെ തന്നെ പിന്തുടരുമെന്ന് യാതൊരു ഉറപ്പുമില്ല. standard. ലെഗസി ലോജിക്, മൂന്നാം കക്ഷി സ്ക്രിപ്റ്റുകൾ, അല്ലെങ്കിൽ ഒരു പിആറിലെ അവഗണിക്കപ്പെട്ട ലൈനുകൾ എന്നിവ ഇപ്പോഴും ഇഞ്ചക്ഷൻ അപകടസാധ്യതകൾക്ക് കാരണമാകും. അവിടെയാണ് സൈജെനി സഹായിക്കുന്നത്.

Xygeni നിങ്ങളുടെ സോഴ്‌സ് കോഡ് സ്കാൻ ചെയ്യുന്നു, pull requests, കൂടാതെ സി.ഐ. pipelineപിടിക്കാൻ:

കോൺകാറ്റനേഷൻ ഉപയോഗിച്ച് SQL നിർമ്മിക്കുന്ന ക്വറി സ്ട്രിംഗുകൾ
ദുർബലമായതോ സ്വന്തമായി നിർമ്മിച്ചതോ ആയ ഫിൽട്ടറുകൾ സ്ട്രിപ്പ്ചാർ
അറിയപ്പെടുന്ന അവ്യക്തമായ പേലോഡുകളുമായി പൊരുത്തപ്പെടുന്ന സംശയാസ്പദമായ യുക്തി.

ഓരോ വരിയും നിങ്ങൾ ചീകി മറിക്കേണ്ടതില്ല. സൈജെനി സുരക്ഷിതമല്ലാത്ത പാറ്റേണുകൾ നേരത്തെ തന്നെ ഫ്ലാഗ് ചെയ്യുന്നു, ബാധകമാക്കുന്നു. ഓട്ടോഫിക്സ് സാധ്യമാകുന്നിടത്തെല്ലാം, ഇഷ്ടാനുസൃതമാക്കാവുന്ന അപകടകരമായ ലയനങ്ങളെ തടയാൻ കഴിയും Guardrails.

ചുരുക്കത്തിൽ, പാരാമീറ്ററൈസ്ഡ് ചോദ്യങ്ങൾ ഒരു മികച്ച രീതി മാത്രമല്ല, അവ സ്കെയിലിൽ നടപ്പിലാക്കുന്നുണ്ടെന്ന് സൈജെനി ഉറപ്പാക്കുന്നു. ഇനി ഊഹക്കച്ചവടമില്ല. ഫിൽട്ടറുകൾ നഷ്ടപ്പെട്ടില്ല. യഥാർത്ഥ സംരക്ഷണം മാത്രം.

നിങ്ങളുടെ കോഡിലെ സുരക്ഷിതമല്ലാത്ത ചോദ്യങ്ങൾ Xygeni എങ്ങനെ കണ്ടെത്തുന്നുവെന്ന് കാണണോ?

സൗജന്യ ട്രയൽ ആരംഭിക്കൂ! ക്രെഡിറ്റ് കാർഡ് വേണ്ട, ആദ്യ സ്കാനിൽ തന്നെ പൂർണ്ണ ദൃശ്യപരത.

സൈജെനി പരീക്ഷിച്ചു നോക്കൂ SAST സൗജന്യമായി

പ്രധാന കാര്യങ്ങൾ: എന്താണ് ഓർമ്മിക്കേണ്ടത് സ്ട്രിപ്പ്ചാർ കുത്തിവയ്പ്പിന്റെ അപകടസാധ്യതകളും

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

ഉപസംഹാരം: ഫിൽട്ടറുകളെ വിശ്വസിക്കരുത്. ഡിസൈൻ പ്രകാരം സുരക്ഷിതമാക്കുക.

പോലുള്ള പ്രവർത്തനങ്ങളെ ആശ്രയിക്കുന്നു സ്ട്രിപ്പ്ചാർ പെട്ടെന്ന് പരിഹരിക്കാവുന്ന ഒന്നായി തോന്നിയേക്കാം, പക്ഷേ അവ തെറ്റായ ഒരു സുരക്ഷാ ബോധം സൃഷ്ടിക്കുന്നു. സ്ട്രിംഗ് ഫിൽട്ടറുകളേക്കാൾ വേഗത്തിൽ ആക്രമണകാരികൾ വികസിക്കുന്നു. ഇഞ്ചക്ഷൻ ആക്രമണങ്ങൾ തടയാനുള്ള ഏക വിശ്വസനീയമായ മാർഗം ഡിസൈൻ പ്രകാരം സുരക്ഷിത കോഡ് എഴുതുകയും ആ ഡിസൈൻ എല്ലായിടത്തും നടപ്പിലാക്കുകയും ചെയ്യുക എന്നതാണ്.

Xygeni പോലുള്ള ഉപകരണങ്ങൾ അത് യാന്ത്രികമായി ചെയ്യാൻ നിങ്ങളെ സഹായിക്കുന്നു. മുതൽ pull request ലേക്ക് pipeline, നിങ്ങളുടെ ഫിൽട്ടറുകൾ ചെയ്യാത്തത് അവർ പിടിച്ചെടുക്കുകയും ഉൽപ്പാദനത്തിലേക്ക് എത്തുന്നതിനുമുമ്പ് അത് ശരിയാക്കുകയും ചെയ്യുന്നു.

സ്ട്രിപ്പ്ചാർ ആ ഇഞ്ചക്ഷൻ ആക്രമണം തടയാതിരുന്നത് എന്തുകൊണ്ട്?

നിർബന്ധമായും വായിക്കേണ്ട പോസ്റ്റുകൾ