Tinutukoy ng function code (FC) sa header ng telegram ang uri ng telegram, gaya ng Request telegram (Request o Send/Request) at Acknowledgement o Response telegram (Acknowledgement frame, Response frame). Bilang karagdagan, ang function code ay naglalaman ng aktwal na transmission function at impormasyon ng kontrol na pumipigil sa pagkawala at pagdoble ng mga mensahe, o ang uri ng istasyon na may katayuang FDL .

7	6	5	4	3	2	1	0	FC: Kahilingan ng Function Code
	1							Humiling ng Telegram
			X					FCV = Alternating bit na naka-on
		X						href=”http://profibus.felser.ch/en/funktionscode.htm#aufruffolgebit”>FCB = Alternating bit (mula sa frame count)
1				0 (0x0)				CV = Halaga ng Orasan()
1				iba pa				Nakareserba
0				0 (0x0)				TE = Kaganapan sa Oras (Pag-synchronize ng orasan)
0				3 (0x3)				SDA_LOW = Send Data Acknowledged - mababang priyoridad
0				4 (0x4)				SDN_LOW = Ipadala ang Data Hindi kinikilala - mababang priyoridad
0				5 (0x5)				SDA_HIGH = Ipadala ang Data na Kinikilala - mataas ang priyoridad
0				6 (0x6)				SDN_HIGH = Ipadala ang Data Hindi kinikilala
0				7 (0x7)				MSRD = Magpadala ng Data ng Kahilingan na may Multicast na Tugon
0				9 (0x9)				Humiling ng Katayuan ng FDL
0				12(0xC)				Mababa ang SRD = Magpadala at Humiling ng Data
0				13(0xD)				SRD mataas = Magpadala at Humiling ng Data
0				14(0xE)				Request Ident na may tugon
0				15 (0xF)				Humiling ng LSAP Status na may tugon 1)
0				iba pa				Nakareserba

1) ang halagang ito ay nasa huling bersyon ng ang pamantayan hindi tinukoy ngunit nakalaan na lamang

7	6	5	4	3	2	1	0	FC: Pagtugon sa Code ng Pag-andar
	0							Tumugon sa telegrama
0								Nakareserba
		0	0					alipin
		0	1					Master hindi pa handa
		1	0					Master handa na, walang token
		1	1					Master handa na, sa token ring
				0 (0x0)				OK
				1 (0x1)				UE = Error sa Gumagamit
				2 (0x2)				RR = Walang mapagkukunan
				3 (0x3)				RS = SAP ay hindi pinagana
				8 (0x8)				DL = Data Low (normal case na may DP)
				9 (0x9)				NR = Walang handa na data ng tugon
				10(0xA)				DH = Data High (DP diagnosis nakabinbin)
				12(0xC)				RDL = Hindi natanggap ang data at Mababa ang Data
				13(0xD)				RDH = Data na hindi natanggap at Data High
				iba pa				Nakareserba

Frame Count Bit Ang frame count bit FCB (b5) ay pumipigil sa pagdoble ng mensahe ng pagkilala o pagtugon sa istasyon(responder) at anumang pagkawala ng calling station (initiator). Hindi kasama rito ang mga kahilingang walang pagkilala (SDN) at FDL Status, Ident at LSAP Status na kahilingan.

Para sa pagkakasunud-sunod ng seguridad, ang nagpasimula ay dapat magdala ng FCB para sa bawat tumugon. Kapag ang isang Request telegram (Kahilingan o Ipadala/Kahilingan) ay ipinadala sa isang tagatugon sa unang pagkakataon, o kung ito ay muling ipinadala sa isang tagatugon na kasalukuyang minarkahan bilang hindi gumagana, ang FCB ay dapat na itakda bilang tinukoy sa tumugon. Nakamit ito ng initiator sa isang Request telegram na may FCV=0 at FCB=1. Dapat tasahin ng tagatugon ang isang telegrama ng ganitong uri bilang unang ikot ng mensahe at iimbak ang FCB=1 kasama ang address ng nagpasimula (SA) (tingnan ang sumusunod na talahanayan). Ang ikot ng mensaheng ito ay hindi uulitin ng nagpasimula. Sa kasunod na mga telegrama ng Kahilingan sa parehong tagatugon, dapat itakda ng nagpasimula ang FCV=1 at baguhin ang FCB sa bawat bagong Telegram ng Kahilingan. Ang sinumang tumugon na makatanggap ng isang Request telegram na naka-address dito gamit ang FCV=1 ay dapat suriin ang FCB. Kung ang FCB ay nagbago kapag inihambing sa huling Humiling na telegram mula sa parehong initiator (parehong SA), ito ay wastong kumpirmasyon na ang naunang ikot ng mensahe ay natapos nang maayos. Kung ang Request telegram ay nagmula sa ibang initiator (ibang SA), hindi na kailangan ang pagsusuri sa FCB. Sa parehong mga kaso, dapat na i-save ng tagatugon ang FCB kasama ang pinagmulang SA hanggang sa matanggap ang isang bagong telegrama na naka-address dito. Sa kaso ng nawala o may kapansanan sa pagkilala o pagtugon sa telegrama, ang FCB ay hindi dapat palitan ng nagpasimula sa kahilingang muli: ito ay magsasaad na ang nakaraang ikot ng mensahe ay mali. Kung ang tagatugon ay nakatanggap ng isang Request telegram na may FCV=1 at ang parehong FCB bilang ang huling Request telegram mula sa parehong initiator (parehong SA), ito ay magsasaad ng kahilingan na muling subukan. Ang tagatugon naman ay dapat na muling ipadala ang pagkilala o tugon na telegrama na hawak bilang kahandaan. Hanggang sa nabanggit na kumpirmasyon o pagtanggap ng isang telegrama na may ibang address (SA o DA) na hindi kinikilala (Send Data with No Acknowledge, SDN) ang tagatugon ay dapat hawakan ang huling pagkilala o tugon telegrama bilang kahandaan para sa anumang posibleng kahilingang muli. . Sa kaso ng Humiling ng mga telegrama na hindi kinikilala at may Status ng Request FDL, Ident, at LSAP Status, FCV=0 at FCB=0; hindi na kailangan ang pagsusuri ng tagatugon.

b5	b4	Bit na posisyon
FCB	FCV	Kundisyon	Ibig sabihin	Aksyon
0	0	DA = TS/127	Humiling nang walang pagkilala Humiling ng FDL Status/ Ident/ LSAP Status	Tanggalin ang huling pagkilala
0/1	0/1	DA#TS	Humiling sa ibang tagatugon
1	0	DA = TS	Unang kahilingan	FCBM:= 1 SAM:=SA Tanggalin ang huling pagkilala / tugon
0/1	1	DA = TS SA = SAM FCB#FCBM	Bagong Kahilingan	Tanggalin ang huling pagkilala / tugon FCBM:=FCB Hawakan ang pagkilala / tugon bilang kahandaan para sa muling pagsubok
0/1	1	DA = TS SA = SAM FCB = FCBM	Subukan muli ang Kahilingan	FCBM:=FCB Ulitin ang pagkilala / tugon at patuloy na humawak sa pagiging handa
0/1	1	DA = TS SA#SAM	Bagong initiator	FCBM:=FCB SAM:= SA Hold acknowledgement / response in ready for retry

Inimbak ng FCBM ang FCB sa memorya Inimbak ng SAM ang SA sa memorya

Ang paghahanap sa pamamagitan ng pag-scan ng mga file ng mga kilalang uri (o, gaya ng madalas na sinasabi, paghahanap ng mga file sa pamamagitan ng lagda) ay isa sa mga pinaka-epektibong ginagamit sa R-Studio data recovery utility. Ang paggamit ng isang ibinigay na lagda ay nagbibigay-daan sa iyo upang ibalik ang mga file ng isang tiyak na uri sa kaganapan na ang impormasyon sa istraktura ng direktoryo at mga pangalan ng file ay bahagyang o ganap na nawawala (nasira).

