નબળાઈઓનો ઉપયોગ કરવા પર એક નજર

જેમ હું આ વિષય પર ચર્ચા કરવાનું ચાલુ રાખવાની રાહ જોઈ રહ્યો હતો, ચાલો હું તમને ઇતિહાસ, સિદ્ધાંત અને નબળાઈઓ પરના અભ્યાસનો થોડો કહો. આપણે બધાં હવેથી સાંભળ્યું છે કે સુરક્ષા ભૂલો પર ખૂબ ખર્ચ થઈ શકે છે, આપણે બધા જાણીએ છીએ કે આપણે આપણા સ softwareફ્ટવેરને અદ્યતન રાખવું જોઈએ, આપણે બધા જાણીએ છીએ કે સુરક્ષા સુધારાની ક્ષતિઓને લીધે ઘણા બધા અપડેટ્સ થાય છે. પરંતુ આજે હું તમને આ ભૂલો કેવી રીતે મળી આવે છે અને તેનું શોષણ થાય છે તેના વિશે થોડું કહીશ - પરંતુ આ પહેલા અમે વધુ સારી રીતે વિહંગાવલોકન કરવા માટે થોડી વિગતો સ્પષ્ટ કરવા જઈશું.

તમે શરૂ કરો તે પહેલાં

પ્રથમ હું તમને કહેવા માંગુ છું કે આપણે પહેલી નબળાઈઓ પર ધ્યાન કેન્દ્રિત કરવા જઈ રહ્યા છીએ જેનો મેં શોષણ કરવાનું શીખ્યા, જાણીતા બફર ઓવરફ્લો, આ નબળાઈમાં અમે મનોરંજક વસ્તુઓ કરવા માટે મેમરી ચકાસણીના અભાવનો લાભ લઈએ છીએ 🙂 પરંતુ ચાલો તેના વિશે થોડું વધુ સ્પષ્ટ કરીએ.

આ એક વાસ્તવિક વિશ્વનું દૃશ્ય બનશે નહીં

હું તેઓને જોયેલા કોઈપણ પ્રોગ્રામને તોડવા શીખવવાનું સમર્થ નથી - પ્રથમ કારણ કે તે તેમના કમ્પ્યુટર માટે જોખમી છે, બીજું કારણ કે તે મારા સામાન્ય શબ્દોના ક્વોટા કરતાં વધુ લેશે.

અમે 80 ના દાયકાની સફર પર જઈએ છીએ

હું તમને જે બતાવવા જઇ રહ્યો છું તે હું મારા લેપટોપ પર કરી શકું છું, પરંતુ તેનો અર્થ એ નથી કે તે આજે સરળ રીતે થઈ શકે છે - આમાંના ઘણા ખ્યાલો પહેલાથી જ ઘણી વખત શોષણ કરવામાં આવ્યા છે કે નવી સુરક્ષા પદ્ધતિઓ અને નવી પદ્ધતિઓ ટાળશે. તે ઉભરી આવ્યા છે - પરંતુ તે અમને તે જ સ્થાને પરત આપે છે, તે બધું કહી શકવા માટે કોઈ જગ્યા નથી. 🙂

તે તમારા પ્રોસેસર પર કામ કરી શકશે નહીં

જો કે હું ખૂબ જ સરળ ઉદાહરણનો ઉપયોગ કરવા જઈ રહ્યો છું, હું ઇચ્છું છું કે શરૂઆતથી જ તે સ્પષ્ટ થઈ જાય કે આની વિગતો ઘણી બધી અને એટલી વૈવિધ્યસભર છે કે જેમ તે મારા જેવા જ બહાર આવી શકે, જો તમે તેનો પ્રયાસ કરવા માંગતા હો , ઇચ્છિત અસર પણ પ્રાપ્ત કરી શકાતી નથી 🙂 પરંતુ તમે કલ્પના કરી શકો છો કે હું આ જગ્યામાં સમજાવી શકતો નથી, ખાસ કરીને કારણ કે આ પરિચય સાથે મેં પહેલેથી જ 300 થી વધુ શબ્દો લીધા છે, તેથી આપણે સીધા જ આપણી વાત પર પહોંચીએ.

શું છે એ બફર ઓવરફ્લો

આનો જવાબ આપવા માટે આપણે પહેલા આ સંયોજનનો પ્રથમ ભાગ સમજવો પડશે.

બફર

