වරක් මම මගේ ලිව්වා . එම තනතුර කැප වූයේ ඉතා රසවත් ගැටලුවක් වන ස්ටෙගානොග්‍රැෆි සඳහා ය. ඇත්ත වශයෙන්ම, එම පැරණි මාතෘකාවේ යෝජනා කරන විසඳුම වචනයේ පරිසමාප්ත අර්ථයෙන්ම ස්ටෙගනොග්‍රැෆි ලෙස හැඳින්විය නොහැක. එය ගොනු ආකෘති සහිත ක්‍රීඩාවක් පමණක් වන නමුත්, කෙසේ වෙතත් ඉතා රසවත් ක්‍රීඩාවකි.
අද අපි ටිකක් ගැඹුරට හාරා LSB ඇල්ගොරිතම දෙස බැලීමට උත්සාහ කරමු. ඔබ උනන්දුවක් දක්වන්නේ නම්, cat යටතේ ඔබව සාදරයෙන් පිළිගනිමු. (කැපීම යටතේ ගමනාගමනය වේ: මෙගාබයිට් පමණ.)
පළමුවෙන්ම, කෙටි හැඳින්වීමක් කිරීම අවශ්ය වේ. ගුප්ත ලේඛනයේ අරමුණ රහස් තොරතුරු කියවීමට නොහැකි වීම බව කවුරුත් දනිති. ඇත්ත වශයෙන්ම, ගුප්තකේතනය එහි යෙදුම් ඇත, නමුත් දත්ත ආරක්ෂාව සඳහා තවත් ප්රවේශයක් ඇත. අපට තොරතුරු සංකේතනය කිරීමට අවශ්ය නැත, නමුත් අප සතුව එය නොමැති බව මවාපාන්න. ස්ටෙගනොග්‍රැෆි සොයා ගත්තේ මේ නිසා ය. විකිපීඩියාව අපට සහතික කරන්නේ “ස්ටෙගානොග්‍රැෆි (ග්‍රීක භාෂාවෙන් στεγανοσ - සැඟවුණු සහ ග්‍රීක γραφω - මම ලියන්නේ, වචනාර්ථයෙන් “රහස් ලිවීම”) සම්ප්‍රේෂණය පිළිබඳ සත්‍යය රහසිගතව තබා ගනිමින් සැඟවුණු තොරතුරු සම්ප්‍රේෂණය කිරීමේ විද්‍යාවයි.
ඇත්ත වශයෙන්ම, ගුප්ත ලේඛන සහ ස්ටෙගනොග්රැෆික් ක්රම ඒකාබද්ධ කිරීම කිසිවෙකු තහනම් නොකරයි. එපමණක් නොව, ප්රායෝගිකව ඔවුන් මෙය සිදු කරයි, නමුත් අපගේ කාර්යය වන්නේ මූලික කරුණු තේරුම් ගැනීමයි. ඔබ විකිපීඩියා ලිපිය ප්‍රවේශමෙන් අධ්‍යයනය කරන්නේ නම්, ස්ටෙගනොග්‍රැෆි ඇල්ගොරිතමවලට ඊනියා ඇතුළත් වන බව ඔබට පෙනී යනු ඇත. බහාලුම් සහ පණිවිඩය. කන්ටේනරයක් යනු අපගේ රහස් පණිවිඩය සැඟවීමට උපකාර වන ඕනෑම තොරතුරකි.
අපගේ නඩුවේදී, කන්ටේනරය BMP ආකෘතියේ රූපයක් වනු ඇත. පළමුව, මෙම ගොනුවේ ව්යුහය දෙස බලමු. ගොනුව කොටස් 4 කට බෙදිය හැකිය: ගොනු ශීර්ෂය, රූප ශීර්ෂය, palette සහ රූපයම. අපගේ අරමුණු සඳහා, අපට දැන ගැනීමට අවශ්ය වන්නේ ශීර්ෂයේ ලියා ඇති දේ පමණි.
ශීර්ෂයේ පළමු බයිට දෙක BM අත්සන වේ, පසුව ගොනු ප්‍රමාණය බයිට් වලින් ලියා ඇත, ඊළඟ බයිට් 4 වෙන් කර ඇති අතර බිංදු අඩංගු විය යුතුය, අවසාන වශයෙන්, තවත් ද්විත්ව වචනයක ආරම්භයේ සිට ඕෆ්සෙට් අඩංගු වේ. රූපයේ සැබෑ බයිට් වෙත ගොනු කරන්න. 24-bit bmp ගොනුවක, සෑම පික්සලයක්ම BGR බයිට් තුනකින් කේතනය කර ඇත.
දැන් අපි රූපයට යන්නේ කෙසේදැයි දනිමු, ඉතිරිව ඇත්තේ අපට අවශ්ය තොරතුරු එහි ලියන්නේ කෙසේද යන්න තේරුම් ගැනීමයි. මේ සඳහා අපට LSB ක්රමය අවශ්ය වේ. ක්රමයේ සාරය පහත පරිදි වේ: වර්ණ කේතනය සඳහා වගකිව යුතු බයිට් වල අවම වශයෙන් සැලකිය යුතු බිටු අපි ප්රතිස්ථාපනය කරමු. අපි හිතමු අපේ රහස් පණිවිඩයේ මීළඟ බයිටය 11001011 නම්, සහ රූපයේ ඇති බයිට් නම්...11101100 01001110 01111100 0101100111..., එවිට කේතීකරණය මේ ආකාරයෙන් දිස්වේවි. අපි රහස් පණිවිඩ බයිටය බිටු දෙකේ කොටස් 4කට බෙදන්නෙමු: 11, 00, 10, 11, සහ රූපයේ පහත් අනුපිළිවෙලෙහි බිටු ප්‍රතිඵලයක් ලෙස ලැබෙන කොටස් සමඟ ප්රතිස්ථාපනය කරන්න: ...11101111 01001100 01111110 0101100111.... එවැනි ආදේශකයක් සාමාන්යයෙන් මිනිස් ඇසට නොපෙනේ. එපමණක් නොව, බොහෝ පැරණි නිමැවුම් උපාංගවලට එවැනි සුළු වෙනස්කම් පෙන්වීමට පවා නොහැකි වනු ඇත.
ඔබට අවම වශයෙන් සැලකිය යුතු බිටු 2 ක් පමණක් නොව, ඒවායින් ඕනෑම සංඛ්යාවක් වෙනස් කළ හැකි බව පැහැදිලිය. පහත රටාව ඇත: අපි වැඩිපුර බිටු වෙනස් කරන තරමට, අපට සැඟවිය හැකි තොරතුරු වැඩි වන අතර, මෙය මුල් රූපයට වැඩි මැදිහත්වීමක් ඇති කරයි. උදාහරණයක් ලෙස, මෙන්න පින්තූර දෙකක්:
මගේ උපරිම උත්සාහය නොතකා, ඔවුන් අතර වෙනස දැකීමට මට නොහැකි විය, නමුත් කෙසේ වෙතත්, දෙවන රූපයේ, විස්තර කරන ලද ක්රමය භාවිතා කරමින්, ලුවිස් කැරොල්ගේ "The Hunting of the Snark" කවිය සැඟවී ඇත. ඔබ මෙතෙක් කියවා ඇත්නම්, ක්‍රියාත්මක කිරීම ගැන ඉගෙන ගැනීමට ඔබ උනන්දු විය හැකිය. එය තරමක් සරල ය, නමුත් සෑම දෙයක්ම ඩෙල්ෆි හි සිදු කර ඇති බව මම ඔබට වහාම අනතුරු අඟවන්නෙමි. මේ සඳහා හේතු දෙකක් තිබේ: 1. මම හිතන්නේ ඩෙල්ෆි හොඳ භාෂාවක්; 2. මෙම වැඩසටහන උපත ලැබුවේ පරිගණක දර්ශනයේ මූලික කරුණු පිළිබඳ පා course මාලාවක් සකස් කිරීමේ ක්‍රියාවලියේදී වන අතර, මම මෙම පා course මාලාව උගන්වන පිරිමි ළමයින් තවමත් ඩෙල්ෆි හැර වෙනත් කිසිවක් නොදනිති. වාක්‍ය ඛණ්ඩය ගැන නොදන්නා අය සඳහා, එක් දෙයක් පැහැදිලි කිරීම අවශ්ය වේ: shl x යනු x මගින් වමට තරමක් මාරුවීමකි, shr x යනු x මගින් දකුණට මාරුවීමකි.
අපි උපකල්පනය කරන්නේ නූලක ගබඩා කර ඇති පෙළ කන්ටේනරය තුළට ලියන අතර පහළ බයිට් දෙක ප්රතිස්ථාපනය කරන බවයි:
පටිගත කිරීමේ කේතය:
i:=1 සිට length(str) do සඳහා
පටන් ගනී
l1:=බයිට්(str[i]) ශ්‍ර 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.Position:=f.Position-1;
tmp:=((tmp shr 2) shl 2)+l1;
f.WriteBuffer(tmp,1);
f.ReadBuffer(tmp,1);
f.Position:=f.Position-1;
tmp:=((tmp shr 2) shl 2)+l2;
f.WriteBuffer(tmp,1);
f.ReadBuffer(tmp,1);
f.Position:=f.Position-1;
tmp:=((tmp shr 2) shl 2)+l3;
f.WriteBuffer(tmp,1);
f.ReadBuffer(tmp,1);
f.Position:=f.Position-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