Karaniwan, ang talahanayan ng disk partition ay ginagamit upang matukoy ang lokasyon ng mga file. Kung ihahambing mo ang isang disk sa isang libro, ang talahanayan ng partisyon ay magiging katulad ng talaan ng mga nilalaman nito. Kapag nag-scan, ang R-Studio ay naghahanap ng mga kilalang uri ng file sa disk partition table gamit ang ilang partikular na pirma. Ito ay naging posible sa pamamagitan ng katotohanan na halos lahat ng uri ng file ay may natatanging lagda o pattern ng data. Ang mga lagda ng file ay matatagpuan sa isang partikular na lokasyon sa simula ng file at sa maraming mga kaso din sa dulo ng file. Kapag nag-scan, tinutugma ng R-Studio ang nahanap na data sa mga lagda ng mga kilalang uri ng file, na nagpapahintulot sa kanila na makilala at mabawi ang kanilang data.

Gamit ang teknolohiya para sa pag-scan ng mga kilalang uri ng file, pinapayagan ka ng R-Studio na mabawi ang data mula sa mga disk na na-reformat at ang mga partition table ay na-overwrit. Bukod dito, kung ang isang disk partition ay na-overwrite, nasira o tinanggal, ang pag-scan sa mga kilalang uri ng file ay ang tanging pagpipilian.

Ngunit halos lahat ay may mga kakulangan nito, at ang mga kilalang uri ng file na ginagamit sa R-Studio ay walang pagbubukod. Kaya, kapag nag-scan ng mga kilalang uri ng file, pinapayagan ka ng R-Studio na mabawi lamang ang mga unfragmented na file, ngunit, tulad ng nabanggit na, sa karamihan ng mga kaso ito ang pinakabagong posibleng paraan.

Kasama na sa R-Studio ang mga lagda ng mga pinakakaraniwang uri ng file (view buong listahan Ang mga file ng mga kilalang uri ay matatagpuan sa seksyong R-Studio Online Help.)

Kung kinakailangan, maaaring magdagdag ang user ng mga bagong uri ng file sa R-Studio. Halimbawa, kung kailangan mong maghanap ng mga file ng isang natatanging uri, o ang mga binuo pagkatapos ng petsa ng huling paglabas ng R-Studio, maaari mong idagdag ang iyong sariling mga lagda sa mga file ng mga kilalang uri. Ang prosesong ito ay tatalakayin sa susunod.

Mga Custom na File ng Mga Kilalang Uri
Ang mga custom na lagda para sa mga kilalang uri ng file ay naka-imbak sa XML file na tinukoy sa dialog box ng Mga Setting. Ang pagdaragdag ng pirma ay binubuo ng dalawang bahagi:

1. Pagpapasiya ng lagda ng file na matatagpuan sa simula ng file at, kung naroroon, sa dulo ng file.
2. Bumuo ng XML file na naglalaman ng file signature at iba pang impormasyon tungkol sa uri ng file.

Ang lahat ng ito ay maaaring gawin gamit ang R-Studio. Kasabay nito, hindi mo kailangang maging isang dalubhasa sa larangan ng pagbubuo (pag-edit) ng mga dokumentong XML o sa larangan ng hexadecimal na pag-edit - sa gabay na ito (artikulo), na naglalayong sa gumagamit mismo antas ng pagpasok, lahat ng mga yugto ng prosesong ito ay tatalakayin nang detalyado.

Halimbawa: Pagdaragdag ng pirma para sa isang MP4 file (XDCam-EX Codec)
Tingnan natin ang pagdaragdag ng file signature gamit ang halimbawa ng isang .MP4 file na ginawa gamit ang gamit ang Sony XDCAM-EX. Maaari mo itong gamitin, halimbawa, kung sakaling masira ang SD card para sa mga file na hindi mo pa nai-save sa hard drive ng iyong computer.

Unang Yugto: Pagtukoy sa File Signature
Upang matukoy ang lagda ng file, isaalang-alang ang mga halimbawa ng mga file na may parehong format.

Sabihin nating apat na video file ito mula sa Sony XDCAM-EX:
ZRV-3364_01.MP4
ZRV-3365_01.MP4
ZRV-3366_01.MP4
ZRV-3367_01.MP4

Para sa kadalian ng pagsasaalang-alang, hayaan itong maging maliliit na file. Ang mas malalaking file ay mas mahirap tingnan sa hexadecimal na format.

1. Buksan ang mga file sa R-Studio. Upang gawin ito, mag-right-click sa bawat file at piliin ang Tingnan/I-edit mula sa menu ng konteksto.

2. Ihambing natin ang mga file. Hahanapin namin ang parehong pattern na matatagpuan sa lahat ng apat na file. Siya ay lilitaw lagda ng file. Karaniwan, ang mga file signature ay matatagpuan sa simula ng file, ngunit minsan sa dulo.

3. Tukuyin ang file signature sa simula ng file. Sa aming halimbawa, ito ay matatagpuan sa pinakadulo simula ng file. Tandaan na hindi ito palaging nangyayari - kadalasan ang file signature ay nasa simula ng file, ngunit hindi sa unang linya (offset).

Mula sa mga larawan sa ibaba, lumalabas na ang mga nilalaman ng lahat ng apat na file ay iba, ngunit lahat sila ay nagsisimula sa parehong file signature.


Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Ang naka-highlight na lugar sa mga larawan ay ang file signature ng ganitong uri ng file. Ito ay ipinakita sa parehong teksto at hexadecimal na format.

Sa text form, ang file signature ay ganito:
....ftypmp42....mp42........libre

Ang mga tuldok (“.”) ay nagpapahiwatig ng mga character na hindi maaaring katawanin sa anyong teksto. Samakatuwid, kinakailangan ding magbigay ng hexadecimal form ng file signature:
00 00 00 18 66 74 79 6D 70 34 32 00 00 00 00 6D 70 34 32 00 00 00 00 00 00 00 08 66 72 65 65

4. Sa parehong paraan, tinutukoy namin ang file signature, ngunit sa pinakadulo ng file. Maaaring ibang file signature ito, ibang haba.

Ang mga larawan sa ibaba ay nagha-highlight sa file signature sa dulo ng file:


Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Pakitandaan na ang data bago ang napiling lugar (file signature) ay pareho sa lahat ng apat na file. Ito ay teknikal na impormasyon na hindi isang file signature, ngunit nagpapahiwatig na ang lahat ng apat na larawan (mga file) ay kinuha gamit ang parehong camera na may parehong mga parameter. Karaniwang posible na makilala ang pagtutugma ng mga pattern sa teknikal na impormasyon mula sa isang file signature. Sa aming halimbawa, sa huling linya bago magsimula ang file signature, makikita namin ang text na 'RecordingMode type="normal"', na malinaw na nagpapahiwatig na ito ay isang uri ng parameter ng file, at hindi isang signature. Laging bigyan ng espesyal na pansin ang linyang ito upang hindi magkamali isama teknikal na impormasyon bahagi ng file signature.

Sa aming kaso, ang file signature ay ang sumusunod na text:
...
Paalalahanan ka namin na ang mga tuldok ay nagpapahiwatig ng mga character na hindi maaaring katawanin sa text form.

Sa hexadecimal, ang file signature ay ganito:
3N 2F 4E 6F 6E 52 65 61 6N 54 69 6A 65 4A 65 74 61 3E 0D 0A 00
Pakitandaan: ang lagda ay hindi palaging nasa dulo ng file.

Ikalawang Yugto: Paglikha ng XML file na naglalarawan ng Kilalang Uri ng File
Ngayon, nang matukoy ang lagda ng file, maaari kang lumikha ng isang XML file at isama ang kaukulang uri ng file sa R-Studio. Magagawa ito sa dalawang paraan:

2.1 Paggamit ng built-in graphic editor mga lagda ng file:
Piliin ang item na Mga Setting mula sa menu ng Mga Tool, sa dialog box ng Mga Setting na bubukas, mag-click sa tab na Mga Kilalang Uri ng File at pagkatapos ay i-click ang pindutang I-edit ang Mga Uri ng File ng User.

Mag-click sa larawan upang palakihin ito

I-click ang button na Lumikha ng Uri ng File sa dialog box ng Edit User's File Types.
Itakda ang mga sumusunod na opsyon:

• Id - isang natatanging digital identifier. Ang numerong ito ay pipiliin nang random; Ang tanging bagay ay hindi ito dapat tumugma sa digital identifier ng anumang iba pang uri ng file.
• Paglalarawan ng Grupo - ang pangkat kung saan matatagpuan ang mga nahanap na file sa R-Studio. Maaari kang magtakda ng alinman sa isang bagong pangkat, o pumili ng isa sa mga umiiral na. Para sa amin ito ang magiging grupong "Multimedia Video (Multimedia: Video)".
• Paglalarawan - maikling paglalarawan uri ng file. Sa aming halimbawa, maaari mong gamitin, halimbawa, "Sony cam video, XDCam-EX".
• Extension - extension ng mga file ng ganitong uri. Sa aming kaso - mp4.