કમ્પ્યુટરમાં બધું જ મેમરી વિશેનું હોવાથી, તે તાર્કિક છે કે ત્યાં અમુક પ્રકારનો માહિતી કન્ટેનર હોવો જોઈએ. જ્યારે આપણે વાત કરીશું ઇનપુટ્સ o આઉટપુટ, અમે સીધા ખ્યાલ પર આવે છે બફર. તેને ટૂંકા રાખવા માટે, એ બફર તે નિર્ધારિત કદની મેમરી સ્પેસ છે જેમાં આપણે માહિતીનો જથ્થો સંગ્રહવા જઈશું, સરળ 🙂

ઓવરફ્લો થાય છે, નામ પ્રમાણે જ, જ્યારે કોઈ બફર સંભાળી શકે તે કરતાં વધુ માહિતી ભરે છે. પરંતુ આ કેમ મહત્વનું છે?

સ્ટેક

સ્ટેક્સ તરીકે પણ ઓળખાય છે, તે એક અમૂર્ત ડેટા પ્રકાર છે જેમાં આપણે કરી શકીએ છીએ સ્ટેક માહિતી, તેમની મુખ્ય લાક્ષણિકતા એ છે કે તેમની પાસે orderર્ડર છે LIFO (છેલ્લે ઇન ફર્સ્ટ આઉટ). ચાલો પ્લેટોના સ્ટેક વિશે એક બીજા માટે વિચાર કરીએ, અમે તેને એક પછી એક ટોચ પર મૂકીએ, અને પછી અમે તેને ઉપરથી એક પછી એક લઈ જઈએ, આ છેલ્લી પ્લેટ બનાવે છે જે આપણે મૂકી છે (એક જે ટોચ પર છે) ) એ પ્રથમ પ્લેટ છે જે આપણે બહાર કા takeવા જઈ રહ્યા છીએ, દેખીતી રીતે જો આપણે એક સમયે ફક્ત એક પ્લેટ લઈ શકીએ અને તે ક્રમમાં તે કરવાનું નક્કી કરીશું: પી.

હવે જ્યારે તમે આ બે વિભાવનાઓ જાણો છો, તો અમે તેમને ક્રમમાં ગોઠવીશું. સ્ટેક્સ મહત્વપૂર્ણ છે કારણ કે આપણે ચલાવેલા દરેક પ્રોગ્રામનું પોતાનું હોય છે એક્ઝેક્યુશન સ્ટેક. પરંતુ આ સ્ટેક એક છે ખાસ લાક્ષણિકતા, નીચે વધે છે. આ વિશે ફક્ત તમારે જાણવાની જરૂર છે કે જ્યારે કોઈ પ્રોગ્રામ ચાલે છે, જ્યારે કોઈ ફંકશન કહેવામાં આવે છે, ત્યારે સ્ટેક એક નંબર X થી મેમરીમાં એક નંબર (Xn) તરફ જાય છે. પરંતુ ચાલુ રાખવા માટે આપણે વધુ એક ખ્યાલ સમજવો જ જોઇએ.

પોઇંટર્સ

આ એક ખ્યાલ છે જે ઘણા પ્રોગ્રામરોને ક્રેઝી તરફ દોરી જાય છે જ્યારે તેઓ સીની દુનિયામાં પ્રારંભ કરે છે, હકીકતમાં સી પ્રોગ્રામિંગની મહાન શક્તિ અંશત poin પોઇંટર્સના ઉપયોગને કારણે છે. તેને સરળ રાખવા માટે, એક નિર્દેશક મેમરી સરનામું નિર્દેશ કરે છે. આ જટિલ લાગે છે, પરંતુ તે એટલું જટિલ નથી, આપણે બધાં આપણા મશીનોમાં રેમ રાખીએ છીએ, ખરું? સારું, આ એક તરીકે વ્યાખ્યાયિત કરી શકાય છે બ્લોક્સની સતત વ્યવસ્થા, આ સ્થાનો સામાન્ય રીતે હેક્સાડેસિમલ નંબર્સ (0 થી 9 અને પછી એ થી એફ, જેમ કે 0x0, 0x1, 0x6, 0xA, 0xF, 0x10) માં વ્યક્ત કરવામાં આવે છે. અહીં એક વિચિત્ર નોંધ તરીકે, 0x10 ના 10 to બરાબર છે જો આપણે તેને દશાંશ ક્રમમાં રૂપાંતરિત કરીએ તો તે 15 કહેતા સમાન હશે. આ એવી વસ્તુ છે જે પહેલા એક કરતા વધારેને પણ મૂંઝવણમાં મૂકી દે છે, પરંતુ ચાલો આપણે તેના પર નીચે ઉતરીએ.

