ఒకప్పుడు నాది రాసింది . మరియు ఆ పోస్ట్ చాలా ఆసక్తికరమైన సమస్యకు అంకితం చేయబడింది, అవి స్టెగానోగ్రఫీ. వాస్తవానికి, ఆ పాత అంశంలో ప్రతిపాదించబడిన పరిష్కారాన్ని పదం యొక్క నిజమైన అర్థంలో స్టెగానోగ్రఫీ అని పిలవలేము. ఇది ఫైల్ ఫార్మాట్‌లతో కూడిన గేమ్, అయితే చాలా ఆసక్తికరమైన గేమ్.
ఈ రోజు మనం కొంచెం లోతుగా త్రవ్వడానికి ప్రయత్నిస్తాము మరియు 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 to length(str) do
ప్రారంభం
l1:=బైట్(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.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);
అంతం;
చదవడానికి కోడ్:
నేను కోసం:=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