Ang parameter na Mga Tampok ay opsyonal, sa aming kaso hindi namin kailangang gamitin ito.

Mag-click sa larawan upang palakihin ito

Susunod, kailangan mong ipasok ang simula at wakas na lagda ng file. Upang gawin ito, piliin ang Magsimula at pagkatapos ay sa menu ng konteksto ang Add Signature command.

Mag-click sa larawan upang palakihin ito

Pagkatapos ay i-double click ang field<пустая сигнатура> () at ilagay ang naaangkop na teksto.

Mag-click sa larawan upang palakihin ito

Pagkatapos ay lumikha ng panghuling lagda ng file. Tiyaking ilagay ang 21 sa column na Mula.

Mag-click sa larawan upang palakihin ito

Matagumpay kang nakagawa ng iyong sariling lagda para sa mga kilalang uri ng file.

Ngayon ay kailangan mong i-save ito. Mayroong dalawang paraan: maaari mo itong i-save sa default na file na tinukoy sa Main tab ng dialog box ng Mga Setting sa pamamagitan ng pag-click sa button na I-save. O i-click ang Save As... button at i-save ang signature sa ibang file.

2.2 Manu-manong paggawa ng XML file na naglalarawan sa isang Kilalang Uri ng File:
Upang lumikha ang file na ito Gamitin natin ang XML version 1.0 at UTF-8 encoding. Huwag mawalan ng pag-asa kung hindi mo alam kung ano ito - buksan mo lang ang anuman text editor(halimbawa, Notepad.exe) at ipasok ang sumusunod na teksto sa unang linya:

Susunod na gagawa kami ng XML tag na tumutukoy sa uri ng file (FileType). Isinasaalang-alang ang naunang inilarawan na mga katangian ng XML, magiging ganito ang hitsura ng tag:

Ipasok natin kaagad pagkatapos

Susunod, tinukoy namin ang file signature (tag ). Ang paunang lagda (sa simula ng file) ay nasa loob ng tag nang walang anumang mga katangian. Ginagamit namin ang uri ng teksto ng lagda, ngunit sabay na pinapalitan ng mga hexadecimal na character na hindi maaaring katawanin sa anyo ng teksto. Bago ang bawat hexadecimal na character ay ipinapasok namin ang "\x" Kaya ang tag na may file signature ay magiging ganito:

Kung naroroon, dapat mo ring tukuyin ang nagtatapos na lagda (sa dulo ng file). Gumagamit ito ng parehong tag, ngunit may elementong "mula sa" at katangiang "end". Magiging ganito ang hitsura:

Tandaan na ang panghuling lagda ng file ay hindi naglalaman ng mga hindi tekstong character, ngunit naglalaman ito ng mga slash at tatsulok na bracket. Upang maiwasan ang pagkalito at mga error sa XML syntax, papalitan namin ang mga character na "/", " sa lagda<" и ">" ang kanilang mga hexadecimal na halaga.

Sa dulo, pagkatapos ng mga lagda ng file, dapat mayroong mga closing tag na FileType at FileTypeList:

Kaya ang buong file ay dapat magmukhang ganito:


\x00\x00\x00\x18ftypmp42\x00\x00\x00\x00mp42\x00\x00\x00\x00\x00\x00\x00\x08libre
\x3C\x2FNonRealTimeMeta\x3E\x0D\x0A\x00

Tandaan: Ang XML syntax ay case sensitive, kaya ang tamang tag ay , hindi .

I-save natin ang file sa text format na may extension na .xml. Halimbawa: SonyCam.xml.

Matagumpay kaming nakagawa ng sarili naming lagda para sa mga kilalang uri ng file. Ang halimbawang ito ay sapat na upang maunawaan ang mga pangunahing prinsipyo ng paglikha ng isang pasadyang uri ng file. Maaaring gumamit ng XML bersyon 2.0 ang mas maraming karanasang user. Maaari kang magbasa nang higit pa tungkol dito sa seksyong Tulong sa online na R-Studio.

Hakbang 3: Pagsusuri at Pagdaragdag ng File na Naglalarawan ng Kilalang Uri ng File
Ang susunod na hakbang ay idagdag (i-upload) ang iyong XML file sa R-Studio. Sa kasong ito, awtomatiko itong susuriin.

I-load natin ang XML file na nilikha sa nakaraang yugto sa R-Studio. Upang gawin ito, piliin ang item na Mga Setting sa menu ng Mga Tool. Sa lugar ng mga uri ng file ng User sa Main tab ng dialog box ng Mga Setting, idagdag ang XML file na ginawa namin (SonyCam.xml). I-click ang button na Ilapat.

Mag-click sa larawan upang palakihin ito

2. Sagutin ang Oo sa kahilingang mag-download ng bagong uri ng file.

Mag-click sa larawan upang palakihin ito

3. Upang i-verify na matagumpay na na-load ang uri ng file, mag-click sa tab na Mga Kilalang Uri ng File ng dialog box ng Mga Setting. Tandaan na idinagdag namin ang uri ng file sa pangkat ng Multimedia Video. Sa pagpapalawak ng pangkat na ito (folder), dapat tayong makakita ng isang elemento na may paglalarawang tinukoy namin noong gumagawa ng XML file: Sony cam video, XDCam-EX (.mp4).

Mag-click sa larawan upang palakihin ito

Mag-click sa larawan upang palakihin ito

Kung mayroong anumang mga error sa syntax ng file, makakakita ka ng kaukulang mensahe:

Mag-click sa larawan upang palakihin ito

Sa kasong ito, suriin muli ang iyong XML file para sa mga error. Tandaan: Ang XML syntax ay case sensitive at ang bawat tag ay dapat may pansarang tag sa dulo.

Hakbang 4: Pagsubok sa File na Naglalarawan ng Kilalang Uri ng File
Upang suriin ang kawastuhan ng custom na uri ng file na aming ginawa, subukan nating hanapin ang aming mga .mp4 na file sa isang naaalis na USB flash drive.

1. Sa ilalim ng Windows Vista o Windows 7, magsagawa ng buong (hindi mabilis) na pag-format ng disk o gumamit ng utility sa paglilinis ng espasyo sa disk (halimbawa, R-Wipe & Clean) upang kumpletong pagtanggal lahat ng data na magagamit sa disk. Hayaan USB disk na-format sa FAT32 (ang laki ng mga hinanap na file ay hindi lalampas sa 2 GB).

2. Kopyahin ang mga test file sa disk at i-reboot ang computer upang ang mga nilalaman ng cache memory ay nai-save sa disk. Maaari mo ring i-disable panlabas na drive at pagkatapos ay ikonekta itong muli.

3. Sa OS, ang drive ay tutukuyin bilang, halimbawa, logical drive F:\.

4. Ilunsad natin ang R-Studio. Piliin ang aming drive (F:\) at i-click ang Scan button

Mag-click sa larawan upang palakihin ito

5. Sa Scan dialog box, sa (File System) na lugar, i-click ang Change... button at alisan ng tsek ang lahat ng box. Sa ganitong paraan, hindi namin paganahin ang paghahanap para sa mga file system at mga file gamit ang partition table.
Mag-click sa larawan upang palakihin ito

6. Lagyan ng check ang Extra Search para sa Mga Kilalang Uri ng File na checkbox. Papayagan nito ang R-Studio na maghanap ng mga kilalang uri ng file kapag nag-scan.

7. Upang simulan ang pag-scan, i-click ang Scan button.

8. Maghintay tayo habang ini-scan ng R-Studio ang disk. Ipapakita ng tab na Impormasyon sa Pag-scan ang progreso ng pag-scan (pag-unlad).


Mag-click sa larawan upang palakihin ito

9. Pagkatapos makumpleto ang pag-scan, piliin ang elemento ng Extra Found Files at i-double click ito.


Mag-click sa larawan upang palakihin ito

10. Ang aming mga test file ay matatagpuan sa Sony cam video, XDCam-EX folder (o sa isang folder na may ibang pangalan na naaayon sa paglalarawan ng uri ng file na tinukoy sa Ikalawang Yugto).


Mag-click sa larawan upang palakihin ito

