Risolti alcuni problemi con le euristiche sul campo Characteristics,

aggiunta descrizione in inglese, risolto typo in Italiano, aggiunti i
certificati di Root Microsoft

Author: seekbytes

.gitignore

@@ -10,7 +10,7 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
-
+.DS_store
 # Dependency directories (remove the comment below to include it)
 # vendor/
 data/

CHANGELOG

@@ -1,3 +1,10 @@
+Versione 0.0.3-alpha:
+- Migliorata euristica sulle flag delle sezioni
+- Risolto problema con offset delle risorse, se presenti in sezioni diverse
+- Aggiunta stampa sulle flag delle sezioni
+- Risolto problema sulla verifica della trust chain per la sezione Security
+- Aggiunti certificati di root Microsoft (2010 e 2017)
+
 Versione 0.0.2-alpha:
 - Risolti fix
 - Aggiunte euristiche sul nome della sezione

README.en.md

@@ -0,0 +1,29 @@
+![MicroSCOPE logo](https://github.com/seekbytes/MicroSCOPE/blob/main/utils/MicroSCOPE.jpg?raw=true)
+
+## Project Goal
+
+MicroSCOPE is a software program developed through the [Go](https://go.dev) programming language that allows for the detection of a precise category of malicious software. The program is designed specifically for a class of malicious programs called _ransomware_ whose operation consists of data encryption and ransom demand in order to gain access to the content again.
+
+In particular, MicroSCOPE was developed to be able to support two of the mainly used formats: the PE (_Portable Executable_) format for Windows platforms and ELF (_Executable and Linking Format_) for Unix-based platforms. Through the application of certain heuristics, MicroSCOPE is able to assign a score that corresponds to the level of dangerousness of the file being analyzed. The higher the score, the more similar characteristics the software will exhibit to ransomware that has already been studied. The heuristics have been extrapolated from numerous case studies and will be improved over time.
+
+## Repository Structure
+* `analysis`: folder related to the static analysis of the binaries (including the various phases of MicroSCOPE)
+* `docs`: folder containing documentation of the MicroSCOPE project.
+* `formats`: folder related to the binary file formats (ELF and PE) including constants, checks and parsing of the binary;
+* `heuristics`: the actual heuristics.
+* `utils`: general utilities
+
+## How it works
+
+The analysis performed by MicroSCOPE has three main steps:
+* **data mining**: in-depth analysis of the binary file based on its extension type (for example: whether PE or ELF file), extrapolating strings, functions it uses and any other information potentially useful for predicting program execution;
+* **application of heuristics**: based on the information extrapolated from the first stage, heuristics are applied to figure out how the program will behave when executed. At this stage, a score (summation of the various scores of the heuristics) is calculated;
+* **outcome determination**: based on the score and above a certain value (called threshold value - user-defined), MicroSCOPE will associate a certain score with malicious behavior;
+
+## How to use it
+
+Download the [latest release](https://github.com/seekbytes/MicroSCOPE/releases) and then run it with the flag `-f` to specify the input file (must be a valid PE or ELF executable).
+
+```
+./microscope -f my_executable_ransomware
+```

README.md

@@ -2,7 +2,7 @@
 
 ## Scopo del progetto
 
-MicroSCOPE è un software sviluppato tramite il linguaggio di programmazione [Go](https://go.dev) che permette di inidividuare una precisa categoria di software dannoso. Il programma è stato studiato specificamente per una classe di programmi dannosi chiamata _ransomware_ il cui funzionamento consiste nella crittazione dei dati e richiesta di riscatto per poter riaccedere al contenuto.
+MicroSCOPE è un software sviluppato tramite il linguaggio di programmazione [Go](https://go.dev) che permette di individuare una precisa categoria di software dannoso. Il programma è stato studiato specificamente per una classe di programmi dannosi chiamata _ransomware_ il cui funzionamento consiste nella crittazione dei dati e richiesta di riscatto per poter riaccedere al contenuto.
 
 In particolare, MicroSCOPE è stato sviluppato per poter supportare due tra i formati principalmente utilizzati: il formato PE (_Portable Executable_) per piattaforme Windows ed ELF (_Executable and Linking Format_) per piattaforme Unix-based. Tramite l'applicazione di alcune euristiche, MicroSCOPE è in grado di attribuire un punteggio che corrisponde al livello di pericolosità del file che si vuole analizzare. Tanto più alto è il punteggio, tanto più il software presenterà caratteristiche simili a ransomware già studiati. Le euristiche sono state estrapolate da numerosi casi di studio e verranno migliorate nel corso del tempo.
 
@@ -20,3 +20,13 @@ L'analisi effettuata da MicroSCOPE ha tre fasi principali:
 * **data mining**: analisi approfondita del file binario in base al tipo di estensione (ad esempio: se file PE o ELF), estrapolando stringhe, funzioni che utilizza e qualsiasi altra informazione potenzialmente utile per prevedere l'esecuzione del programma;
 * **applicazione delle euristiche**: in base alle informazioni estrapolate dalla prima fase, si applicano le euristiche che consentono di capire che comportamento avrà il programma una volta eseguito. In questa fase viene calcolato un punteggio (sommatoria dei vari punteggi delle euristiche);
 * **determinazione del risultato**: in base al punteggio e sopra un certo valore (chiamato valore di threshold - definito dall'utente), MicroSCOPE assocerà un certo punteggio a un comportamento malevolo;
+
+## Come utilizzarlo
+
+Scarica l'[ultima release](https://github.com/seekbytes/MicroSCOPE/releases) e avvialo con la flag `-f` per specificare il file di input (nota: deve essere un file PE o un file ELF).
+
+```
+./microscope -f my_executable_ransomware
+```
+
+Verrà così generato un nuovo report HTML all'interno di una cartella chiamata `results` (creata all'interno della working directory).

analysis/analysis.go

@@ -36,6 +36,7 @@ func PrintResult(Analyzed *formats.FileAnalyzed) {
 		"PEprintResource":              pe.PrintResource,
 		"PEprintSubsystem":             pe.PrintSubsystem,
 		"PEprintMajorOperatingVersion": pe.PrintMajorOperatingSystemVersion,
+		"PEprintSectionFlags":          pe.PrintSectionFlags,
 		"PEprintCharacteristics":       pe.PrintCharacteristic,
 		"ELFprintMachine":              elf.PrintMachine,
 		"ELFprintSectionType":          elf.PrintSectionType,

formats/analysis.go

@@ -14,9 +14,10 @@ type FileAnalyzed struct {
 	ExtractedStrings []string      // Stringhe estratte
 	Anomalies        []Anomaly     // Anomalie
 	Hash             string        // Hash 256
-	OutputFormat     string        // Formato del file di output dell'analisi
+	OutputFormat     string        // Formato del file prodotto dall'analisi
 	PEInterface      pe.PEBINARY   // Puntatore al PEbinary se il formato è PE
 	ELFInterface     elf.ELFBINARY // Puntatore all'elfbinary se il formato è ELF
+	Instructions     []string      // Istruzioni
 	Threshold        int           // Threshold
 	Raw              []byte
 }

formats/elf/sections.go

@@ -101,7 +101,10 @@ func parseSections32(endianness binary.ByteOrder, shnum uint16, table uint16) []
 				fmt.Println(err.Error())
 			}
 			buffer := make([]byte, headers[i].Size)
-			binary.Read(reader, endianness, &buffer)
+			err = binary.Read(reader, endianness, &buffer)
+			if err != nil {
+				fmt.Println("errore durante la lettura della sezione ")
+			}
 			tmp.Raw = buffer
 			tmp.Entropy = utils.CalculateEntropy(tmp.Raw)
 		} else {

formats/pe/apiset.go

@@ -53,7 +53,7 @@ func readApiSet() {
 			// Sposta l'offset
 			_, err = readerApiSet.Seek(int64(int(header.NamesOffset)+binary.Size(ApiSetNameEntry{})*i), io.SeekStart)
 			if err != nil {
-				fmt.Println("Impossibile spostare il seek.")
+				fmt.Println("Impossibile spostare il seek " + err.Error())
 				return
 			}
 
@@ -70,7 +70,7 @@ func readApiSet() {
 			for i := 0; i < int(tmp.NumberOfHosts); i++ {
 				_, err = readerApiSet.Seek(int64(tmp.HostOffset)+int64(i*(binary.Size(ApiSetValueEntry{}))), io.SeekStart)
 				if err != nil {
-					fmt.Println("Impossibile effettuare il seek")
+					fmt.Println("Impossibile effettuare il seek" + err.Error())
 					return
 				}
 				var tmpEntry ApiSetValueEntry

formats/pe/exports.go

@@ -45,7 +45,7 @@ func readExports(virtualAddress uint32) {
 
 	fileAnalyzed.ExportNameMap = make(map[string]*Export)
 	fileAnalyzed.ExportOrdinalMap = make(map[int]*Export)
-	fmt.Printf("%d \n", exportDirectory.NumberOfName)
+
 	// Per ogni entry della tabella degli exports
 	for i := 0; i < int(exportDirectory.NumberOfName); i++ {
 

formats/pe/imports.go

@@ -119,8 +119,7 @@ func readImports(is64bit bool, virtualAddress uint32) {
 
 			}
 
-			importElement := &ImportInfo{DllName: dllName, APICalled: funcName, Offset: tableOffset}
-
+			importElement := &ImportInfo{DllName: dllName, APICalled: funcName, Offset: tableOffset, Thunk: thunk1}
 			fileAnalyzed.Imports = append(fileAnalyzed.Imports, importElement)
 
 			// Continua il ciclo aggiungendo il padding