રેકોર્ડ્સ

પ્રોસેસર્સ સંખ્યાબંધ સાથે કાર્ય કરે છે રેકોર્ડ, જે સ્થળોએ શારીરિક મેમરીથી પ્રોસેસર સુધી સ્થાનાંતરિત કરવાનું કામ કરે છે, આર્કિટેક્ચરો માટે કે જે 64-બીટ્સનો ઉપયોગ કરે છે, અહીં રજિસ્ટરની સંખ્યા વર્ણવવી મોટી અને મુશ્કેલ છે, પરંતુ વિચાર મેળવવા માટે, રજિસ્ટર નિર્દેશકો જેવા છે, તેઓ અન્ય વસ્તુઓ વચ્ચે સૂચવે છે. , મેમરી સ્થાન (સ્થાન).

હવે પ્રેક્ટિસ કરો

હું જાણું છું કે તે અત્યાર સુધી પ્રક્રિયા કરવા માટે ઘણી બધી માહિતી રહી છે, પરંતુ વાસ્તવમાં તે કંઈક અંશે જટિલ મુદ્દા છે જેનો હું ખૂબ જ સરળ રીતે સમજાવવાનો પ્રયત્ન કરું છું, અમે એક નાનો પ્રોગ્રામ જોશું જેમાં બફરનો ઉપયોગ થાય છે અને અમે જઈ રહ્યા છીએ ઓવરફ્લો વિશે આને સમજવા માટે તેને તોડી નાખો, દેખીતી રીતે આ તે નથી, તે એક વાસ્તવિક પ્રોગ્રામ છે, અને આપણે આજે જે કાઉન્ટરમેઝર્સનો ઉપયોગ કરવામાં આવે છે તે "ટાળવું" જઈ રહ્યા છીએ, ફક્ત તે બતાવવા માટે કે વસ્તુઓ પહેલા કેવી રીતે કરવામાં આવી હતી because અને આમાંથી કેટલાક સિદ્ધાંતો વધુ જટિલ વસ્તુઓ શીખવા માટે સક્ષમ થવા માટે જરૂરી છે

જીડીબી

એક મહાન પ્રોગ્રામ જે નિ Cશંકપણે સી પ્રોગ્રામર્સ દ્વારા સૌથી વધુ ઉપયોગમાં લેવામાં આવે છે. તેના ઘણા બધા ગુણોમાં આપણી પાસે એ હકીકત છે કે તે અમને આ બધું જોવા દે છે જે આપણે અત્યાર સુધી વાત કરી રહ્યા છીએ, રજિસ્ટર, સ્ટેક, બફર વગેરે. 🙂 ચાલો પ્રોગ્રામ જોઈએ જેનો આપણે ઉપયોગ કરીશું આપણા ઉદાહરણ માટે.

retinput.c

આ એકદમ સરળ પ્રોગ્રામ છે, આપણે પુસ્તકાલયનો ઉપયોગ કરીશું stdio.h માહિતી મેળવવા અને ટર્મિનલમાં પ્રદર્શિત કરવામાં સમર્થ થવા માટે. જેને આપણે ફંક્શન કહે છે return_input જે પેદા કરે છે બફર કહેવાય છે એરે, જેની લંબાઈ 30 છે બાઇટ્સ (ચાર ડેટા પ્રકાર 1 બાઇટ લાંબી છે).

કાર્ય gets(array); કન્સોલ અને ફંક્શન દ્વારા માહિતી વિનંતી printf() એરેની સામગ્રી પરત કરે છે અને તેને સ્ક્રીન પર પ્રદર્શિત કરે છે.

સી માં લખાયેલ દરેક પ્રોગ્રામની શરૂઆત ફંકશનથી થાય છે main(), આ ફક્ત રીટર્ન_પુટ ક callingલ કરવા માટેનો હવાલો હશે, હવે આપણે પ્રોગ્રામ કમ્પાઇલ કરવા જઈ રહ્યા છીએ.