Nakita mo na ang mga pangalan ng file, petsa at lokasyon (mga folder) ay hindi naibalik dahil impormasyong ito nakaimbak sa file system. Samakatuwid, awtomatikong ipapakita ng R-Studio ang bawat file na may bagong pangalan.

Gayunpaman, malinaw na ang mga nilalaman ng mga file ay hindi nasira. Upang i-verify ito, buksan natin ang mga ito sa naaangkop na programa, halimbawa VLC media player.


Mag-click sa larawan upang palakihin ito

Konklusyon
Ang kakayahan ng R-Studio na mag-scan para sa mga kilalang uri ng file ay nagpapahintulot sa iyo na mabawi ang data kahit na mula sa isang disk na ang mga file system ay na-overwrite. Maaari kang maghanap ng mga file nang epektibo gamit ang kanilang mga lagda, na lalong kapaki-pakinabang kung alam mo nang eksakto ang uri ng mga file na ibinabalik, tulad ng sa aming halimbawa. Ang kakayahang lumikha ng mga custom na uri ng file ay nagbibigay-daan sa iyo upang magdagdag ng anumang file na may partikular na lagda ng file sa listahan ng mga kilalang uri ng file.

Maaaring narinig ng marami ang mga file tulad ng rarjpeg Ito ay isang espesyal na uri ng file, na isang jpeg na imahe at isang rar archive na pinagsama-sama Ito ay isang mahusay na lalagyan para sa pagtatago ng katotohanan ng pagpapadala ng impormasyon ang mga sumusunod na utos:

UNIX: cat image1.jpg archive.rar > image2.jpg
WINDOWS: kopyahin ang /b image1.jpg+archive.rar image2.jpg

O kung mayroon kang hex editor.

Siyempre, upang itago ang katotohanan ng pagpapadala ng impormasyon, maaari mong gamitin hindi lamang ang format na JPEG, kundi pati na rin ang marami pang iba. Ang bawat format ay may sariling mga katangian, dahil sa kung saan ito ay maaaring o hindi maaaring maging angkop para sa papel na ginagampanan ng lalagyan. Ilalarawan ko kung paano mo mahahanap ang mga naka-paste na file sa pinakasikat na mga format o ipahiwatig ang katotohanan ng gluing.

Ang mga pamamaraan para sa pag-detect ng mga pinagsama-samang file ay maaaring nahahati sa tatlong grupo:

1. Paraan para sa pagsuri sa lugar pagkatapos ng EOF marker. Maraming mga sikat na format ng file ang may tinatawag na end-of-file marker, na responsable para sa pagpapakita ng nais na data. Halimbawa, binabasa ng mga tumitingin ng larawan ang lahat ng byte hanggang sa marker na ito, ngunit hindi pinansin ang lugar pagkatapos nito. Ang pamamaraang ito ay perpekto para sa mga sumusunod na format: JPEG, PNG, GIF, ZIP, RAR, PDF.
2. Paraan para sa pagsuri sa laki ng file. Ang istraktura ng ilang mga format (mga lalagyan ng audio at video) ay nagbibigay-daan sa iyong kalkulahin ang aktwal na laki ng file at ihambing ito sa orihinal na laki. Mga Format: AVI, WAV, MP4, MOV.
3. Paraan para sa pagsuri ng mga CFB file. Ang CFB o Compound File Binary Format ay isang format ng dokumento na binuo ng Microsoft, na isang lalagyan na may sarili nitong lalagyan file system. Ang pamamaraang ito ay batay sa pag-detect ng mga anomalya sa isang file.

Mayroon bang buhay pagkatapos ng pagtatapos ng isang file?

JPEG

Upang mahanap ang sagot sa tanong na ito, kinakailangan upang bungkalin ang mga pagtutukoy ng format, na siyang "ninuno" ng mga pinagsama-samang file at maunawaan ang istraktura nito. Ang anumang JPEG ay nagsisimula sa pirmang 0xFF 0xD8.

Pagkatapos ng lagdang ito mayroong impormasyon ng serbisyo, opsyonal na icon ng imahe at, sa wakas, ang naka-compress na imahe. Sa format na ito, ang dulo ng larawan ay minarkahan ng dalawang-byte na lagda 0xFF 0xD9.

PNG

Ang unang walong byte ng PNG file ay inookupahan ng sumusunod na lagda: 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A. Tapusin ang lagda na nagtatapos sa stream ng data: 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82.

RAR

Karaniwang lagda para sa lahat ng rar archive: 0x52 0x61 0x72 0x21 (Rar!). Pagkatapos nito ay dumating ang impormasyon tungkol sa bersyon ng archive at iba pang nauugnay na data. Eksperimento na natukoy na ang archive ay nagtatapos sa pirmang 0x0A, 0x25, 0x25, 0x45, 0x4F, 0x46.

Talaan ng mga format at ang kanilang mga lagda:
Ang algorithm para sa pagsuri para sa gluing sa mga format na ito ay napakasimple:

1. Hanapin ang paunang lagda;
2. Hanapin ang huling pirma;
3. Kung walang data pagkatapos ng huling lagda, malinis ang iyong file at hindi naglalaman ng mga attachment! Kung hindi, kinakailangang maghanap ng iba pang mga format pagkatapos ng huling lagda.

GIF at PDF

Ang isang PDF na dokumento ay maaaring magkaroon ng higit sa isang EOF marker, halimbawa dahil sa maling paggawa ng dokumento. Ang bilang ng mga huling lagda sa isang GIF file ay katumbas ng bilang ng mga frame sa loob nito. Batay sa mga tampok ng mga format na ito, posible na mapabuti ang algorithm para sa pagsuri sa pagkakaroon ng mga nakalakip na file.

1. Ang point 1 ay inuulit mula sa nakaraang algorithm.
2. Ang punto 2 ay paulit-ulit mula sa nakaraang algorithm.
3. Kapag nahanap mo ang huling lagda, tandaan ang lokasyon nito at maghanap pa;
4. Kung maabot mo ang huling EOF marker sa ganitong paraan, malinis ang file.
5. Kung ang file ay hindi nagtatapos sa isang end signature, ang goto ay ang lokasyon ng huling end signature na natagpuan.

Ang isang malaking pagkakaiba sa pagitan ng laki ng file at ang posisyon pagkatapos ng huling lagda ay nagpapahiwatig ng pagkakaroon ng isang malagkit na attachment. Ang pagkakaiba ay maaaring higit sa sampung byte, kahit na ang iba pang mga halaga ay maaaring itakda.

ZIP

Ang kakaiba ng mga archive ng ZIP ay ang pagkakaroon ng tatlong magkakaibang mga lagda: Ang istraktura ng archive ay ang mga sumusunod:

Lokal na File Header 1

Data ng File 1

Deskriptor ng Data 1

Lokal na File Header 2

Data ng File 2

Deskriptor ng Data 2

...

Lokal na File Header

Data ng File n

Deskriptor ng Datos n

Header ng pag-decryption ng archive

I-archive ang dagdag na tala ng data

Direktoryo ng sentral

Ang pinakakawili-wili ay ang sentral na direktoryo, na naglalaman ng metadata tungkol sa mga file sa archive. Ang gitnang direktoryo ay palaging nagsisimula sa signature na 0x50 0x4b 0x01 0x02 at nagtatapos sa signature na 0x50 0x4b 0x05 0x06, na sinusundan ng 18 byte ng metadata. Kapansin-pansin, ang mga walang laman na archive ay binubuo lamang ng panghuling lagda at 18 zero byte. Pagkatapos ng 18 bytes ay darating ang lugar ng komento sa archive, na isang mainam na lalagyan para sa pagtatago ng file.

Upang suriin ang isang ZIP archive, kailangan mong hanapin ang dulong lagda ng gitnang direktoryo, laktawan ang 18 byte at hanapin ang mga lagda ng mga kilalang format sa lugar ng komento. Malaking sukat Ang komento ay nagpapahiwatig din ng katotohanan ng gluing.

Mahalaga ang sukat

AVI

