Theory
હુમલાખોરો જે નબળાઈઓનો લાભ લે છે
હુમલાખોરો કંઈ જાદુથી અંદર ઘૂસતા નથી; એ vulnerabilities નો, એટલે કે system ની નબળાઈઓનો, લાભ ઉઠાવે છે. સામાન્ય નબળાઈઓ જાણવી એ જ બચાવ કરનારાઓ માટે એમને હુમલાખોરો શોધે એ પહેલાં પૂરી દેવાનો રસ્તો છે.
આ પાઠ વારંવાર જોવા મળતી નબળાઈઓ આવરી લે છે: injection attacks, અસલામત security settings, સંવેદનશીલ માહિતીનું ખુલ્લા પડવું અને તૂટેલું authentication. એમાંની કેટલીક તમે અગાઉ જોઈ ચૂક્યા છો (databases અને PHP માં SQL injection; full-stack development માં authentication); અહીં એમને security ની નબળાઈઓ તરીકે મૂકી છે. દરેક એવો ખાડો છે જે હુમલાખોર શોધે છે, અને દરેકને પૂરી દેતો બચાવ પણ છે.
At a glance
| Vulnerability | નબળાઈ | બચાવ |
|---|---|---|
| Injection attacks | નુકસાનકારક input command તરીકે ચાલી જાય (દા.ત. SQL injection) | Input ની ચકાસણી કરો; parameterised queries વાપરો |
| અસલામત security settings | ખોટી ગોઠવણ, નબળાં મૂળ મૂલ્યો, બંધ કરેલાં રક્ષણો | સલામત ગોઠવણ; settings ની નિયમિત ચકાસણી |
| સંવેદનશીલ માહિતીનું ખુલ્લા પડવું | Data encrypt કર્યા વગરનો કે ઢીલા રક્ષણ વાળો, એટલે એ લીક થાય | Data encrypt કરો; પ્રવેશ મર્યાદિત રાખો |
| તૂટેલું authentication | નબળું login હુમલાખોરોને એને ટાળવા કે પચાવી પાડવા દે | મજબૂત authentication; સલામત sessions |
Theory
Injection અને અસલામત settings
Injection attack એવા system માં નુકસાનકારક input સરકાવી દે છે જે એને ભૂલથી command ગણી લે છે. એનો જાણીતો દાખલો છે SQL injection: form માં ખાસ ઘડેલું લખાણ ટાઇપ કરવું જેથી database હુમલાખોરનું SQL ચલાવે. એનો બચાવ, એટલે કે parameterised queries અને input ની ચકાસણી, તમે databases તથા PHP માં શીખી ચૂક્યા છો; અહીં એને vulnerability ના એક વર્ગ તરીકે નામ અપાયું છે.
અસલામત security settings (ખોટી ગોઠવણ) એ વધુ ચૂપચાપ રહેતું જોખમ છે: મૂળ મુકાયેલા નબળા passwords બદલ્યા વગર રહી જવા, બિનજરૂરી સેવાઓ ચાલુ રહેવી, રક્ષણો બંધ કરી દેવાં, કે પરવાનગીઓ બહુ ઢીલી રાખવી. હુમલાખોરો આવી ખોટી ગોઠવણો ખાસ શોધે છે, કારણ કે એ સામાન્ય પણ છે અને એનો લાભ લેવો સહેલો પણ. એનો બચાવ છે ધ્યાનપૂર્વકની સલામત ગોઠવણ અને નિયમિત ચકાસણી, એટલે કે બારણાં ખુલ્લાં ન છોડવાં.
Theory
માહિતીનું ખુલ્લા પડવું અને તૂટેલું authentication
સંવેદનશીલ માહિતીનું ખુલ્લા પડવું ત્યારે થાય છે જ્યારે data નું બરાબર રક્ષણ થતું નથી, એટલે કે એ encryption વગર સંઘરાય કે મોકલાય, અથવા જેમણે જોવો ન જોઈએ એમની પહોંચમાં હોય, અને એટલે એ લીક થાય છે (કોઈ breach માં, કે જે જુએ એ દરેકને). એનો બચાવ છે સંવેદનશીલ data ને encrypt કરવો (મુસાફરીમાં SSL થી, અને સંગ્રહમાં પણ) તથા એની પહોંચ મર્યાદિત રાખવી.
તૂટેલું (કે ભંગાયેલું) authentication એટલે login ની રીત એટલી નબળી હોવી કે હુમલાખોરો એને ટાળી શકે કે પચાવી પાડી શકે, જે નબળા passwords, ઢીલા session ના સંચાલન કે ખામીભરી login ની તર્કરચનાથી થાય છે, અને એ એમને વપરાશકારનો ડોળ કરવા દે છે. એનો બચાવ છે મજબૂત authentication (સારા passwords, two-factor) અને સલામત session નું સંચાલન. આ ચારેય નબળાઈઓ, એટલે કે injection, ખોટી ગોઠવણ, માહિતીનું ખુલ્લા પડવું અને તૂટેલું authentication, સૌથી વધુ વપરાતી નબળાઈઓમાં આવે છે, અને એટલે જ એમને પૂરી દેવી એ security ની અગ્રતા છે.
Quiz
કોઈ હુમલાખોર login form માં ખાસ ઘડેલું input ટાઇપ કરે છે જેથી database એનો પોતાનો SQL command ચલાવે. આ કઈ vulnerability છે, અને એ કઈ રીતે અટકાવાય?
- તૂટેલું authentication; વધુ ઝડપી servers એને અટકાવે
- Injection attack (SQL injection); input ની ચકાસણી કરીને અને parameterised queries વાપરીને એ અટકાવાય
- માહિતીનું ખુલ્લા પડવું; DDoS filter એને અટકાવે
- અસલામત settings; ફક્ત encryption થી એ અટકાવાય
Show the answer
Injection attack (SQL injection); input ની ચકાસણી કરીને અને parameterised queries વાપરીને એ અટકાવાય
એવો નુકસાનકારક input સરકાવવો જેને database ભૂલથી command તરીકે ચલાવે, એ injection attack છે, ખાસ કરીને SQL injection, અને એ input ની ચકાસણી કરીને તથા, જે સૌથી અગત્યનું છે, parameterised queries વાપરીને અટકાવાય છે (એ વપરાશકારના input ને હંમેશા data જ રાખે છે, કદી ચાલી શકે એવો SQL બનવા દેતી નથી). વિકલ્પ A નામ ખોટું આપે છે: તૂટેલું authentication નબળી login પદ્ધતિની વાત છે, અને server ની ઝડપને injection સાથે કશો સંબંધ નથી. વિકલ્પ C એને માહિતીનું ખુલ્લા પડવું કહે છે (જે રક્ષણ વગરના data ના લીક થવાની વાત છે) અને સંબંધ વગરનો બચાવ સૂચવે છે (DDoS filter). વિકલ્પ D એને અસલામત settings કહે છે અને અધૂરો બચાવ આપે છે; સારી ગોઠવણ સામાન્ય રીતે મદદ કરે છે ખરી, પણ injection નો ચોક્કસ ઉપાય તો input ની ચકાસણી અને parameterised queries જ છે. SQL injection ને ઓળખો અને parameterised queries થી બચાવ કરો, બરાબર એ જ રીતે જે તમે databases માં શીખ્યા હતા.
Think first
આ જ નબળાઈઓ આટલી બધી systems માં વારંવાર કેમ દેખાયા કરે છે?
Injection અને તૂટેલું authentication વર્ષોથી જાણીતાં છે. તો પણ એ હજી આટલાં સામાન્ય કેમ છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે એ કોઈ વિચિત્ર ખામીઓમાંથી નહીં પણ software કઈ રીતે બનાવાય અને ગોઠવાય છે એમાં વારંવાર થતી ભૂલો માંથી જન્મે છે; અને જ્યાં સુધી developers તથા administrators એ ભૂલો કરતા રહેશે (ઘણી વાર દબાણ હેઠળ, કે security ની તાલીમ વગર), ત્યાં સુધી એ જ નબળાઈઓ એક પછી એક system માં પાછી દેખાયા કરશે.
Injection નો વિચાર કરો: એ ત્યારે થાય છે જ્યારે code કોઈ command (જેમ કે database query) બનાવતી વખતે વપરાશકારનો input ભેળવી દે છે અને data ને સૂચનાઓથી બરાબર જુદો પાડતો નથી. Strings ને જોડી દેવાની આ ટૂંકી કેડી સહેલી અને લોભામણી છે, કારણ કે એ ચાલે છે અને testing માં બરાબર દેખાય છે, એટલે developers એ કરી નાખે છે, ખાસ કરીને જો એમને કદી શીખવાયું જ ન હોય કે એ કેમ ખતરનાક છે, અથવા એ ઉતાવળે release કરવા મથતા હોય. સાચી ટેવ (parameterised queries, input ની ચકાસણી) જાણીતી છે, પણ એ દરેક વખતે પાળવી પડે, અને એક જગ્યાએ ભુલાય એટલું બસ છે.
તૂટેલું authentication પણ એ જ રીતે સામાન્ય ટૂંકી કેડીઓમાંથી આવે છે: નબળા password ના નિયમો, ખામીવાળો code ફરી વાપરવો, ઢીલું session નું સંચાલન, two-factor છોડી દેવું; આ દરેક કોઈ ગૂઢ bug નહીં પણ ચૂક છે.
અસલામત settings કદાચ સૌથી વધુ માણસને લગતી બાબત છે: મૂળ મુકાયેલા passwords બદલ્યા વગર રહી જવા, રક્ષણો 'હાલ પૂરતાં' બંધ કરી દેવાં, સમય બચાવવા પરવાનગીઓ બહુ ઢીલી રાખવી. ખોટી ગોઠવણ એટલા માટે જ ફેલાયેલી છે કે સલામત ગોઠવણ કાળજી અને જ્ઞાન માગે છે. માહિતીનું ખુલ્લા પડવું પણ encrypt ન કરવા કે પહોંચ મર્યાદિત ન કરવામાંથી આવે છે, એટલે કે ફરી એક ચૂક.
લઢણ એ છે કે આ નબળાઈઓ માણસ અને પ્રક્રિયાની અંદાજી શકાય એવી નિષ્ફળતાઓનું પરિણામ છે, એટલે કે જ્ઞાનની ખોટ, સમયનું દબાણ અને નજરચૂક. એટલે જ્યાં આ સંજોગો હોય ત્યાં એ પાછી આવે છે, અને એ સંજોગો લગભગ બધે જ હોય છે.
એટલે જ એ વરસોવરસ 'સૌથી સામાન્ય vulnerability' ની યાદીઓમાં ટોચે રહે છે, અને એટલે જ security નું શિક્ષણ (આ પાઠ જેવું) મહત્ત્વનું છે: પ્રચલિત નબળાઈઓ અને એમના બચાવ જાણવા, એ જ developers ને એ ભૂલો ફરી ન કરવાનો રસ્તો છે. આ ખામીઓ ટકી રહે છે કારણ કે એમને જન્માવતી ભૂલો કરવી સહેલી છે અને નજર બહાર જવા દેવી પણ સહેલી; અને એટલે જ જાગૃતિ તથા શિસ્તબદ્ધ સલામત ટેવો જ ખરો ઉપાય છે. જાણીતી નબળાઈઓ એટલા માટે ટકે છે કે જાણીતી સારી ટેવો સતત પળાતી નથી.
Summary
Key takeaways
- Vulnerability એટલે system ની એવી નબળાઈ જેનો હુમલાખોર લાભ લઈ શકે; સામાન્ય નબળાઈઓ જાણવાથી બચાવ કરનારા એમને પૂરી શકે છે.
- Injection attacks એવો નુકસાનકારક input સરકાવે છે જેને system command તરીકે ચલાવે (દા.ત. SQL injection); input ની ચકાસણી અને parameterised queries એને અટકાવે છે.
- અસલામત security settings (ખોટી ગોઠવણ, નબળાં મૂળ મૂલ્યો, બંધ કરેલાં રક્ષણો) સામાન્ય છે અને એનો લાભ લેવો સહેલો છે; સલામત ગોઠવણ તથા નિયમિત ચકાસણી એને અટકાવે છે.
- સંવેદનશીલ માહિતી ત્યારે ખુલ્લી પડે છે જ્યારે data encrypt કર્યા વગરનો કે ઢીલા રક્ષણ વાળો હોય અને એટલે લીક થાય; encryption અને મર્યાદિત પહોંચ એને અટકાવે છે.
- તૂટેલું authentication હુમલાખોરોને login ટાળવા કે પચાવી પાડવા દે છે; મજબૂત authentication અને સલામત session નું સંચાલન એને અટકાવે છે.
- આ નબળાઈઓ અનેક systems માં પાછી આવ્યા કરે છે કારણ કે એ સામાન્ય અને ટાળી શકાય એવી ભૂલોમાંથી જન્મે છે.
- યાદ રાખવાની કડી: injection, ખોટી ગોઠવણ, માહિતીનું ખુલ્લા પડવું અને તૂટેલું authentication, દરેકને એના બંધબેસતા બચાવથી પૂરી દો.