એલએસબી સ્ટેગનોગ્રાફી

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

આજે આપણે થોડું ઊંડું ખોદવાનો પ્રયત્ન કરીશું અને LSB એલ્ગોરિધમને જોઈશું. જો તમને રસ હોય, તો બિલાડી હેઠળ તમારું સ્વાગત છે. (કટ હેઠળ ટ્રાફિક છે: લગભગ એક મેગાબાઇટ.)

સૌ પ્રથમ, ટૂંકો પરિચય કરવો જરૂરી છે. દરેક વ્યક્તિ જાણે છે કે ક્રિપ્ટોગ્રાફીનો હેતુ ગુપ્ત માહિતી વાંચવાનું અશક્ય બનાવવાનો છે. અલબત્ત, ક્રિપ્ટોગ્રાફીમાં તેની એપ્લિકેશનો છે, પરંતુ ડેટા સુરક્ષા માટે અન્ય અભિગમ છે. અમારે માહિતીને એન્ક્રિપ્ટ કરવાની જરૂર નથી, પરંતુ ડોળ કરીએ છીએ કે અમારી પાસે તે નથી. આ કારણે જ સ્ટેગનોગ્રાફીની શોધ થઈ હતી. વિકિપીડિયા અમને ખાતરી આપે છે કે “સ્ટેગનોગ્રાફી (ગ્રીકમાંથી στεγανοσ - હિડન અને ગ્રીક γραφω - હું લખું છું, શાબ્દિક રીતે "ગુપ્ત લેખન") એ ટ્રાન્સમિશનની હકીકતને ગુપ્ત રાખીને માહિતીના છુપાયેલા ટ્રાન્સમિશનનું વિજ્ઞાન છે.

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

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

હેડરના પ્રથમ બે બાઇટ BM સહી છે, પછી બાઇટ્સમાં ફાઇલનું કદ ડબલ શબ્દમાં લખવામાં આવે છે, આગામી 4 બાઇટ આરક્ષિત છે અને તેમાં શૂન્ય હોવું આવશ્યક છે, અને અંતે, બીજા ડબલ શબ્દની શરૂઆતથી ઓફસેટ શામેલ છે. ઇમેજના વાસ્તવિક બાઇટ્સ પર ફાઇલ કરો. 24-બીટ bmp ફાઇલમાં, દરેક પિક્સેલ ત્રણ BGR બાઇટ્સ સાથે એન્કોડેડ છે.

હવે આપણે જાણીએ છીએ કે ઇમેજ પર કેવી રીતે પહોંચવું, જે બાકી છે તે સમજવાનું છે કે આપણે ત્યાં જરૂરી માહિતી કેવી રીતે લખી શકીએ. આ માટે આપણને LSB પદ્ધતિની જરૂર પડશે. પદ્ધતિનો સાર નીચે મુજબ છે: અમે રંગ એન્કોડિંગ માટે જવાબદાર બાઇટ્સમાં ઓછામાં ઓછા નોંધપાત્ર બિટ્સને બદલીએ છીએ. ચાલો કહીએ કે જો આપણા ગુપ્ત સંદેશનો આગામી બાઈટ 11001011 છે, અને ઈમેજમાંના બાઈટ...11101100 01001110 01111100 0101100111... છે, તો એન્કોડિંગ આના જેવું દેખાશે. અમે ગુપ્ત સંદેશ બાઈટને 4 ટુ-બીટ ભાગોમાં વિભાજિત કરીશું: 11, 00, 10, 11, અને પરિણામી ટુકડાઓ સાથે છબીના લો-ઓર્ડર બિટ્સને બદલીશું: ...11101111 01001100 01111110 0101100111…. આવા રિપ્લેસમેન્ટ સામાન્ય રીતે માનવ આંખ માટે ધ્યાનપાત્ર નથી. તદુપરાંત, ઘણા જૂના આઉટપુટ ઉપકરણો આવા નાના ફેરફારોને પ્રદર્શિત કરવામાં પણ સમર્થ હશે નહીં.

તે સ્પષ્ટ છે કે તમે માત્ર 2 ઓછામાં ઓછા નોંધપાત્ર બિટ્સ જ નહીં, પરંતુ તેમાંની કોઈપણ સંખ્યા બદલી શકો છો. નીચેની પેટર્ન છે: આપણે જેટલા વધુ બિટ્સ બદલીશું, તેટલી વધુ માહિતી આપણે છુપાવી શકીશું અને આનાથી મૂળ ઈમેજમાં વધુ દખલ થશે. ઉદાહરણ તરીકે, અહીં બે છબીઓ છે:

મારા શ્રેષ્ઠ પ્રયાસો છતાં, હું તેમની વચ્ચેનો તફાવત જોઈ શક્યો નહીં, પરંતુ તેમ છતાં, બીજી છબીમાં, વર્ણવેલ પદ્ધતિનો ઉપયોગ કરીને, લેવિસ કેરોલની કવિતા "ધ હન્ટિંગ ઓફ ધ સ્નાર્ક" છુપાયેલ છે. જો તમે આટલું વાંચ્યું છે, તો કદાચ તમને અમલીકરણ વિશે જાણવામાં રસ હશે. તે એકદમ સરળ છે, પરંતુ હું તમને તરત જ ચેતવણી આપીશ કે બધું ડેલ્ફીમાં થઈ ગયું છે. આના બે કારણો છે: 1. મને લાગે છે કે ડેલ્ફી એક સારી ભાષા છે; 2. આ પ્રોગ્રામનો જન્મ કોમ્પ્યુટર વિઝનની મૂળભૂત બાબતો પર કોર્સ તૈયાર કરવાની પ્રક્રિયામાં થયો હતો, અને હું જેમને આ કોર્સ શીખવી રહ્યો છું તેઓ હજુ સુધી ડેલ્ફી સિવાય બીજું કંઈ જાણતા નથી. જેઓ વાક્યરચનાથી પરિચિત નથી તેમના માટે, એક વસ્તુ સમજાવવાની જરૂર છે: shl x એ x દ્વારા ડાબી બાજુની બીટવાઇઝ શિફ્ટ છે, shr x એ x દ્વારા જમણી તરફની બીટવાઇઝ શિફ્ટ છે.

અમે ધારીએ છીએ કે અમે સ્ટ્રિંગમાં સંગ્રહિત ટેક્સ્ટને કન્ટેનરમાં લખી રહ્યા છીએ અને નીચેના બે બાઇટ્સને બદલી રહ્યા છીએ:
રેકોર્ડિંગ કોડ:

i:=1 થી લંબાઈ(str) માટે કરો
    શરૂઆત
      l1:=byte(str[i]) shr 6;
      l2:=byte(str[i]) shl 2; l2:=l2 shr 6;
      l3:=byte(str[i]) shl 4; l3:=l3 shr 6;
      l4:=byte(str[i]) shl 6; l4:=l4 shr 6;
 
      f.ReadBuffer(tmp,1);
      f.પોઝિશન:=f.પોઝિશન-1;
      tmp:=((tmp shr 2) shl 2)+l1;
      f.WriteBuffer(tmp,1);
 
      f.ReadBuffer(tmp,1);
      f.પોઝિશન:=f.પોઝિશન-1;
      tmp:=((tmp shr 2) shl 2)+l2;
      f.WriteBuffer(tmp,1);
 
      f.ReadBuffer(tmp,1);
      f.પોઝિશન:=f.પોઝિશન-1;
      tmp:=((tmp shr 2) shl 2)+l3;
      f.WriteBuffer(tmp,1);
 
      f.ReadBuffer(tmp,1);
      f.પોઝિશન:=f.પોઝિશન-1;
      tmp:=((tmp shr 2) shl 2)+l4;
      f.WriteBuffer(tmp,1);
 
    અંત;

વાંચવા માટે કોડ:

i:=1 થી MsgSize માટે કરો
    શરૂઆત
      f.ReadBuffer(tmp,1);
      l1:=tmp shl 6;
      f.ReadBuffer(tmp,1);
      l2:=tmp shl 6; l2:=l2 shr 2;
      f.ReadBuffer(tmp,1);
      l3:=tmp shl 6; l3:=l3 shr 4;
      f.ReadBuffer(tmp,1);
      l4:=tmp shl 6; l4:=l4 shr 6;
      str:=str+char(l1+l2+l3+l4);
    અંત;

સારું, ખરેખર આળસુ લોકો માટે - પ્રોગ્રામ અને તેના સ્રોત કોડની લિંક.

Спасибо.

સોર્સ: www.habr.com