Ang istraktura ng isang AVI file ay ang mga sumusunod: ang bawat file ay nagsisimula sa isang RIFF signature (0x52 0x49 0x46 0x46). Sa byte 8 mayroong isang AVI signature na tumutukoy sa format (0x41 0x56 0x49 0x20). Ang block sa offset 4, na binubuo ng 4 na byte, ay naglalaman ng paunang sukat ng data block (byte order - maliit na endian). Upang malaman ang block number na naglalaman ng susunod na laki, kailangan mong idagdag ang laki ng header (8 bytes) at ang laki na nakuha sa 4-8 byte block. Kinakalkula nito ang kabuuang laki ng file. Katanggap-tanggap na ang kinakalkula na laki ay maaaring mas maliit kaysa sa aktwal na laki ng file. Pagkatapos ng kalkuladong laki, ang file ay maglalaman lamang ng zero byte (kinakailangan upang ihanay ang 1Kb na hangganan).

Halimbawa ng pagkalkula ng laki:

WAV

Tulad ng AVI, ang WAV file ay nagsisimula sa isang RIFF signature, gayunpaman, ang file na ito ay may signature mula sa byte 8 - WAVE (0x57 0x41 0x56 0x45). Ang laki ng file ay kinakalkula sa parehong paraan tulad ng AVI. Aktwal na laki dapat na eksaktong kapareho ng kinakalkula.

MP4

Ang MP4 o MPEG-4 ay isang format ng lalagyan ng media na ginagamit upang mag-imbak ng mga video at audio stream, na nagbibigay din para sa pag-imbak ng mga subtitle at larawan.
Sa offset 4 bytes mayroong mga lagda: uri ng file ftyp (66 74 79 70) (Uri ng File ng QuickTime Container) at subtype ng file na mmp4 (6D 6D 70 34). Para sa pagkilala nakatagong mga file, interesado kami sa kakayahang kalkulahin ang laki ng file.

Tingnan natin ang isang halimbawa. Ang laki ng unang bloke ay nasa offset zero, at ito ay 28 (00 00 00 1C, Big Endian byte order); ipinapahiwatig din nito ang offset kung saan matatagpuan ang laki ng pangalawang bloke ng data. Sa offset 28 nakita namin ang susunod na laki ng bloke na katumbas ng 8 (00 00 00 08). Upang mahanap ang susunod na laki ng bloke, kailangan mong idagdag ang mga sukat ng mga nakaraang bloke na natagpuan. Kaya, ang laki ng file ay kinakalkula:

MOV

Ang malawak na ginagamit na format na ito ay isa ring lalagyan ng MPEG-4. Gumagamit ang MOV ng proprietary data compression algorithm, may istraktura na katulad ng MP4 at ginagamit para sa parehong layunin - para sa pag-iimbak ng data ng audio at video, pati na rin ang mga nauugnay na materyales.
Tulad ng MP4, anumang mov file ay may 4-byte ftyp na lagda sa offset 4, gayunpaman, ang susunod na lagda ay may halagang qt__ (71 74 20 20). Ang panuntunan para sa pagkalkula ng laki ng file ay hindi nagbago: simula sa simula ng file, kinakalkula namin ang laki ng susunod na bloke at idagdag ito.

Ang paraan ng pagsuri sa grupong ito ng mga format para sa pagkakaroon ng "sticky" na mga file ay upang kalkulahin ang laki ayon sa mga panuntunang tinukoy sa itaas at ihambing ito sa laki ng file na sinusuri. Kung ang kasalukuyang laki ng file ay mas maliit kaysa sa kinakalkula, kung gayon ito ay nagpapahiwatig ng katotohanan ng gluing. Kapag sinusuri ang mga file ng AVI, tinatanggap na ang kinakalkula na laki ay maaaring mas maliit kaysa sa laki ng file dahil sa pagkakaroon ng mga idinagdag na mga zero upang ihanay ang hangganan. Sa kasong ito, kinakailangang suriin ang mga zero pagkatapos ng kinakalkula na laki ng file.

Sinusuri ang Compound File Binary Format

Ang format ng file na ito, na binuo ng Microsoft, ay kilala rin bilang OLE (Object Linking and Embedding) o COM (Component Object Model). DOC file, XLS, PPT ay nabibilang sa pangkat ng mga format ng CFB.

Ang isang CFB file ay binubuo ng isang 512-byte na header at mga sektor ng pantay na haba na nag-iimbak ng mga stream ng data o impormasyon ng serbisyo. Ang bawat sektor ay may sariling di-negatibong numero, maliban sa mga espesyal na numero: "-1" - binibilang ang libreng sektor, "-2" - binibilang ang sektor na nagsasara ng kadena. Ang lahat ng mga chain ng sektor ay tinukoy sa FAT table.

Ipagpalagay natin na binago ng isang attacker ang isang partikular na .doc file at nag-paste ng isa pang file sa dulo nito. Mayroong ilang sa iba't ibang paraan tuklasin ito o magpahiwatig ng anomalya sa dokumento.

Abnormal na laki ng file

Tulad ng nabanggit sa itaas, ang anumang CFB file ay binubuo ng isang header at mga sektor na may pantay na haba. Upang malaman ang laki ng sektor, kailangan mong basahin ang isang two-byte na numero sa offset 30 mula sa simula ng file at itaas ang 2 sa kapangyarihan ng numerong ito. Ang numerong ito ay dapat na katumbas ng alinman sa 9 (0x0009) o 12 (0x000C), ayon sa pagkakabanggit, ang laki ng file sector ay 512 o 4096 bytes. Matapos mahanap ang sektor, kailangan mong suriin ang sumusunod na pagkakapantay-pantay:

(FileSize - 512) mod SectorSize = 0

Kung ang pagkakapantay-pantay na ito ay hindi nasiyahan, maaari mong ituro ang katotohanan ng gluing ng mga file. Gayunpaman, ang pamamaraang ito ay may isang makabuluhang disbentaha. Kung alam ng isang attacker ang laki ng sektor, kailangan lang niyang i-paste ang kanyang file at isa pang n byte upang ang laki ng na-paste na data ay isang multiple ng laki ng sektor.

Hindi kilalang uri ng sektor

Kung alam ng isang umaatake ang tungkol sa isang paraan upang i-bypass ang nakaraang pagsusuri, maaaring matukoy ng pamamaraang ito ang pagkakaroon ng mga sektor na may mga hindi natukoy na uri.

Tukuyin natin ang pagkakapantay-pantay:

FileSize = 512 + CountReal * SectorSize, kung saan ang FileSize ay ang laki ng file, ang SectorSize ay ang laki ng sektor, ang CountReal ay ang bilang ng mga sektor.

Tinukoy din namin ang mga sumusunod na variable:

1. CountFat – bilang ng mga sektor ng FAT. Matatagpuan sa offset 44 mula sa simula ng file (4 bytes);
2. CountMiniFAT – bilang ng mga sektor ng MiniFAT. Matatagpuan sa offset 64 mula sa simula ng file (4 bytes);
3. CountDIFAT – bilang ng mga sektor ng DIFAT. Matatagpuan sa offset 72 mula sa simula ng file (4 bytes);
4. CountDE – bilang ng mga sektor ng Directory Entry. Upang mahanap ang variable na ito, kailangan mong hanapin ang unang sektor DE, na nasa offset 48. Pagkatapos ay kinakailangan upang makakuha ng kumpletong representasyon ng DE mula sa FAT at bilangin ang bilang ng mga sektor ng DE;
5. CountStreams – bilang ng mga sektor na may mga stream ng data;
6. CountFree – bilang ng mga libreng sektor;
7. CountClassified – bilang ng mga sektor na may tiyak na uri;

CountClassified = CountFAT + CountMiniFAT + CountDIFAT + CountDE + CountStreams + CountFree

Malinaw, kung ang CountClassified at CountReal ay hindi pantay, maaari naming tapusin na ang mga file ay maaaring pagsamahin.

Binigyan ako ng aking amo ng isang medyo kawili-wiling gawain. Sa maikling panahon, magsulat ng executable file analyzer na makakahanap ng mga virus body batay sa mga lagda at matukoy ang packer/cryptor na ginamit. Ang natapos na prototype ay lumitaw sa loob ng ilang oras.

Salita ng may-akda

Pagsusuri ng lagda

Ang paghahanap para sa isang nakakahamak na bagay gamit ang mga lagda ay isang bagay na maaaring gawin ng anumang antivirus. Sa pangkalahatan, ang isang lagda ay isang pormal na paglalarawan ng ilang mga katangian kung saan matutukoy na ang file na ini-scan ay isang virus at isang mahusay na tinukoy na virus.