ચાલો મેં હમણાંથી જે કર્યું તે થોડો લઈએ. વિકલ્પ -ggdb જીસીસીને કહે છે કે તે યોગ્ય રીતે ડીબગ કરવામાં સક્ષમ થવા માટે પ્રોગ્રામને માહિતી સાથે કમ્પાઇલ કરશે. -fno-stack-protector તે એક વિકલ્પ છે જે દેખીતી રીતે આપણે ઉપયોગમાં લેવા જોઈએ નહીં, પરંતુ અમે તેનો ઉપયોગ કરી રહ્યા છીએ કારણ કે નહીં તો સ્ટેકમાં બફર ઓવરફ્લો ઉત્પન્ન કરવાનું શક્ય બનશે. અંતે મેં પરિણામ પરીક્ષણ કર્યું છે. ./a.out તે ફક્ત જે મેં હમણાં સંકલિત કર્યું છે તે ચાલે છે, તે માહિતી માંગે છે અને તેને પાછું આપે છે. ચાલી રહેલ 🙂

ચેતવણી

અહીં બીજી નોંધ. તમે ચેતવણીઓ જોઈ શકો છો? સ્પષ્ટ છે કે જ્યારે આપણે કોડ સાથે કામ કરીએ છીએ અથવા કમ્પાઇલ કરીએ છીએ ત્યારે ધ્યાનમાં લેવા જેવું છે, આ થોડું સ્પષ્ટ છે અને આજે એવા કેટલાક પ્રોગ્રામ છે જેનું કાર્ય છે gets() કોડમાં જેન્ટુનો એક ફાયદો એ છે કે દરેક પ્રોગ્રામને કમ્પાઇલ કરીને, હું જોઈ શકું છું કે શું ખોટું હોઈ શકે છે, એક "આદર્શ" પ્રોગ્રામ તેમની પાસે ન હોવો જોઈએ, પરંતુ તમને આશ્ચર્ય થશે કે કેટલા મોટા પ્રોગ્રામ્સમાં આ ચેતવણીઓ છે કારણ કે તે ફક્ત ખૂબ મોટા છે અને તે છે જ્યારે એક જ સમયે ઘણી ચેતવણીઓ હોય ત્યારે ખતરનાક કાર્યોનો ટ્ર trackક રાખવાનું મુશ્કેલ છે. હવે જો આપણે ચાલુ રાખીએ

પ્રોગ્રામ ડિબગીંગ

હવે આ ભાગ થોડો મૂંઝવણભરી થઈ શકે છે, પરંતુ મેં પહેલેથી જ થોડું લખ્યું હોવાથી, હું બધું સમજાવવા સમર્થ નથી, તેથી માફ કરશો જો તમે જોશો કે હું ખૂબ ઝડપથી જઈ રહ્યો છું 🙂

કોડને નિષ્ક્રિય કરવા

ચાલો આપણા કમ્પાઇલ કરેલા મશીન લેંગ્વેજ પ્રોગ્રામને જોઈને પ્રારંભ કરીએ.

આ આપણા મુખ્ય ફંક્શનનો કોડ છે વિધાનસભા, આ તે છે જે આપણું પ્રોસેસર સમજે છે, ડાબી બાજુની લાઇન એ મેમરીનો ભૌતિક સરનામું છે <+ n> તરીકે ઓળખાય છે ઑફસેટ, મૂળભૂત રીતે ફંક્શનની શરૂઆતથી (મુખ્ય) તે નિવેદનની અંતર (તરીકે ઓળખાય છે ઓપકોડ). પછી આપણે સૂચનાનો પ્રકાર (પુશ / મોવ / કોલક…) અને એક અથવા વધુ રજિસ્ટર જોશું. સારાંશમાં આપણે કહી શકીએ કે તે સ્રોત / મૂળ અને લક્ષ્ય દ્વારા અનુસરેલ સૂચક છે. <return_input> અમારા બીજા કાર્ય સંદર્ભ લે છે, ચાલો એક નજર કરીએ.

રીટર્ન_પુટ

આ થોડું વધારે જટિલ છે, પરંતુ હું ઇચ્છું છું કે તમે કેટલીક વસ્તુઓની તપાસ કરો, ત્યાં એક ટેગ કહેવામાં આવે છે <gets@plt> અને એક છેલ્લું ઓપ્કોડ કહેવાય છે retq ફંક્શનનો અંત દર્શાવે છે. આપણે ફંક્શનમાં કેટલાક બ્રેકપોઇન્ટ્સ મૂકીશું gets અને બીજામાં retq.

ચલાવો

હવે આપણે ક્રિયા કેવી રીતે શરૂ થાય છે તે જોવા માટે પ્રોગ્રામ ચલાવવા જઈ રહ્યા છીએ.

