Creazione di un tipo di file noto personalizzato per R-Studio. Determinare un tipo di file tramite firma Che cos'è una firma di file
Il concetto " Numero magico"nella programmazione ha tre significati:
- Firma dei dati
- Selezionato valori unici, che non dovrebbe essere uguale ad altri valori (es. UUID)
- Cattiva pratica di programmazione.
Firma dei dati
Numero magico, O firma, - un numero intero o una costante di testo utilizzata per identificare in modo univoco una risorsa o dati. Un tale numero di per sé non ha alcun significato e può creare confusione se appare nel codice del programma senza il contesto o il commento appropriato, mentre un tentativo di cambiarlo con un altro, anche vicino al valore, può portare a conseguenze del tutto imprevedibili. Per questo motivo tali numeri venivano ironicamente chiamati numeri magici. Attualmente, questo nome è saldamente stabilito come termine. Ad esempio, qualsiasi classe compilata del linguaggio Java inizia con il "numero magico" esadecimale 0xCAFEBABE. Il secondo esempio ampiamente noto è qualsiasi file eseguibile sistema operativo Microsoft Windows con l'estensione .exe inizia con la sequenza di byte 0x4D5A (che corrisponde ai caratteri ASCII MZ - le iniziali di Mark Zbikowski, uno dei creatori di MS-DOS). Un esempio meno noto è il puntatore non inizializzato in Microsoft Visual C++ (a partire dalla versione 2005 di Microsoft Visual Studio), che ha l'indirizzo 0xDEADBEEF in modalità debug.
In stile UNIX sistemi operativi Il tipo di file è solitamente determinato dalla firma del file, indipendentemente dall'estensione del suo nome. Forniscono un'utilità di file standard per interpretare la firma del file.
Cattiva pratica di programmazione
Chiamati anche “numeri magici” sono una cattiva pratica di programmazione quando nel testo di origine è presente un valore numerico e non è ovvio cosa significhi. Ad esempio, uno snippet come questo, scritto in Java, sarebbe dannoso:
drawSprite(53, 320, 240);
finale int LARGHEZZA_SCREEN = 640; finale int SCREEN_HEIGHT = 480; final int SCREEN_X_CENTER = SCREEN_WIDTH / 2; final int SCHERMO_Y_CENTRO = SCHERMO_ALTEZZA / 2; finale int SPRITE_CROSSHAIR = 53; ... drawSprite(SPRITE_CROSSHAIR, SCREEN_X_CENTER, SCREEN_Y_CENTER);
Ora è chiaro: questa linea mostra uno sprite - il mirino del mirino - al centro dello schermo. Nella maggior parte dei linguaggi di programmazione, tutti i valori utilizzati per tali costanti verranno calcolati in fase di compilazione e sostituiti nei punti in cui vengono utilizzati i valori. Pertanto, tale modifica nel testo di origine non compromette le prestazioni del programma.
Inoltre, i numeri magici sono una potenziale fonte di errori in un programma:
- Se lo stesso numero magico viene utilizzato più di una volta in un programma (o potrebbe essere potenzialmente utilizzato), la sua modifica richiederà modifiche a ciascuna occorrenza (invece di una sola modifica al valore della costante denominata). Se non tutte le occorrenze vengono corrette, si verificherà almeno un errore.
- In almeno uno dei casi, inizialmente il numero magico potrebbe essere scritto in modo errato e ciò è piuttosto difficile da rilevare.
- Il numero magico può dipendere da un parametro implicito o da un altro numero magico. Se queste dipendenze, non identificate esplicitamente, non vengono soddisfatte, si verificherà almeno un errore.
- Quando si modificano le occorrenze di un numero magico, è possibile modificare erroneamente un altro numero magico indipendente ma con lo stesso valore numerico.
Numeri magici e multipiattaforma
A volte i numeri magici danneggiano il codice multipiattaforma. Il fatto è che in C, sui sistemi operativi a 32 e 64 bit, la dimensione dei tipi char , short e long long è garantita, mentre la dimensione di int , long , size_t e ptrdiff_t può cambiare (per i primi due, a seconda delle preferenze degli sviluppatori del compilatore, per gli ultimi due - a seconda della capacità in bit del sistema di destinazione). Nel codice vecchio o scritto male, potrebbero esserci dei "numeri magici" che indicano la dimensione di un tipo: quando si passa a macchine con una capacità di bit diversa, possono portare a sottili errori.
Per esempio:
const dimensione_t NUMERO_DI_ELEMENTI = 10; lungo un[NUMBER_OF_ELEMENTI]; memset(a, 0, 10 * 4); // errato: si presuppone che long sia 4 byte, viene utilizzato il numero magico di elementi memset(a, 0, NUMERO_DI_ELEMENTI * 4); // errato: si presuppone che long sia 4 byte memset(a, 0, NUMBER_OF_ELEMENTI * dimensione(lungo)); // non del tutto corretto - duplicazione del nome del tipo (se il tipo cambia, dovrai cambiarlo anche qui) memset (a, 0, NUMERO_DI_ELEMENTI * sizeof (a [0])); // corretto, ottimale per array dinamici di dimensione diversa da zero memset(a, 0, dimensione(a)); // corretto, ottimale per array statici
Numeri che non sono magici
Non tutti i numeri devono essere convertiti in costanti. Ad esempio, il codice per
La ricerca tramite scansione di file di tipo noto (o, come spesso si dice, la ricerca di file per firma) è una delle modalità più efficaci utilizzate nell'utilità di recupero dati R-Studio. L'utilizzo di una determinata firma consente di ripristinare file di un certo tipo nei casi in cui le informazioni sulla struttura delle directory e sui nomi dei file sono parzialmente o completamente mancanti (danneggiate).
In genere, la tabella delle partizioni del disco viene utilizzata per determinare la posizione dei file. Se confronti un disco con un libro, la tabella delle partizioni sarà simile al suo sommario. Durante la scansione, R-Studio ricerca i tipi di file conosciuti nella tabella delle partizioni del disco utilizzando determinate firme specificate. Ciò è reso possibile dal fatto che praticamente ogni tipo di file ha una firma o un modello di dati univoci. Le firme dei file si trovano in una posizione specifica all'inizio del file e in molti casi anche alla fine del file. Durante la scansione, R-Studio abbina i dati trovati con le firme dei tipi di file conosciuti, consentendone l'identificazione e il recupero dei dati.
Utilizzando la tecnologia per la scansione dei tipi di file conosciuti, R-Studio consente di recuperare dati da dischi che sono stati riformattati e le cui tabelle delle partizioni sono state sovrascritte. Inoltre, se una partizione del disco viene sovrascritta, danneggiata o eliminata, l'unica opzione possibile è la scansione dei tipi di file conosciuti.
Ma quasi tutto ha i suoi svantaggi e i tipi di file conosciuti utilizzati in R-Studio non fanno eccezione. Pertanto, durante la scansione di tipi di file conosciuti, R-Studio consente di recuperare solo file non frammentati ma, come già accennato, nella maggior parte dei casi questo è il metodo più recente possibile.
R-Studio include già le firme dei tipi di file più comuni (view lista completa i file di tipi conosciuti sono reperibili nella sezione Guida in linea di R-Studio.)
Se necessario, l'utente può aggiungere nuovi tipi di file a R-Studio. Ad esempio, se hai bisogno di trovare file di un tipo univoco o quelli sviluppati dopo l'ultima data di rilascio di R-Studio, puoi aggiungere le tue firme ai file di tipi conosciuti. Questo processo verrà discusso in seguito.
File personalizzati di tipi noti
Le firme dei file personalizzati dei tipi di file conosciuti vengono archiviate in FileXML e specificato nella finestra di dialogo Impostazioni. L'aggiunta di una firma è composta da due parti:
- Determinazione della firma del file posta all'inizio del file e, se presente, alla fine del file.
- Genera un file XML contenente una firma del file e altre informazioni sul tipo di file.
Tutto questo può essere fatto utilizzando R-Studio. Allo stesso tempo, non è necessario essere un esperto nel campo della composizione (modifica) di documenti XML o nel campo dell'editing esadecimale - in questa guida (articolo), che si rivolge all'utente stesso livello base, tutte le fasi di questo processo saranno discusse in dettaglio.
Esempio: aggiunta di una firma per un file MP4 (XDCam-EX Codec)
Diamo un'occhiata all'aggiunta di una firma file utilizzando l'esempio di un file .MP4 creato utilizzando Sony XDCAM-EX. Puoi usarlo, ad esempio, in caso di danneggiamento della scheda SD per file che non sei ancora riuscito a salvare sul disco rigido del tuo computer.
Prima fase: determinazione della firma del file
Per determinare la firma del file, considera esempi di file dello stesso formato.
Lascia che questi siano quattro file video di Sony XDCAM-EX:
ZRV-3364_01.MP4
ZRV-3365_01.MP4
ZRV-3366_01.MP4
ZRV-3367_01.MP4
Per comodità di considerazione, lasciamo che questi siano file di piccole dimensioni. I file più grandi sono più difficili da visualizzare in formato esadecimale.
1. Aprire i file in R-Studio. Per fare ciò, fare clic con il tasto destro su ciascun file e selezionare Visualizza/Modifica dal menu contestuale.
2. Confrontiamo i file. Cercheremo lo stesso modello trovato in tutti e quattro i file. Apparirà firma del file. In genere, le firme dei file si trovano all'inizio del file, ma a volte alla fine.
3. Definire la firma del file all'inizio del file. Nel nostro esempio, si trova all'inizio del file. Tieni presente che ciò non accade sempre: spesso la firma del file si trova all'inizio del file, ma non alla prima riga (offset).
Dalle immagini sottostanti, sembra che i contenuti di tutti e quattro i file siano diversi, ma iniziano tutti con la stessa firma del file. 
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
L'area evidenziata nelle immagini è la firma di un file di questo tipo File. È presentato sia in formato testo che esadecimale.
In formato testo, la firma del file è simile alla seguente:
....ftypmp42....mp42........gratuito
I punti (“.”) indicano caratteri che non possono essere rappresentati in forma di testo. Pertanto è necessario fornire anche la forma esadecimale della firma del file:
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. Allo stesso modo definiamo la firma del file, ma alla fine del file. Potrebbe trattarsi di una firma di file diversa, di una lunghezza diversa.
Le immagini seguenti evidenziano la firma del file alla fine del file: 
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Tieni presente che i dati prima dell'area selezionata (firma del file) sono gli stessi in tutti e quattro i file. Si tratta di informazioni tecniche che non costituiscono una firma del file, ma indicano che tutte e quattro le immagini (file) sono state scattate utilizzando la stessa fotocamera con gli stessi parametri. Di solito è possibile distinguere i modelli di corrispondenza con le informazioni tecniche dalla firma di un file. Nel nostro esempio, nell'ultima riga prima dell'inizio della firma del file, vediamo il testo "RecordingMode type="normal"", che indica chiaramente che si tratta di una sorta di parametro del file e non di una firma. Prestare sempre particolare attenzione a questa riga per non includerla erroneamente informazioni tecniche parte della firma del file.
Nel nostro caso, la firma del file è il seguente testo:
...
Ricordiamo che i punti indicano caratteri che non possono essere rappresentati in forma testuale.
In esadecimale, la firma del file è simile alla seguente:
3N 2F 4E 6F 6E 52 65 61 6N 54 69 6A 65 4A 65 74 61 3E 0D 0A 00
Nota: la firma non sarà sempre alla fine del file.
Seconda fase: creazione di un file XML che descrive un tipo di file noto
Ora, dopo aver definito la firma del file, è possibile creare un file XML e includere il tipo di file corrispondente in R-Studio. Questo può essere fatto in due modi:
2.1 Utilizzo del built-in redattore grafico firme dei file:
Seleziona la voce Impostazioni dal menu Strumenti, nella finestra di dialogo Impostazioni che si apre, fai clic sulla scheda Tipi di file conosciuti e quindi sul pulsante Modifica tipi di file dell'utente. 
Clicca sull'immagine per ingrandirla
Fare clic sul pulsante Crea tipo di file nella finestra di dialogo Modifica tipi di file dell'utente.
Imposta le seguenti opzioni:
- Id: un identificatore digitale univoco. Questo numero sarà scelto in modo casuale; L'unica cosa è che non dovrebbe corrispondere all'identificatore digitale di nessun altro tipo di file.
- Descrizione gruppo: il gruppo in cui verranno posizionati i file trovati in R-Studio. Puoi impostarli entrambi nuovo gruppo, oppure scegline uno tra quelli già esistenti. Per noi questo sarà il gruppo “Video multimediale (Multimedia: Video)”.
- Descrizione - breve descrizione tipo di file. Nel nostro esempio è possibile utilizzare ad esempio "Sony cam video, XDCam-EX".
- Estensione: estensione di file di questo tipo. Nel nostro caso - mp4.
Il parametro Features è facoltativo, nel nostro caso non è necessario utilizzarlo. 
Clicca sull'immagine per ingrandirla
Successivamente, è necessario inserire la firma del file iniziale e finale. Per fare ciò, seleziona Inizia e poi menù contestuale il comando Aggiungi firma. 
Clicca sull'immagine per ingrandirla
Quindi fare doppio clic sul campo<пустая сигнатура> (
Clicca sull'immagine per ingrandirla
Quindi crea la firma del file finale. Assicurati di inserire 21 nella colonna Da. 
Clicca sull'immagine per ingrandirla
Hai creato con successo la tua firma per i tipi di file conosciuti.
Ora devi salvarlo. Esistono due modi: puoi salvarlo nel file predefinito specificato nella scheda Principale della finestra di dialogo Impostazioni facendo clic sul pulsante Salva. Oppure fai clic sul pulsante Salva con nome... e salva la firma in un altro file.
2.2 Creazione manuale di un file XML che descrive un tipo di file noto:
Per creare questa vita Usiamo XML versione 1.0 e la codifica UTF-8. Non disperare se non sai di cosa si tratta: aprine semplicemente uno qualsiasi editor di testo(ad esempio, Notepad.exe) e inserisci il seguente testo nella prima riga:
Successivamente creeremo un tag XML che definisce il tipo di file (FileType). Tenendo conto degli attributi XML precedentemente descritti, il tag sarà simile a questo:
Inseriamolo subito dopo
Successivamente, definiamo la firma del file (tag
Se presente è necessario definire anche la firma finale (alla fine del file). Utilizza lo stesso tag, ma con un elemento "from" e un attributo "end". Apparirà così:
Ricorda che la firma del file finale non conteneva caratteri non di testo, ma conteneva barre e parentesi triangolari. Per evitare confusione ed errori nella sintassi XML, sostituiremo i caratteri "/", " nella firma<" и ">" i loro valori esadecimali.
Alla fine, dopo le firme dei file, devono esserci i tag di chiusura FileType e FileTypeList:
Quindi l'intero file dovrebbe assomigliare a questo:
Ricorda: la sintassi XML fa distinzione tra maiuscole e minuscole, quindi sarebbe il tag corretto
Salviamo il file in formato testo con estensione .xml. Ad esempio: SonyCam.xml.
Abbiamo creato con successo la nostra firma per i tipi di file conosciuti. Questo esempio è abbastanza sufficiente per comprendere i principi di base della creazione di un tipo di file personalizzato. Gli utenti più esperti possono utilizzare la versione XML 2.0. È possibile leggere ulteriori informazioni al riguardo nella sezione della Guida in linea di R-Studio.
Passaggio 3: controllo e aggiunta di un file che descrive un tipo di file noto
Il passaggio successivo consiste nell'aggiungere (caricare) il file XML in R-Studio. In questo caso, verrà controllato automaticamente.
Carichiamo in R-Studio il file XML creato nella fase precedente. Per fare ciò, seleziona la voce Impostazioni nel menu Strumenti. Nell'area Tipi di file utente della scheda Principale della finestra di dialogo Impostazioni, aggiungi il file XML che abbiamo creato (SonyCam.xml). Fare clic sul pulsante Applica. 
Clicca sull'immagine per ingrandirla
2. Rispondere Sì alla richiesta di scaricare un nuovo tipo di file. 
Clicca sull'immagine per ingrandirla
3. Per verificare che il tipo di file sia stato caricato correttamente, fare clic sulla scheda Tipi di file conosciuti della finestra di dialogo Impostazioni. Ricorda che abbiamo aggiunto il tipo di file al gruppo Video multimediale (Multimedia: Video). Dopo aver espanso questo gruppo (cartella), dovremmo vedere un elemento con la descrizione che abbiamo specificato durante la creazione del file XML: Sony cam video, XDCam-EX (.mp4). 
Clicca sull'immagine per ingrandirla
Clicca sull'immagine per ingrandirla
Se sono presenti errori nella sintassi del file, verrà visualizzato il messaggio corrispondente: 
Clicca sull'immagine per ingrandirla
In questo caso, controlla nuovamente la presenza di errori nel file XML. Ricorda: la sintassi XML fa distinzione tra maiuscole e minuscole e ogni tag deve avere un tag di chiusura alla fine.
Passaggio 4: test del file che descrive un tipo di file noto
Per verificare la correttezza del tipo di file personalizzato che abbiamo creato, proviamo a trovare i nostri file .mp4 su un'unità flash USB rimovibile.
1. In Windows Vista o Windows 7, eseguire una formattazione completa (non rapida) del disco o utilizzare un'utilità di pulizia dello spazio su disco (ad esempio, R-Wipe & Clean) per rimozione completa tutti i dati disponibili sul disco. Permettere Disco USB formattato in FAT32 (la dimensione dei file cercati non supera i 2 GB).
2. Copiamolo file di prova su disco e riavviare il computer in modo che il contenuto della memoria cache venga salvato su disco. Puoi anche disabilitare unità esterna e poi collegarlo di nuovo.
3. Nell'OS l'unità verrà definita ad es. unità logica F:\.
4. Avviamo R-Studio. Seleziona la nostra unità (F:\) e fai clic sul pulsante Scansione 
Clicca sull'immagine per ingrandirla
5. Nella finestra di dialogo Scansione, nell'area (File System), fare clic sul pulsante Cambia... e deselezionare tutte le caselle. In questo modo disabiliteremo la ricerca di file system e file utilizzando la tabella delle partizioni. 
Clicca sull'immagine per ingrandirla
6. Selezionare la casella di controllo Ricerca aggiuntiva per tipi di file conosciuti. Ciò consentirà a R-Studio di cercare tipi di file conosciuti durante la scansione.
7. Per avviare la scansione, fare clic sul pulsante Scansione.
8. Aspettiamo mentre R-Studio esegue la scansione del disco. La scheda Informazioni sulla scansione visualizzerà l'avanzamento della scansione (avanzamento). 
Clicca sull'immagine per ingrandirla
9. Una volta completata la scansione, selezionare l'elemento File extra trovati e fare doppio clic su di esso. 
Clicca sull'immagine per ingrandirla
10. I nostri file di test si troveranno nella cartella Sony Cam Video, XDCam-EX (o in una cartella con un altro nome corrispondente alla descrizione del tipo di file specificata nella seconda fase). 
Clicca sull'immagine per ingrandirla
Vedi che i nomi dei file, le date e le posizioni (cartelle) non sono stati ripristinati perché questa informazione memorizzati nel file system. Pertanto, R-Studio visualizzerà automaticamente ciascun file con un nuovo nome.
Tuttavia, è chiaro che il contenuto dei file non è danneggiato. Per verificarlo apriamoli nel programma apposito, ad esempio VLC media player. 
Clicca sull'immagine per ingrandirla
Conclusione
La capacità di R-Studio di eseguire la scansione dei tipi di file conosciuti consente di recuperare i dati anche da un disco i cui file system sono stati sovrascritti. Puoi cercare i file in modo abbastanza efficace utilizzando le loro firme, il che è particolarmente utile se conosci esattamente il tipo di file da ripristinare, come nel nostro esempio. La possibilità di creare tipi di file personalizzati consente di aggiungere qualsiasi file con una firma di file specifica all'elenco dei tipi di file conosciuti.
Molti potrebbero aver sentito parlare di file come rarjpeg. Questo è un tipo speciale di file, che è un'immagine jpeg e un archivio rar incollati insieme strettamente. È un eccellente contenitore per nascondere il fatto di trasmettere informazioni. Puoi creare un rarjpeg usando i seguenti comandi:
UNIX: gatto immagine1.jpg archivio.rar > immagine2.jpg
FINESTRE: copia /b immagine1.jpg+archivio.rar immagine2.jpg
O se hai un editor esadecimale.
Naturalmente, per nascondere il fatto di trasmettere informazioni, puoi utilizzare non solo il formato JPEG, ma anche molti altri. Ogni formato ha le sue caratteristiche, per cui può essere adatto o meno al ruolo di contenitore. Descriverò come trovare i file incollati nei formati più diffusi o indicherò il fatto di incollarli.
I metodi per rilevare i file uniti possono essere suddivisi in tre gruppi:
- Metodo per controllare l'area dopo il segnalino EOF. Molti formati di file popolari dispongono di un cosiddetto indicatore di fine file, che è responsabile della visualizzazione dei dati desiderati. Ad esempio, i visualizzatori di foto leggono tutti i byte fino a questo indicatore, ma l'area successiva viene ignorata. Questo metodo è ideale per i seguenti formati: JPEG, PNG, GIF, ZIP, RAR, PDF.
- Metodo per controllare la dimensione del file. La struttura di alcuni formati (contenitori audio e video) consente di calcolare la dimensione effettiva del file e confrontarla con la dimensione originale. Formati: AVI, WAV, MP4, MOV.
- Metodo per controllare i file CFB. CFB o Compound File Binary Format è un formato di documento sviluppato da Microsoft, che è un contenitore con un proprio file system. Questo metodo si basa sul rilevamento di anomalie in un file.
C'è vita dopo la fine di un file?
JPEG
Per trovare la risposta a questa domanda è necessario approfondire le specifiche del formato, che è il “antenato” dei file uniti e comprenderne la struttura. Qualsiasi JPEG inizia con la firma 0xFF 0xD8.Dopo questa firma ci sono le informazioni sul servizio, facoltativamente un'icona dell'immagine e, infine, l'immagine compressa stessa. In questo formato, la fine dell'immagine è contrassegnata con una firma a due byte 0xFF 0xD9.
PNG
I primi otto byte del file PNG sono occupati dalla seguente firma: 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A. Firma finale che termina il flusso di dati: 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82.RARO
Firma comune per tutti gli archivi rar: 0x52 0x61 0x72 0x21 (Rar!). Dopo vengono le informazioni sulla versione dell'archivio e altri dati correlati. È stato sperimentalmente determinato che l'archivio termina con la firma 0x0A, 0x25, 0x25, 0x45, 0x4F, 0x46.Tabella dei formati e delle relative firme:
L'algoritmo per il controllo dell'incollaggio in questi formati è estremamente semplice:
- Trova la firma iniziale;
- Trova la firma finale;
- Se non ci sono dati dopo la firma finale, il tuo file è pulito e non contiene allegati! Altrimenti è necessario cercare altri formati dopo la firma finale.
GIF e PDF
Un documento PDF può avere più di un indicatore EOF, ad esempio a causa di una generazione errata del documento. Il numero di firme finali in un file GIF è uguale al numero di fotogrammi in esso contenuti. In base alle caratteristiche di questi formati è possibile migliorare l'algoritmo per verificare la presenza dei file allegati.- Il punto 1 viene ripetuto dall'algoritmo precedente.
- Il punto 2 viene ripetuto dall'algoritmo precedente.
- Quando trovi la firma finale, ricorda la sua posizione e guarda oltre;
- Se raggiungi l'ultimo marcatore EOF in questo modo, il file è pulito.
- Se il file non termina con una segnatura finale, vai a è la posizione dell'ultima segnatura finale trovata.
cerniera lampo
La particolarità degli archivi ZIP è la presenza di tre diverse firme: La struttura dell'archivio è la seguente:| Intestazione file locale 1 |
| Dati dell'archivio 1 |
| Descrittore dei dati 1 |
| Intestazione file locale 2 |
| Dati dell'archivio 2 |
| Descrittore dei dati 2 |
| ... |
| Intestazione file locale |
| Dati del File n |
| Descrittore dei dati n |
| Intestazione di decrittografia dell'archivio |
| Archivia record di dati aggiuntivi |
| Elenco centrale |
Per controllare un archivio ZIP è necessario trovare la firma finale della directory centrale, saltare 18 byte e cercare le firme dei formati conosciuti nell'area dei commenti. Grande taglia Il commento indica anche il fatto dell'incollaggio.
La dimensione conta
AVI
La struttura di un file AVI è la seguente: ogni file inizia con una firma RIFF (0x52 0x49 0x46 0x46). Sul byte 8 c'è una firma AVI che specifica il formato (0x41 0x56 0x49 0x20). Il blocco all'offset 4, composto da 4 byte, contiene la dimensione iniziale del blocco dati (ordine dei byte - little endian). Per scoprire il numero del blocco contenente la dimensione successiva, è necessario aggiungere la dimensione dell'intestazione (8 byte) e la dimensione ottenuta nel blocco da 4-8 byte. Questo calcola la dimensione totale del file. È accettabile che la dimensione calcolata possa essere inferiore alla dimensione effettiva del file. Una volta calcolata la dimensione, il file conterrà solo zero byte (necessari per allineare il limite di 1Kb).Esempio di calcolo delle dimensioni:
WAV
Come AVI, un file WAV inizia con una firma RIFF, tuttavia, questo file ha una firma dal byte 8 - WAVE (0x57 0x41 0x56 0x45). La dimensione del file viene calcolata allo stesso modo dell'AVI. La dimensione effettiva deve corrispondere completamente a quella calcolata.MP4
MP4 o MPEG-4 è un formato contenitore multimediale utilizzato per archiviare flussi video e audio, consentendo anche l'archiviazione di sottotitoli e immagini.All'offset 4 byte ci sono le firme: tipo di file ftyp (66 74 79 70) (tipo di file contenitore QuickTime) e sottotipo di file mmp4 (6D 6D 70 34). Per il riconoscimento file nascosti, siamo interessati alla possibilità di calcolare la dimensione del file.
Diamo un'occhiata a un esempio. La dimensione del primo blocco è all'offset zero ed è 28 (00 00 00 1C, ordine dei byte Big Endian); indica anche l'offset in cui si trova la dimensione del secondo blocco dati. All'offset 28 troviamo la dimensione del blocco successivo pari a 8 (00 00 00 08). Per trovare la dimensione del blocco successivo, è necessario aggiungere le dimensioni dei blocchi precedenti trovati. Pertanto, la dimensione del file viene calcolata:
MOV
Questo formato ampiamente utilizzato è anche un contenitore MPEG-4. MOV utilizza un algoritmo di compressione dati proprietario, ha una struttura simile a MP4 e viene utilizzato per gli stessi scopi: per archiviare dati audio e video, nonché materiali correlati.Come MP4, qualsiasi file mov ha una firma ftyp da 4 byte all'offset 4, tuttavia, la firma successiva ha il valore qt__ (71 74 20 20). La regola per calcolare la dimensione del file non è cambiata: partendo dall'inizio del file, calcoliamo la dimensione del blocco successivo e la sommiamo.
Il metodo per verificare la presenza di file "adesivi" in questo gruppo di formati consiste nel calcolare la dimensione secondo le regole sopra specificate e confrontarla con la dimensione del file da controllare. Se la dimensione del file corrente è molto inferiore a quella calcolata, ciò indica il fatto dell'incollaggio. Quando si controllano i file AVI, si accetta che la dimensione calcolata possa essere inferiore alla dimensione del file a causa della presenza di zeri aggiunti per allineare il bordo. In questo caso, è necessario verificare la presenza di zeri dopo la dimensione del file calcolata.
Controllo del formato binario del file composto
Questo formato file, sviluppato da Microsoft, è noto anche come OLE (Object Linking and Embedding) o COM (Component Object Model). I file DOC, XLS, PPT appartengono al gruppo dei formati CFB.Un file CFB è costituito da un'intestazione da 512 byte e da settori di uguale lunghezza che memorizzano flussi di dati o informazioni sul servizio. Ogni settore ha il proprio numero non negativo, ad eccezione dei numeri speciali: “-1” - numera il settore libero, “-2” - numera il settore che chiude la catena. Tutte le catene di settori sono definite nella tabella FAT.
Supponiamo che un utente malintenzionato abbia modificato un determinato file .doc e ne abbia incollato un altro alla fine. Ci sono alcuni in vari modi rilevarlo o segnalare un'anomalia nel documento.
Dimensioni del file anomale
Come accennato in precedenza, qualsiasi file CFB è costituito da un'intestazione e settori di uguale lunghezza. Per scoprire la dimensione del settore, è necessario leggere un numero di due byte all'offset 30 dall'inizio del file ed elevare 2 alla potenza di questo numero. Questo numero deve essere uguale rispettivamente a 9 (0x0009) o 12 (0x000C), la dimensione del settore del file è 512 o 4096 byte. Dopo aver trovato il settore, è necessario verificare la seguente uguaglianza:(FileSize - 512) mod SectorSize = 0
Se questa uguaglianza non è soddisfatta, puoi segnalare il fatto di incollare i file. Tuttavia, questo metodo presenta uno svantaggio significativo. Se un utente malintenzionato conosce la dimensione del settore, deve semplicemente incollare il suo file e altri n byte in modo che la dimensione dei dati incollati sia un multiplo della dimensione del settore.
Tipo di settore sconosciuto
Se l'aggressore conosce un metodo per aggirare il controllo precedente, allora questo metodo può rilevare la presenza di settori con tipi non definiti.Definiamo l'uguaglianza:
FileSize = 512 + CountReal * SectorSize, dove FileSize è la dimensione del file, SectorSize è la dimensione del settore, CountReal è il numero di settori.
Definiamo inoltre le seguenti variabili:
- CountFat – numero di settori FAT. Situato all'offset 44 dall'inizio del file (4 byte);
- CountMiniFAT: numero di settori MiniFAT. Situato all'offset 64 dall'inizio del file (4 byte);
- CountDIFAT – numero di settori DIFAT. Situato all'offset 72 dall'inizio del file (4 byte);
- CountDE – numero di settori di voci di directory. Per trovare questa variabile, è necessario trovare il primo settore DE, che si trova all'offset 48. Successivamente è necessario ottenere una rappresentazione completa del DE dalla FAT e contare il numero dei settori DE;
- CountStreams – numero di settori con flussi di dati;
- CountFree – numero di settori liberi;
- CountClassified – numero di settori con un certo tipo;
Ovviamente, se CountClassified e CountReal non sono uguali, possiamo concludere che i file potrebbero essere uniti.
Il mio capo mi ha affidato un compito piuttosto interessante. In breve tempo, scrivere un analizzatore di file eseguibili in grado di trovare i corpi dei virus in base alle firme e determinare il packer/cryptor utilizzato. Il prototipo finito è apparso entro un paio d'ore.
Parola d'autore
Analisi della firma
La ricerca di un oggetto dannoso utilizzando le firme è qualcosa che qualsiasi antivirus può fare. In generale, una firma è una descrizione formalizzata di determinate caratteristiche in base alle quali è possibile determinare che il file sottoposto a scansione è un virus e un virus ben definito.
Ci sono varie tecniche qui. Un'alternativa è utilizzare una firma composta da N byte di un oggetto dannoso. In questo caso, non puoi fare un confronto stupido, ma un confronto usando qualche maschera (come cercare i byte EB ?? ?? CD 13). Oppure impostare condizioni aggiuntive come "tali byte devono trovarsi nel punto di ingresso del programma" e così via. La firma del malware è una questione particolare.
Allo stesso modo, vengono descritti alcuni segni dai quali è possibile determinare che il file eseguibile è compresso con l'uno o l'altro crittografo o packer (ad esempio il banale ASPack). Se leggi attentamente la nostra rivista, avrai sicuramente sentito parlare di uno strumento come PEiD, che è in grado di identificare i packer, i crittografi e i compilatori più comunemente utilizzati (il database ha un gran numero di firme) per il file PE trasferito su di esso . Purtroppo, le nuove versioni del programma non vengono rilasciate da molto tempo e recentemente sul sito ufficiale è apparso un messaggio che il progetto non avrà ulteriori sviluppi. È un peccato, perché le funzionalità di PEiD (soprattutto considerando il sistema di plugin) potrebbero tornarmi molto utili. Dopo una breve analisi, è diventato chiaro che questa non era un’opzione. Ma dopo aver esplorato i blog in lingua inglese, ho trovato rapidamente ciò che faceva al caso mio. Progetto YARA (code.google.com/p/yara-project).
Cos'è YARA?
Fin dall'inizio ero convinto che da qualche parte su Internet esistesse già uno sviluppo open source che si sarebbe assunto il compito di determinare la corrispondenza tra una determinata firma e il file esaminato. Se potessi trovare un progetto del genere, potrebbe essere facilmente inserito nei binari di un'applicazione web, aggiungere lì diverse firme e ottenere ciò che mi veniva richiesto. Il piano ha cominciato a sembrarmi ancora più realistico quando ho letto la descrizione del progetto YARA.
Gli stessi sviluppatori lo posizionano come uno strumento per aiutare i ricercatori di malware a identificare e classificare campioni dannosi. Il ricercatore può creare descrizioni per tipi diversi malware che utilizza testo o modelli binari che descrivono le caratteristiche formalizzate del malware. Ecco come si ottengono le firme. Ogni descrizione, infatti, è composta da un insieme di righe e da qualche espressione logica, in base alla quale viene determinata la logica di attivazione dell’analizzatore.
Se le condizioni di una delle regole sono soddisfatte per il file esaminato, questo viene determinato di conseguenza (ad esempio, questo o quel worm). Un semplice esempio di regola per capire di cosa stiamo parlando:
regola silent_banker: banchiere
{
meta:
description = "Questo è solo un esempio"
livello_thread = 3
in_the_wild = vero
stringhe:
$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"
condizione:
$a o $b o $c
}
In questa regola diciamo a YARA che qualsiasi file che contiene almeno una delle stringhe di esempio descritte nelle variabili $a, $b, $c dovrebbe essere classificato come trojan silent_banker. E questa è una regola molto semplice. In realtà le regole possono essere molto più complesse (ne parleremo più avanti).
Anche l'elenco dei progetti che lo utilizzano parla dell'autorità del progetto YARA, e questo è:
- VirusTotal Malware Intelligence Services (vt-mis.com);
- jsunpack-n (jsunpack.jeek.org);
- Controlliamo il tuo sito web (wewatchyourwebsite.com).
Tutto il codice è scritto in Python e all'utente viene offerto sia il modulo stesso da utilizzare nel proprio sviluppo, sia semplicemente un file eseguibile per utilizzare YARA come applicazione autonoma. Come parte del mio lavoro, ho scelto la prima opzione, ma per semplicità in questo articolo utilizzeremo semplicemente l'analizzatore come applicazione console.
Dopo un po' di ricerche, ho capito rapidamente come scrivere le regole per YARA, nonché come allegarvi le firme dei virus dal freeware e dai packer di PEiD. Ma inizieremo con l'installazione.
Installazione
Come ho già detto, il progetto è scritto in Python, quindi può essere facilmente installato su Linux, Windows e Mac. All'inizio puoi semplicemente prendere il binario. Se chiamiamo l'applicazione nella console, otterremo le regole per l'avvio.
$yara
utilizzo: yara ... ... FILE | PID
Cioè, il formato per chiamare il programma è il seguente: prima c'è il nome del programma, poi un elenco di opzioni, dopo di che viene indicato il file con le regole, e alla fine - il nome del file che viene esaminato (o la directory contenente i file) o l'identificatore del processo. Adesso vorrei spiegarvi bene come vengono stilate proprio queste regole, ma non voglio caricarvi subito di aride teorie. Pertanto, faremo le cose in modo diverso e prenderemo in prestito le firme di altre persone in modo che YARA possa eseguire uno dei compiti che abbiamo impostato: un rilevamento completo dei virus tramite le firme.
Il tuo antivirus
La domanda più importante: dove trovare il database delle firme dei virus conosciuti? Le società di antivirus condividono attivamente tra loro tali database (alcune più generosamente, altre meno). Ad essere sincero, all'inizio dubitavo persino che da qualche parte su Internet qualcuno avrebbe pubblicato apertamente cose del genere. Ma, come si è scoperto, ci sono brave persone. Un database adatto del popolare antivirus ClamAV è a disposizione di tutti (clamav.net/lang/en). Nella sezione "Ultima versione stabile" puoi trovare un collegamento a ultima versione prodotto antivirus, nonché collegamenti per scaricare i database dei virus ClamAV. Saremo interessati principalmente ai file main.cvd (db.local.clamav.net/main.cvd) e daily.cvd (db.local.clamav.net/daily.cvd).
Il primo contiene il database principale delle firme, il secondo contiene il database più completo questo momento base con varie aggiunte. A questo scopo è più che sufficiente Daily.cvd, che contiene più di 100.000 impressioni di malware. Tuttavia, il database ClamAV non è un database YARA, quindi dobbiamo convertirlo nel formato desiderato. Ma come? Dopotutto non sappiamo ancora nulla né del formato ClamAV né del formato Yara. Questo problema è già stato risolto prima di noi preparando un piccolo script che converte il database delle firme antivirali di ClamAV in un insieme di regole YARA. Lo script si chiama clamav_to_yara.py ed è scritto da Matthew Richard (bit.ly/ij5HVs). Scarica lo script e converti i database:
$ python clamav_to_yara.py -f daily.cvd -o clamav.yara
Di conseguenza, nel file clamav.yara riceveremo un database di firme che sarà immediatamente pronto per l'uso. Proviamo ora la combinazione di YARA e il database ClamAV in azione. La scansione di una cartella utilizzando una firma viene eseguita con un solo comando:
$ yara -r clamav.yara /pentest/msf3/data
L'opzione -r specifica che la scansione deve essere eseguita in modo ricorsivo su tutte le sottocartelle della cartella corrente. Se ci fossero corpi di virus nella cartella /pentest/msf3/data (almeno quelli che si trovano nel database ClamAV), YARA lo segnalerà immediatamente. In linea di principio, questo è uno scanner di firma già pronto. Per maggiore comodità, ho scritto un semplice script che controllava gli aggiornamenti del database ClamAV, scaricava nuove firme e le convertiva nel formato YARA. Ma questi sono già dettagli. Una parte del compito è completata, ora puoi iniziare a stilare le regole per identificare i packer/cryptor. Ma per fare questo ho dovuto fare i conti un po’ con loro.
Gioca secondo le regole
Quindi, una regola è il meccanismo principale di un programma che consente di assegnare un determinato file a una determinata categoria. Le regole sono descritte in uno o più file separati e in apparenza sono molto simili alla costruzione struct() del linguaggio C/C++.
governa BadBoy
{
stringhe:
$a = "win.exe"
$b = "http://foo.com/badfile1.exe"
$c = "http://bar.com/badfi le2.exe"
condizione:
$a e ($b o $c)
}
In linea di principio, non c'è nulla di complicato nello scrivere le regole. In questo articolo ho toccato solo i punti principali, i dettagli li troverai nel manuale. Per ora, i dieci punti più importanti:
1. Ogni regola inizia con la parola chiave regola, seguita dall'identificatore della regola. Gli identificatori possono avere gli stessi nomi delle variabili in C/C++, ovvero possono essere costituiti da lettere e numeri e il primo carattere non può essere un numero. Lunghezza massima nome identificativo: 128 caratteri.
2. In genere, le regole sono costituite da due sezioni: una sezione di definizione (stringhe) e una sezione di condizione (condizione). La sezione stringhe specifica i dati in base ai quali la sezione condizioni deciderà se un determinato file soddisfa determinate condizioni.
3. Ogni riga nella sezione stringhe ha il proprio identificatore, che inizia con il segno $ - in generale, come una dichiarazione di variabile in PHP. YARA supporta le stringhe regolari racchiuse in virgolette("") e stringhe esadecimali racchiuse tra bretelle(()), nonché le espressioni regolari:
$my_text_string = "testo qui"
$mia_stringa_esadecimale = ( E2 34 A1 C8 23 FB )
4. La sezione delle condizioni contiene tutta la logica della regola. Questa sezione deve contenere un'espressione booleana che determina quando un file o un processo corrisponde alla regola. In genere, questa sezione si riferisce a righe dichiarate in precedenza. E l'identificatore di stringa viene trattato come una variabile booleana che restituisce true se la stringa è stata trovata nel file o nella memoria del processo e false altrimenti. La regola precedente specifica che i file e i processi contenenti la stringa win.exe e uno dei due URL devono essere classificati come BadBoy (in base al nome della regola).
5. Le stringhe esadecimali consentono tre costrutti che le rendono più flessibili: caratteri jolly, salti e alternative. Le sostituzioni sono posti in una stringa che sono sconosciuti e possono essere sostituiti da qualsiasi valore. Sono indicati dal simbolo “?”:
$stringa_esadecimale = ( MI2 34 ?? DO8 LA? FA )
Questo approccio è molto comodo quando si specificano stringhe di cui si conosce la lunghezza, ma il contenuto può variare. Se parte di una stringa può avere lunghezze diverse, è conveniente utilizzare gli intervalli:
$stringa_esadecimale = ( F4 23 62 B4 )
Questa voce significa che al centro della riga possono esserci da 4 a 6 byte diversi. Puoi anche implementare una scelta alternativa:
$stringa_esadecimale = ( F4 23 (62 B4 | 56) 45 )
Ciò significa che al posto del terzo byte possono esserci 62 B4 oppure 56, tale voce corrisponde alle righe F42362B445 o F4235645.
6. Per verificare che una determinata stringa si trovi a un offset specifico in uno spazio di indirizzi di file o processo, viene utilizzato l'operatore at :
$a a 100 e $b a 200
Se la stringa può rientrare in un determinato intervallo di indirizzi, viene utilizzato l'operatore in:
$a in (0..100) e $b in (100..dimensione file)
A volte si verificano situazioni in cui è necessario specificare che un file deve contenere un determinato numero da un determinato set. Questo viene fatto utilizzando l'operatore of:
regola dell'Esempio1
{
stringhe:
$pippo1 = "manichino1"
$pippo2 = "manichino2"
$foo3 = "manichino3"
condizione:
2 di ($foo1,$foo2,$foo3)
}
La regola precedente richiede che il file contenga due righe qualsiasi del set ($foo1,$foo2,$foo3). Invece di specificare un numero specifico di righe nel file, è possibile utilizzare le variabili any (almeno una riga di un dato set) e all (tutte le righe di un dato set).
7. Ebbene, l'ultima possibilità interessante da considerare è l'applicazione di una condizione a più righe. Questa funzionalità è molto simile all'operatore of, solo che è più potente l'operatore for..of:
per l'espressione di string_set: (boolean_expression)
Questa voce dovrebbe essere letta in questo modo: delle stringhe specificate nel set string_, almeno le parti dell'espressione devono soddisfare la condizione boolean_expression. O, in altre parole: boolean_expression viene valutata per ogni stringa in string_set e le espressioni da essi devono restituire True. Successivamente esamineremo questa costruzione utilizzando un esempio specifico.
Realizzare PEiD
Quindi, quando tutto sarà diventato più o meno chiaro con le regole, possiamo iniziare a implementare un rilevatore di packer e cryptor nel nostro progetto. Inizialmente, come materiale originale, ho preso in prestito le firme di noti imballatori dallo stesso PEiD. Nella cartella plugins c'è un file userdb.txt, che contiene ciò di cui abbiamo bisogno. Nel mio database c'erano 1850 firme.
Abbastanza, quindi per importarli completamente, ti consiglio di scrivere una sorta di script. Il formato di questo database è semplice: viene utilizzato quello abituale file di testo, che memorizza record come:
firma = 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 = vero
La prima riga specifica il nome del packer, che verrà visualizzato in PEiD, ma per noi sarà l'identificatore della regola. Il secondo è la firma stessa. Il terzo è il flag ep_only, che indica se cercare una determinata riga solo all'indirizzo del punto di ingresso o nell'intero file.
Bene, proviamo a creare una regola, diciamo, per ASPack? A quanto pare, non c'è nulla di complicato in questo. Per prima cosa creiamo un file per memorizzare le regole e chiamiamolo, ad esempio, packers.yara. Quindi cerchiamo nel database PEiD tutte le firme che includono ASPack nei loro nomi e le trasferiamo alla regola:
regola ASPack
{
stringhe:
$ = ( 60 E8 ?? ?? ?? ?? 5D 81 ED ?? ?? (43 | 44) ?? B8 ?? ?? (43 | 44) ?? 03 C5 )
$ = ( 60 EB ?? 5D EB ?? FF ?? ?? ?? ?? ?? E9 )
[.. taglio..]
$ = ( 60 E8 03 00 00 00 E9 EB 04 5D 45 55 C3 E8 01 )
condizione:
per ognuno di essi: ($al punto di ingresso)
}
Tutti i record trovati hanno il flag ep_only impostato su true, ovvero queste righe devono trovarsi nell'indirizzo del punto di ingresso. Pertanto scriviamo la seguente condizione: “per qualcuno di essi: ($at entrypoint)”.
Pertanto, la presenza di almeno una delle righe indicate nell'indirizzo del punto di ingresso significherà che il file è compresso con ASPack. Tieni inoltre presente che in questa regola tutte le righe vengono specificate semplicemente utilizzando il segno $, senza identificatore. Ciò è possibile perché nella sezione delle condizioni non accediamo a nessuna specifica, ma utilizziamo l'intero set.
Per verificare la funzionalità del sistema risultante, basta eseguire il comando nella console:
$ yara -r packers.yara somefi le.exe
Dopo aver alimentato lì un paio di applicazioni confezionate con ASPack, ero convinto che tutto funzionasse!
Prototipo pronto
YARA si è rivelato uno strumento estremamente chiaro e trasparente. Non è stato difficile per me scrivere un amministratore web e configurarlo affinché funzioni come servizio web. Con un po' di creatività i risultati secchi dell'analizzatore vengono già colorati in diversi colori, indicando il grado di pericolosità del malware rilevato. Un piccolo aggiornamento del database e per molti dei crittografi è disponibile una breve descrizione e talvolta anche le istruzioni per decomprimere. Il prototipo è stato creato e funziona perfettamente, e i boss ballano di gioia!
Il codice funzione (FC) nell'intestazione del telegramma identifica il tipo di telegramma, come telegramma di richiesta (Request o Send/Request) e telegramma di conferma o di risposta (telegramma di conferma, telegramma di risposta). Inoltre il codice funzione contiene l'effettiva funzione di trasmissione e informazioni di controllo che impediscono la perdita e la duplicazione dei messaggi, oppure il tipo di stazione con stato FDL.
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | FC: Richiesta codice funzione |
| 1 | Richiedi Telegramma | |||||||
| X | FCV = Bit alternato attivato | |||||||
| X | href=”http://profibus.felser.ch/en/funktionscode.htm#aufruffolgebit”>FCB = Bit alternato (dal conteggio dei fotogrammi) | |||||||
| 1 | 0 (0x0) | CV = Valore orologio() | ||||||
| 1 | altro | Riservato | ||||||
| 0 | 0 (0x0) | TE = Time Event (sincronizzazione dell'orologio) | ||||||
| 0 | 3 (0x3) | SDA_LOW = Invio dati confermato - priorità bassa | ||||||
| 0 | 4 (0x4) | SDN_LOW = Invia dati non riconosciuto: priorità bassa | ||||||
| 0 | 5 (0x5) | SDA_HIGH = Invio dati confermato - priorità alta | ||||||
| 0 | 6 (0x6) | SDN_HIGH = Invia dati non riconosciuto | ||||||
| 0 | 7 (0x7) | MSRD = Invia dati di richiesta con risposta multicast | ||||||
| 0 | 9 (0x9) | Richiedi lo stato FDL | ||||||
| 0 | 12(0xC) | SRD basso = Invia e richiedi dati | ||||||
| 0 | 13(0xD) | SRD alto = Invia e richiedi dati | ||||||
| 0 | 14(0xE) | Richiedi Ident con risposta | ||||||
| 0 | 15 (0xF) | Richiesta stato LSAP con risposta 1) | ||||||
| 0 | altro | Riservato | ||||||
1) questo valore è nell'ultima versione dello standard non più definito ma solo riservato
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | FC: risposta al codice funzione |
| 0 | Telegramma di risposta | |||||||
| 0 | Riservato | |||||||
| 0 | 0 | Schiavo | ||||||
| 0 | 1 | Maestro non pronto | ||||||
| 1 | 0 | Maestro pronto, senza gettone | ||||||
| 1 | 1 | Maestro pronto, nel gettone | ||||||
| 0 (0x0) | OK | |||||||
| 1 (0x1) | UE = Errore utente | |||||||
| 2 (0x2) | RR = Nessuna risorsa | |||||||
| 3 (0x3) | RS = SAP non abilitato | |||||||
| 8 (0x8) | DL = Dati bassi (caso normale con DP) | |||||||
| 9 (0x9) | NR = Nessun dato di risposta pronto | |||||||
| 10(0xA) | DH = Data High (diagnosi DP in sospeso) | |||||||
| 12(0xC) | RDL = Dati non ricevuti e Dati bassi | |||||||
| 13(0xD) | RDH = Dati non ricevuti e Dati alti | |||||||
| altro | Riservato | |||||||
Bit di conteggio dei frame Il bit di conteggio dei frame FCB (b5) impedisce la duplicazione del messaggio da parte della stazione di riconoscimento o di risposta (risponditore) e qualsiasi perdita da parte della stazione chiamante (iniziatore). Sono escluse da ciò le richieste senza riconoscimento (SDN) e le richieste FDL Status, Ident e LSAP Status.
Per la sequenza di sicurezza, l'iniziatore deve portare con sé un FCB per ciascun risponditore. Quando un telegramma di richiesta (Richiesta o Invia/Richiesta) viene inviato a un risponditore per la prima volta o se viene inviato nuovamente a un risponditore attualmente contrassegnato come non operativo, l'FCB deve essere impostato come definito nel risponditore. L'iniziatore ottiene ciò in un telegramma Request con FCV=0 e FCB=1. Il risponditore deve valutare un telegramma di questo tipo come primo ciclo di messaggi e memorizzare l'FCB=1 insieme all'indirizzo dell'iniziatore (SA) (vedi tabella seguente). Questo ciclo di messaggi non verrà ripetuto dall'iniziatore. Nei successivi telegrammi Request allo stesso risponditore, l'iniziatore deve impostare FCV=1 e modificare l'FCB con ogni nuovo telegramma Request. Ogni risponditore che riceve un telegramma Request indirizzato a lui con FCV=1 deve valutare l'FCB. Se l'FCB è cambiato rispetto all'ultimo telegramma Request dello stesso iniziatore (stesso SA), ciò è una valida conferma che il ciclo di messaggi precedente si è concluso correttamente. Se il telegramma Request proviene da un diverso iniziatore (diverso SA), la valutazione dell'FCB non è più necessaria. In entrambi i casi il ricevente deve salvare l'FCB con l'SA sorgente fino al ricevimento di un nuovo telegramma a lui indirizzato. In caso di telegramma di conferma o di risposta perso o compromesso, l'FCB non deve essere modificato dall'iniziatore nel nuovo tentativo di richiesta: ciò indicherà che il ciclo di messaggio precedente era errato. Se il risponditore riceve un telegramma Request con FCV=1 e lo stesso FCB dell'ultimo telegramma Request dallo stesso iniziatore (stesso SA), ciò indicherà un nuovo tentativo di richiesta. Il risponditore deve a sua volta ritrasmettere il telegramma di conferma o di risposta tenuto pronto. Fino alla suddetta conferma o ricezione di un telegramma con indirizzo diverso (SA o DA) che non viene riconosciuto (Send Data with No Acknowledge, SDN) il risponditore deve tenere pronto l'ultimo telegramma di conferma o di risposta per ogni eventuale nuovo tentativo di richiesta . In caso di telegrammi Request non confermati e con Request FDL Status, Ident e LSAP Status, FCV=0 e FCB=0; la valutazione da parte del risponditore non è più necessaria.
| b5 | b4 | Posizione della punta | ||
| FCB | FCV | Condizione | Senso | Azione |
| 0 | 0 | DA =TS/127 | Richiesta senza conferma Richiedi stato FDL/Ident/Stato LSAP |
Elimina l'ultima conferma |
| 0/1 | 0/1 | DA#TS | Richiesta a un altro risponditore | |
| 1 | 0 | DA = ST | Prima richiesta | FCBM:= 1 SAM:=SA Elimina l'ultima conferma/risposta |
| 0/1 | 1 | DA = ST SA = SAM FCB#FCBM |
Nuova richiesta | Elimina l'ultima conferma/risposta FCBM:=FCB Mantieni il riconoscimento/risposta pronto per un nuovo tentativo |
| 0/1 | 1 | DA = ST SA = SAM FCB = FCBM |
Richiesta di nuovo tentativo | FCBM:=FCB Ripetere il riconoscimento/risposta e continuare a mantenersi pronti |
| 0/1 | 1 | DA = ST SA#SAM |
Nuovo iniziatore | FCBM:=FCB SAM:= SA Mantiene la conferma/risposta pronta per un nuovo tentativo |
FCBM ha memorizzato FCB in memoria SAM ha memorizzato SA in memoria