Mayroong iba't ibang mga diskarte dito. Ang isang alternatibo ay ang paggamit ng isang lagda na binubuo ng N bytes ng isang malisyosong bagay. Sa kasong ito, hindi ka maaaring gumawa ng isang hangal na paghahambing, ngunit isang paghahambing gamit ang ilang maskara (tulad ng paghahanap ng mga byte na EB ?? ?? CD 13). O magtakda ng mga karagdagang kundisyon tulad ng "ganyan at ganoong mga byte ay dapat nasa entry point sa program" at iba pa. Ang lagda ng malware ay isang partikular na bagay.

Sa parehong paraan, ang ilang mga palatandaan ay inilarawan kung saan matutukoy ng isa na ang executable file ay naka-pack na may isa o isa pang cryptor o packer (halimbawa, ang banal na ASPack). Kung maingat mong basahin ang aming magazine, tiyak na narinig mo ang tungkol sa isang tool tulad ng PEiD, na may kakayahang tukuyin ang pinakakaraniwang ginagamit na mga packer, cryptors at compiler (ang database ay may malaking bilang ng mga lagda) para sa PE file na inilipat dito . Sa kasamaang palad, ang mga bagong bersyon ng programa ay hindi inilabas sa loob ng mahabang panahon, at kamakailan lamang ay lumitaw ang isang mensahe sa opisyal na website na ang proyekto ay hindi magkakaroon ng karagdagang pag-unlad. Nakakalungkot, dahil ang mga kakayahan ng PEiD (lalo na kung isasaalang-alang ang plugin system) ay maaaring maging kapaki-pakinabang sa akin. Pagkatapos ng maikling pagsusuri, naging malinaw na hindi ito isang opsyon. Ngunit pagkatapos maghukay sa mga blog sa wikang Ingles, mabilis kong nakita kung ano ang nababagay sa akin. YARA Project (code.google.com/p/yara-project).

Ano ang YARA?

Sa simula pa lang, kumbinsido ako na sa isang lugar sa Internet mayroon nang isang open source development na kukuha sa gawain ng pagtukoy ng mga sulat sa pagitan ng isang tiyak na lagda at ang file na sinusuri. Kung makakahanap ako ng ganoong proyekto, madali itong mailagay sa daang-bakal ng isang web application, magdagdag ng iba't ibang mga lagda doon at makuha ang hinihiling sa akin. Nagsimulang magmukhang mas makatotohanan ang plano nang mabasa ko ang paglalarawan ng proyekto ng YARA.

Ang mga developer mismo ay nagpoposisyon nito bilang isang tool upang matulungan ang mga mananaliksik ng malware na tukuyin at uriin ang mga nakakahamak na sample. Ang mananaliksik ay maaaring gumawa ng mga paglalarawan para sa iba't ibang uri malware na gumagamit ng text o binary pattern na naglalarawan sa mga pormal na katangian ng malware. Ganito ang pagkuha ng mga pirma. Sa katunayan, ang bawat paglalarawan ay binubuo ng isang hanay ng mga linya at ilang lohikal na pagpapahayag, sa batayan kung saan tinutukoy ang nagpapalitaw na lohika ng analyzer.

Kung ang mga kundisyon ng isa sa mga patakaran ay natutugunan para sa file na sinusuri, ito ay tinutukoy nang naaayon (halimbawa, ganito at ganoong worm). Isang simpleng halimbawa ng panuntunan upang maunawaan kung ano ang pinag-uusapan natin:

tuntunin silent_banker: banker
{
meta:
paglalarawan = "Ito ay isang halimbawa lamang"
thread_level = 3
in_the_wild = totoo
mga string:
$a = (6A 40 68 00 30 00 00 6A 14 8D 91)
$b = (8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9)
$c = "UVODFRYSIHLNWPEJXQZAKCBGMT"
kundisyon:
$a o $b o $c
}

Sa panuntunang ito, sinasabi namin sa YARA na ang anumang file na naglalaman ng hindi bababa sa isa sa mga sample na string na inilarawan sa mga variable na $a, $b, $c ay dapat na uriin bilang silent_banker trojan. At ito ay isang napaka-simpleng tuntunin. Sa katotohanan, ang mga patakaran ay maaaring maging mas kumplikado (pag-uusapan natin ito sa ibaba).
Kahit na ang listahan ng mga proyekto na gumagamit nito ay nagsasalita tungkol sa awtoridad ng proyekto ng YARA, at ito ay:

• VirusTotal Malware Intelligence Services (vt-mis.com);
• jsunpack-n (jsunpack.jeek.org);
• Pinapanood Namin ang Iyong Website (wewatchyourwebsite.com).

Ang lahat ng code ay nakasulat sa Python, at ang gumagamit ay inaalok ang parehong module mismo para sa paggamit sa kanilang pag-unlad, at simpleng isang executable na file upang magamit ang YARA bilang isang stand-alone na application. Bilang bahagi ng aking trabaho, pinili ko ang unang pagpipilian, ngunit para sa pagiging simple sa artikulong ito ay gagamitin lang namin ang analyzer bilang isang console application.

Pagkatapos ng ilang paghuhukay, mabilis kong naisip kung paano magsulat ng mga panuntunan para sa YARA, pati na rin kung paano mag-attach ng mga virus signature mula sa freeware at mga packer mula sa PEiD dito. Ngunit magsisimula kami sa pag-install.

Pag-install

Tulad ng nasabi ko na, ang proyekto ay nakasulat sa Python, kaya madali itong mai-install sa Linux, Windows, at Mac. Sa una, maaari mo lamang kunin ang binary. Kung tatawagan namin ang application sa console, makukuha namin ang mga panuntunan para sa paglulunsad.

$yara
paggamit: yara ... ... FILE | PID

Iyon ay, ang format para sa pagtawag sa programa ay ang mga sumusunod: una mayroong pangalan ng programa, pagkatapos ay isang listahan ng mga pagpipilian, pagkatapos kung saan ang file na may mga patakaran ay ipinahiwatig, at sa pinakadulo - ang pangalan ng file na napagmasdan (o ang direktoryo na naglalaman ng mga file), o ang pagkakakilanlan ng proseso. Ngayon ay nais kong ipaliwanag sa isang mahusay na paraan kung paano iginuhit ang mismong mga patakarang ito, ngunit hindi ko nais na agad na pasanin ka ng tuyong teorya. Samakatuwid, iba ang gagawin namin at hihiram kami ng mga pirma ng ibang tao para magawa ng YARA ang isa sa mga gawaing itinakda namin - isang ganap na pagtuklas ng mga virus sa pamamagitan ng mga lagda.

Ang iyong sariling antivirus

Ang pinakamahalagang tanong: saan kukuha ng signature database mga kilalang virus? Ang mga kumpanya ng antivirus ay aktibong nagbabahagi ng mga naturang database sa kanilang mga sarili (ang ilan ay mas mapagbigay, ang iba ay mas mababa). Sa totoo lang, noong una ay nag-alinlangan pa ako na sa isang lugar sa Internet ay may hayagang mag-post ng mga ganoong bagay. Ngunit, tulad ng nangyari, may mabubuting tao. Ang isang angkop na database mula sa sikat na ClamAV antivirus ay magagamit sa lahat (clamav.net/lang/en). Sa seksyong "Pinakabagong Stable na Paglabas" mahahanap mo ang isang link sa pinakabagong bersyon produkto ng antivirus, pati na rin ang mga link para mag-download ng mga database ng virus ng ClamAV. Pangunahing magiging interesado kami sa main.cvd (db.local.clamav.net/main.cvd) at daily.cvd (db.local.clamav.net/daily.cvd) na mga file.

Ang una ay naglalaman ng pangunahing database ng mga lagda, ang pangalawa ay naglalaman ng pinaka kumpletong database sa ngayon base na may iba't ibang mga karagdagan. Ang Daily.cvd, na naglalaman ng higit sa 100,000 malware impression, ay sapat na para sa layuning ito. Gayunpaman, ang ClamAV database ay hindi isang YARA database, kaya kailangan namin itong i-convert sa nais na format. Pero paano? Pagkatapos ng lahat, wala pa kaming alam tungkol sa alinman sa ClamAV na format o sa Yara na format. Ang problemang ito ay naayos na bago sa amin sa pamamagitan ng paghahanda ng isang maliit na script na nagko-convert sa ClamAV virus signature database sa isang hanay ng mga panuntunan ng YARA. Ang script ay tinatawag na clamav_to_yara.py at isinulat ni Matthew Richard (bit.ly/ij5HVs). I-download ang script at i-convert ang mga database:

$ python clamav_to_yara.py -f daily.cvd -o clamav.yara

Bilang resulta, sa clamav.yara file makakatanggap kami ng isang signature database na kaagad na handang gamitin. Subukan natin ngayon ang kumbinasyon ng YARA at ang ClamAV database na gumagana. Ang pag-scan ng isang folder gamit ang isang pirma ay isinasagawa sa isang solong utos:

$ yara -r clamav.yara /pentest/msf3/data

Ang -r na opsyon ay tumutukoy na ang pag-scan ay dapat na isagawa nang recursive sa lahat ng mga subfolder ng kasalukuyang folder. Kung mayroong anumang mga katawan ng virus sa folder na /pentest/msf3/data (kahit man lang ang mga nasa database ng ClamAV), agad itong iuulat ng YARA. Sa prinsipyo, ito ay isang ready-made signature scanner. Para sa higit na kaginhawahan, nagsulat ako ng isang simpleng script na nagsuri ng mga update sa database ng ClamAV, nag-download ng mga bagong lagda at na-convert ang mga ito sa format na YARA. Ngunit ito ay mga detalye na. Nakumpleto ang isang bahagi ng gawain, maaari ka na ngayong magsimulang gumuhit ng mga panuntunan para sa pagtukoy ng mga packer/cryptor. Ngunit para magawa ito kailangan kong harapin sila ng kaunti.

Maglaro ayon sa mga patakaran

Kaya, ang isang panuntunan ay ang pangunahing mekanismo ng isang programa na nagbibigay-daan sa iyong pag-uri-uriin ang isang naibigay na file sa isang kategorya. Ang mga patakaran ay inilarawan sa isang hiwalay na file (o mga file) at sa hitsura ay halos kapareho sa struct() na pagbuo mula sa C/C++ na wika.

mamuno sa BadBoy
{
mga string:
$a = "win.exe"
$b = "http://foo.com/badfi le1.exe"
$c = "http://bar.com/badfi le2.exe"
kundisyon:
$a at ($b o $c)
}

Sa prinsipyo, walang kumplikado sa pagsulat ng mga patakaran. Sa artikulong ito, hinawakan ko lamang ang mga pangunahing punto, at makikita mo ang mga detalye sa manwal. Sa ngayon, ang sampung pinakamahalagang punto:

1. Nagsisimula ang bawat panuntunan sa panuntunan ng keyword, na sinusundan ng identifier ng panuntunan. Ang mga identifier ay maaaring magkaroon ng parehong mga pangalan tulad ng mga variable sa C/C++, iyon ay, maaari silang binubuo ng mga titik at numero, at ang unang character ay hindi maaaring isang numero. Ang maximum na haba ng pangalan ng identifier ay 128 character.

2. Karaniwan, ang mga panuntunan ay binubuo ng dalawang seksyon: isang seksyon ng kahulugan (mga string) at isang seksyon ng kundisyon (kondisyon). Ang seksyon ng mga string ay tumutukoy sa data sa batayan kung saan ang seksyon ng kundisyon ay magpapasya kung ang isang naibigay na file ay nakakatugon sa ilang mga kundisyon.

3. Ang bawat linya sa seksyon ng mga string ay may sariling identifier, na nagsisimula sa $ sign - sa pangkalahatan, tulad ng variable na deklarasyon sa PHP. Sinusuportahan ng YARA ang mga regular na string na nakapaloob dobleng panipi("") at hexadecimal string na nakapaloob sa mga kulot na brace (()), pati na rin ang mga regular na expression:

$my_text_string = "text dito"
$my_hex_string = ( E2 34 A1 C8 23 FB )

4. Ang seksyon ng kundisyon ay naglalaman ng lahat ng lohika ng panuntunan. Ang seksyong ito ay dapat maglaman ng isang Boolean na expression na tumutukoy kung ang isang file o proseso ay tumutugma sa panuntunan. Karaniwan, ang seksyong ito ay tumutukoy sa mga naunang ipinahayag na mga linya. At ang string identifier ay itinuturing bilang isang boolean variable na nagbabalik ng true kung ang string ay natagpuan sa file o memorya ng proseso, at false kung hindi. Tinutukoy ng panuntunan sa itaas na ang mga file at prosesong naglalaman ng string win.exe at isa sa dalawang URL ay dapat na uriin bilang BadBoy (sa pangalan ng panuntunan).

5. Binibigyang-daan ng mga hexadecimal string ang tatlong construct na ginagawang mas flexible ang mga ito: mga wildcard, jump, at alternatibo. Ang mga pamalit ay mga lugar sa isang string na hindi alam at maaaring palitan ng anumang halaga. Ang mga ito ay ipinahiwatig ng simbolo na "?":

$hex_string = ( E2 34 ?? C8 A? FB )

Ang diskarte na ito ay napaka-maginhawa kapag tinutukoy ang mga string na alam ang haba, ngunit maaaring mag-iba ang nilalaman. Kung ang bahagi ng isang string ay maaaring may iba't ibang haba, maginhawang gumamit ng mga hanay:

$hex_string = ( F4 23 62 B4 )

Ang entry na ito ay nangangahulugan na sa gitna ng linya ay maaaring mayroong mula 4 hanggang 6 na magkakaibang byte. Maaari ka ring magpatupad ng alternatibong pagpipilian:

$hex_string = ( F4 23 (62 B4 | 56) 45 )

Nangangahulugan ito na sa lugar ng ikatlong byte ay maaaring mayroong 62 B4 o 56, ang naturang entry ay tumutugma sa mga linyang F42362B445 o F4235645.

6. Upang suriin kung ano binigay na linya na matatagpuan sa isang partikular na offset sa file o puwang ng address ng proseso, ang at operator ay ginagamit:

$a sa 100 at $b sa 200

Kung ang string ay maaaring nasa loob ng isang tiyak na hanay ng address, ang in operator ay ginagamit:

$a sa (0..100) at $b sa (100..fi lesize)

Minsan lumitaw ang mga sitwasyon kapag kailangan mong tukuyin na ang isang file ay dapat maglaman ng isang tiyak na numero mula sa isang naibigay na hanay. Ginagawa ito gamit ang ng operator:

panuntunan NgHalimbawa1
{
mga string:
$foo1 = "dummy1"
$foo2 = "dummy2"
$foo3 = "dummy3"
kundisyon:
2 ng ($foo1,$foo2,$foo3)
}

Ang panuntunan sa itaas ay nangangailangan na ang file ay naglalaman ng anumang dalawang linya mula sa set ($foo1,$foo2,$foo3). Sa halip na tukuyin ang isang tiyak na bilang ng mga linya sa file, maaari mong gamitin ang mga variable anuman (kahit isang linya mula sa isang ibinigay na hanay) at lahat (lahat ng mga linya mula sa isang ibinigay na hanay).

7. Well, ang huling kagiliw-giliw na posibilidad na kailangang isaalang-alang ay ang paglalapat ng isang kundisyon sa maraming mga hilera. Ang tampok na ito ay halos kapareho sa ng operator, tanging ang mas malakas ay ang para sa..ng operator:

para sa pagpapahayag ng string_set: (boolean_expression)

Ang entry na ito ay dapat basahin nang ganito: sa mga string na tinukoy sa string_ set, kahit man lang ang mga expression na piraso ay dapat matugunan ang boolean_expression na kundisyon. O, sa madaling salita: ang boolean_expression ay sinusuri para sa bawat string sa string_set, at ang mga expression mula sa kanila ay dapat magbalik ng True. Susunod na titingnan natin ang konstruksiyon na ito gamit ang isang tiyak na halimbawa.

Paggawa ng PEiD

Kaya, kapag ang lahat ay naging mas o hindi gaanong malinaw sa mga panuntunan, maaari tayong magsimulang magpatupad ng isang detector ng mga packer at cryptors sa ating proyekto. Noong una, bilang source material, hiniram ko ang mga pirma ng mga kilalang packer mula sa parehong PEiD. Sa folder ng mga plugin mayroong isang file userdb.txt, na naglalaman ng kung ano ang kailangan namin. Mayroong 1850 na lagda sa aking database.

Medyo marami, kaya upang ganap na ma-import ang mga ito, ipinapayo ko sa iyo na magsulat ng ilang uri ng script. Ang format ng database na ito ay simple - ang karaniwan ay ginagamit text file, na nag-iimbak ng mga tala tulad ng:

lagda = 50 E8 ?? ?? ?? ?? 58 25 ?? F0 FF FF 8B C8 83 C1 60 51 83 C0 40 83 EA 06 52 FF 20 9D C3
ep_only = totoo

Tinutukoy ng unang linya ang pangalan ng packer, na ipapakita sa PEiD, ngunit para sa amin ito ang magiging rule identifier. Ang pangalawa ay ang pirma mismo. Ang pangatlo ay ang ep_only na flag, na nagsasaad kung maghahanap lang ng isang linya sa entry point address, o sa buong file.

Well, subukan nating lumikha ng isang panuntunan, sabihin, para sa ASPack? Tulad ng lumalabas, walang kumplikado tungkol dito. Una, gumawa tayo ng file para iimbak ang mga panuntunan at tawagan ito, halimbawa, packers.yara. Pagkatapos ay hinahanap namin ang database ng PEiD para sa lahat ng mga lagda na kasama ang ASPack sa kanilang mga pangalan at inilipat ang mga ito sa panuntunan:

tuntunin ang ASPack
{
mga string:
$ = ( 60 E8 ??? ?? ?? 5D 81 ED ?? ?? (43 | 44) ?? B8 ?? ?? (43 | 44) ?? 03 C5 )
$ = ( 60 EB ?? 5D EB ?? FF ?? ?? ?? ?? ?? E9 )
[.. cut..]
$ = ( 60 E8 03 00 00 00 E9 EB 04 5D 45 55 C3 E8 01 )
kundisyon:
para sa alinman sa kanila: ($at entrypoint)
}

Lahat ng nahanap na tala ay may ep_only na flag na nakatakda sa true, ibig sabihin, ang mga linyang ito ay dapat na matatagpuan sa entry point address. Samakatuwid, isinusulat namin ang sumusunod na kondisyon: "para sa alinman sa kanila: ($at entrypoint)".

Kaya, ang pagkakaroon ng hindi bababa sa isa sa mga ibinigay na linya sa address ng entry point ay nangangahulugan na ang file ay puno ng ASPack. Pakitandaan din na sa panuntunang ito ang lahat ng mga string ay tinukoy lamang gamit ang $ sign, nang walang isang identifier. Posible ito dahil sa seksyon ng kundisyon hindi namin naa-access ang anumang partikular na mga, ngunit ginagamit ang buong hanay.

Upang suriin ang pag-andar ng nagresultang system, patakbuhin lamang ang command sa console:

$ yara -r packers.yara somefi le.exe

Ang pagkakaroon ng feed ng ilang mga application na nakabalot sa ASPack doon, ako ay kumbinsido na ang lahat ay gumana!

Handa nang prototype

Ang YARA ay naging isang napakalinaw at transparent na tool. Hindi naging mahirap para sa akin na magsulat ng isang webadmin para dito at i-set up ito upang gumana bilang isang serbisyo sa web. Sa kaunting pagkamalikhain, ang mga tuyong resulta ng analyzer ay may kulay na sa iba't ibang kulay, na nagpapahiwatig ng antas ng panganib ng nakitang malware. Ang isang maliit na pag-update ng database, at para sa marami sa mga cryptors isang maikling paglalarawan ay magagamit, at kung minsan kahit na i-unpack ang mga tagubilin. Ang prototype ay nilikha at gumagana nang perpekto, at ang mga boss ay sumasayaw sa tuwa!

Ang konsepto" Magic number"sa programming ay may tatlong kahulugan:

• Lagda ng data
• Mga napiling natatanging halaga na hindi dapat kapareho ng iba pang mga halaga (tulad ng UUID)
• Masamang kasanayan sa programming.

Lagda ng data

Magic number, o pirma, - isang integer o text constant na ginagamit upang natatanging tukuyin ang isang mapagkukunan o data. Ang nasabing numero mismo ay walang anumang kahulugan at maaaring magdulot ng pagkalito kung ito ay lilitaw sa program code nang walang naaangkop na konteksto o komento, habang ang isang pagtatangka na baguhin ito sa isa pa, kahit na isang malapit sa halaga, ay maaaring humantong sa ganap na hindi mahuhulaan na mga kahihinatnan. Para sa kadahilanang ito, ang mga naturang numero ay ironically na tinatawag na magic number. Sa kasalukuyan, matatag na itinatag ang pangalang ito bilang isang termino. Halimbawa, ang anumang pinagsama-samang klase ng wikang Java ay nagsisimula sa hexadecimal na "magic number" na 0xCAFEBABE. Ang pangalawang malawak na kilalang halimbawa ay ang anumang OS executable file Microsoft Windows na may extension na .exe ay nagsisimula sa byte sequence na 0x4D5A (na tumutugma sa mga ASCII na character na MZ - ang mga inisyal ni Mark Zbikowski, isa sa mga tagalikha ng MS-DOS). Ang isang hindi gaanong kilalang halimbawa ay ang uninitialized pointer sa Microsoft Visual C++ (mula noong 2005 Mga bersyon ng Microsoft Visual Studio), na nasa debug mode ay may address na 0xDEADBEEF .

Parang UNIX mga operating system Ang uri ng file ay karaniwang tinutukoy ng file signature, anuman ang extension ng pangalan nito. Nagbibigay sila ng isang karaniwang file utility upang bigyang-kahulugan ang file signature.

Masamang kasanayan sa programming

Ang "magic number" ay tumutukoy din sa mga masasamang kasanayan sa programming kapag may naganap na numeric na value sa source text at hindi malinaw kung ano ang ibig sabihin nito. Halimbawa, ang isang snippet na tulad nito, na nakasulat sa Java, ay magiging masama:

drawSprite(53, 320, 240);

final int SCREEN_WIDTH = 640 ;

final int SCREEN_HEIGHT = 480 ;

final int SCREEN_X_CENTER = SCREEN_WIDTH / 2 ;

• final int SCREEN_Y_CENTER = SCREEN_HEIGHT / 2 ;
• final int SPRITE_CROSSHAIR = 53 ;
• ... drawSprite(SPRITE_CROSSHAIR, SCREEN_X_CENTER, SCREEN_Y_CENTER);
• Ngayon ay malinaw na: ang linyang ito ay nagpapakita ng sprite - ang crosshair ng paningin - sa gitna ng screen. Sa karamihan ng mga wika ng programming, ang lahat ng mga halaga na ginagamit para sa naturang mga constant ay kakalkulahin sa oras ng pag-compile at papalitan sa mga lugar kung saan ginagamit ang mga halaga. Samakatuwid, ang gayong pagbabago sa pinagmulang teksto ay hindi nagpapababa sa pagganap ng programa.

Bilang karagdagan, ang mga magic number ay isang potensyal na mapagkukunan ng mga error sa isang programa:

Minsan ang mga magic number ay nakakapinsala sa cross-platform code. Ang katotohanan ay na sa C, sa 32- at 64-bit na mga operating system, ang laki ng char , maikli at mahabang mahabang uri ay ginagarantiyahan, habang ang laki ng int , long , size_t at ptrdiff_t ay maaaring magbago (para sa unang dalawa, depende sa mga kagustuhan ng mga developer ng compiler , para sa huling dalawa - depende sa bit na kapasidad ng target na sistema). Sa luma o hindi magandang nakasulat na code, maaaring may mga "magic number" na nagpapahiwatig ng laki ng isang uri - kapag lumipat sa mga makina na may ibang bit capacity, maaari silang humantong sa mga banayad na error.

Halimbawa:

const size_t NUMBER_OF_ELEMENTS = 10 ; mahaba ang isang[NUMBER_OF_ELEMENTS]; memset(a, 0, 10 * 4); // hindi tama - ang haba ay ipinapalagay na 4 byte, ginamit ang magic number ng mga elemento memset(a, 0, NUMBER_OF_ELEMENTS * 4); // hindi tama - ang haba ay ipinapalagay na 4 bytes memset(a, 0, NUMBER_OF_ELEMENTS * sizeof(long)); // hindi ganap na tama - pagdoble ng pangalan ng uri (kung magbago ang uri, kailangan mo ring baguhin ito dito) memset (a , 0 , NUMBER_OF_ELEMENTS * sizeof (a [ 0 ])); // tama, pinakamainam para sa mga dynamic na array na hindi zero ang laki

memset(a, 0, sizeof(a));

// tama, pinakamainam para sa mga static na array