આપણે જોઈ શકીએ છીએ કે એક નાનો તીર દેખાય છે જ્યાં ઓપ્કોડ સૂચવે છે જ્યાં આપણે છીએ, હું ઇચ્છું છું કે તે દિશા ધ્યાનમાં લે 0x000055555555469b, આ ક theલ કર્યા પછીનું સરનામું છે return_input કાર્યમાં main , આ મહત્વપૂર્ણ છે કારણ કે આ તે છે જ્યાં તમે પ્રોગ્રામ પ્રાપ્ત કરવાનું સમાપ્ત કરો ત્યારે પાછા આવવા જોઈએ ઇનપુટચાલો, ફંક્શનમાં આવીએ. હવે આપણે ફંકશનમાં પ્રવેશતા પહેલા મેમરી ચકાસીશું gets.

મેં તમારા માટે મુખ્ય ફંક્શન પાછું મૂક્યું છે, અને હું ઉલ્લેખ કરું છું તે કોડને હાઇલાઇટ કર્યો છે, જેમ કે તમે જોઈ શકો છો, અંત બે ભાગમાં વિભાજીત થઈ ગયું છે, હું ઇચ્છું છું કે તેઓ દિશા ધ્યાનમાં લે 0x7fffffffdbf0 (કમાન્ડો પછી ડાબી બાજુએથી પ્રથમ x/20x $rsp) કારણ કે આ તે સ્થાન છે જે આપણે ઉપયોગના પરિણામો તપાસવા માટે વાપરવા માટે છે, ચાલો ચાલુ રાખીએ:

કાર્યક્રમ તોડી રહ્યો છે

મેં તે પ્રકાશિત કર્યું છે 0x44444444કારણ કે તે અમારા ડીએસનું પ્રતિનિધિત્વ છે 🙂 હવે અમે ઉમેરવાનું શરૂ કર્યું છે ઇનપુટ પ્રોગ્રામમાં, અને તમે જોઈ શકો છો કે, અમે અમારા ઇચ્છિત સરનામાંથી માત્ર બે લાઇનો જ છીએ, અમે પહેલાના પગલામાં પ્રકાશિત કરેલા સરનામાંઓ પહેલા નહીં ત્યાં સુધી અમે તેને ભરવા જઈશું.

પરત કરવાનો રસ્તો બદલવો

હવે આપણે કોડના આ વિભાગમાં પ્રવેશવાનું સંચાલિત કર્યું છે જ્યાં તે ફંક્શનનું વળતર સૂચવે છે, ચાલો જોઈએ કે જો આપણે સરનામું બદલીએ તો શું થાય છે - aપ્કોડના સ્થાન પર જવાને બદલે જે આપણે એક ક્ષણ પહેલા કર્યું હતું, જો અમે પાછા જઇએ તો તમને શું લાગે છે return_input? પરંતુ આ માટે, અમે દ્વિસંગીમાં જોઈએ તે સરનામું લખવું જરૂરી છે, આપણે તે કાર્ય સાથે કરીશું printf બાશ from માંથી

હવે અમને બે વાર માહિતી મળી છે - ચોક્કસ પ્રોગ્રામ તેના માટે બનાવવામાં આવ્યો ન હતો, પરંતુ અમે કોડને તોડવા અને તેને કંઈક એવું પુનરાવર્તિત કરવામાં સફળ કર્યું છે જે કરવાનું ન હતું.

પ્રતિબિંબ

આ સરળ ફેરફારને ગણી શકાય શોષણ ખૂબ જ મૂળભૂત - તે પ્રોગ્રામને તોડવા માટે વ્યવસ્થાપિત છે અને અમે કંઈક કરવા માંગીએ છીએ તે કંઈક કરવું તે.

જોવા અને ઉમેરવા માટેની વસ્તુઓની લગભગ અનંત સૂચિમાં આ ફક્ત પ્રથમ પગલું છે, ફક્ત orderર્ડરને પુનરાવર્તિત કરવા કરતાં વધુ વસ્તુઓ ઉમેરવાની રીતો છે, પરંતુ આ વખતે મેં ઘણું લખ્યું છે અને તે સંબંધિત બધી બાબતો શેલકોડિંગ લેખો કરતાં વધુ લખવા માટેનો વિષય છે, હું કહીશ તે સંપૂર્ણ પુસ્તકો. માફ કરજો જો હું પસંદ કરેલા વિષયોમાં થોડું વધારે માહિતી આપી શક્યું ન હોત, પરંતુ ચોક્કસ ત્યાં એક તક મળશે 🙂 શુભેચ્છાઓ અને અહીં આવવા બદલ આભાર.