Aggiunte nuove euristiche sulle sezioni

Author: seekbytes

formats/elf/sections.go

@@ -52,7 +52,11 @@ func parseSections64(endianness binary.ByteOrder, shnum uint16, table uint16) []
 				return nil
 			}
 			buffer := make([]byte, headers[i].Size)
-			binary.Read(reader, endianness, &buffer)
+			err = binary.Read(reader, endianness, &buffer)
+			if err != nil {
+				fmt.Println("Impossibile leggere la sezione")
+				return nil
+			}
 			tmp.Raw = buffer
 			tmp.Entropy = utils.CalculateEntropy(tmp.Raw)
 		} else {

formats/pe/exports.go

@@ -31,6 +31,12 @@ func readExports(virtualAddress uint32) {
 
 	if err != nil {
 		fmt.Println("Impossibile leggere la struttura exportDirectory " + err.Error())
+		return
+	}
+
+	if exportDirectory.NumberOfFunctions == 0 {
+		fmt.Println("Attenzione: numero di funzioni esportate uguale a 0")
+		return
 	}
 
 	namesTableRVA := exportDirectory.NameRva - section.VirtualAddress
@@ -39,11 +45,10 @@ 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++ {
 
-		//
 		_, err = reader.Seek(int64(namesTableRVA+uint32(i*4)), io.SeekStart)
 		if err != nil {
 			fmt.Println("Errore nel seek per la tabella delle funzioni esportate")
@@ -56,7 +61,7 @@ func readExports(virtualAddress uint32) {
 			fmt.Println("Impossibile leggere la struttura ExportAddressTable per il seguente motivo : " + err.Error())
 			return
 		}
-
+		fmt.Printf("%+v \n", exportAddressTable)
 		name := utils.ReadString(section.Raw[exportAddressTable.ExportRva-section.VirtualAddress:])
 		ordinal = binary.LittleEndian.Uint16(section.Raw[ordinalsTableRVA+uint32(i*2) : ordinalsTableRVA+uint32(i*2)+2])
 		_, err = reader.Seek(int64(uint32(ordinal)*4+exportDirectory.AddressOfFunctions-section.VirtualAddress), io.SeekStart)

formats/pe/pe.go

@@ -226,7 +226,7 @@ func Analysis(PEStruct *PEBINARY, content []byte) {
 
 	// Se, all'interno del binario, la dimensione della sezione per l'export è diverso 0, procediamo con la lettura degli export
 	if DataDirectories[IMAGE_DIRECTORY_ENTRY_EXPORT].Size != 0 {
-		readExports(DataDirectories[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
+		//readExports(DataDirectories[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
 	}
 
 	// Sezione Import
@@ -253,6 +253,7 @@ func Analysis(PEStruct *PEBINARY, content []byte) {
 			err = binary.Read(reader, binary.LittleEndian, &contenuto)
 			fileAnalyzed.Resource[i].Content = contenuto
 			fileAnalyzed.Resource[i].ContentType = utils.IdentifyFile(contenuto)
+			fileAnalyzed.Resource[i].Entropy = utils.CalculateEntropy(contenuto)
 			if fileAnalyzed.Resource[i].Name == "" {
 				fileAnalyzed.Resource[i].Name = PrintResource(fileAnalyzed.Resource[i].Type)
 			}

formats/pe/pe_structs.go

@@ -162,8 +162,8 @@ type Section struct {
 type ExportDirectory struct {
 	Characteristics       uint32 // In genere tutti zero per PE, campo riservato
 	TimeDateStamp         uint32 // data di creazione
-	MajorVersion          uint32 // Riservato: zero
-	MinorVersion          uint32 // Riservato: zero
+	MajorVersion          uint16 // Riservato: zero
+	MinorVersion          uint16 // Riservato: zero
 	NameRva               uint32 // RVA che punta al nome del modulo
 	OrdinalBase           uint32 // Numero che va sommato all'indice per ottenere l'ordinal della funzione
 	NumberOfFunctions     uint32 // Numero di funzioni esportate dal modulo
@@ -231,12 +231,14 @@ type ResourceDirString struct {
 }
 
 type Resource struct {
-	Name        string
-	Offset      uint64
-	Size        uint64
-	Content     []byte
-	Type        int
-	ContentType string
+	Name          string
+	Offset        uint64
+	Size          uint64
+	Content       []byte
+	Type          int
+	ContentType   string
+	TimedateStamp uint32
+	Entropy       float64
 }
 
 // CompID è una struttura che riporta le informazioni del compilatore all'interno del RichHeader.
@@ -322,9 +324,10 @@ type WinCertificate struct {
 }
 
 type SecurityHeader struct {
-	Header   WinCertificate
-	Content  *pkcs7.PKCS7
-	IsSigned bool
+	Header     WinCertificate
+	Content    *pkcs7.PKCS7
+	IsSigned   bool
+	ReasonFail string
 }
 
 // APISET

formats/pe/resources.go

@@ -81,6 +81,7 @@ func readResourceDirectory(virtualAddress uint32) {
 			var single byte
 			// Lettura della stringa
 			for j := 0; j <= int(ResourceDir.Length)*2; j = j + 1 {
+				// Lettura della stringa byte per byte
 				err = binary.Read(reader, binary.LittleEndian, &single)
 				if err != nil {
 					fmt.Println("Impossibile leggere la struttura byte per il seguente motivo " + err.Error())
@@ -93,6 +94,7 @@ func readResourceDirectory(virtualAddress uint32) {
 			_, err = reader.Seek(seekPosition, io.SeekStart)
 			if err != nil {
 				fmt.Println("Impossibile riallineare l'offset allo stato iniziale per il seguente errore " + err.Error())
+				return
 			}
 		} else {
 			// PrintResource(int(ImgTmp.Name))
@@ -210,7 +212,7 @@ func readResourceDirectory(virtualAddress uint32) {
 						return
 					}
 
-					resourceTmpFrom := Resource{Name: string(tmpString), Type: int(ImgResDirEntry[i].Name), Offset: uint64(resourceTmp.Offset), Size: uint64(resourceTmp.Size), Content: nil}
+					resourceTmpFrom := Resource{Name: string(tmpString), Type: int(ImgResDirEntry[i].Name), Offset: uint64(resourceTmp.Offset), Size: uint64(resourceTmp.Size), Content: nil, TimedateStamp: resource.TimeDateStamp}
 					fileAnalyzed.Resource = append(fileAnalyzed.Resource, resourceTmpFrom)
 				}
 				_, err = reader.Seek(seekPosition, io.SeekStart)

formats/pe/security.go

@@ -1,7 +1,6 @@
 package pe
 
 import (
-	"bytes"
 	"crypto/x509"
 	"encoding/binary"
 	"fmt"
@@ -19,17 +18,16 @@ func readSecuritySection(virtualAddress uint32) {
 		return
 	}
 
-	offset := virtualAddress - section.VirtualAddress
+	//offset := virtualAddress - section.VirtualAddress
+	offset := virtualAddress
 	if offset < 0 {
 		fmt.Println("L'offset non può essere minore di 0.")
 		return
 	}
 
-	readerRaw := bytes.NewReader(section.Raw)
-
 	for {
-		_, err := readerRaw.Seek(int64(offset), io.SeekStart)
-
+		_, err := reader.Seek(int64(offset), io.SeekStart)
+		var reasonString string
 		if err != nil {
 			fmt.Println("Impossibile effettuare il seek per il seguente motivo: " + err.Error())
 			return
@@ -38,9 +36,9 @@ func readSecuritySection(virtualAddress uint32) {
 		// Parsa ogni certificato
 		var Certificate WinCertificate
 
-		err = binary.Read(readerRaw, binary.LittleEndian, &Certificate)
+		err = binary.Read(reader, binary.LittleEndian, &Certificate)
 		if err != nil {
-			fmt.Println("Impossibile leggere la struttura WinCertificate")
+			fmt.Println("Impossibile leggere la struttura WinCertificate per il seguente motivo: " + err.Error())
 			return
 		}
 
@@ -49,16 +47,20 @@ func readSecuritySection(virtualAddress uint32) {
 			return
 		}
 
-		certificateContent := make([]byte, Certificate.Length)
-		err = binary.Read(readerRaw, binary.LittleEndian, certificateContent)
+		fmt.Printf("%+v\n", Certificate)
+
+		certificateContent := make([]byte, Certificate.Length-uint32(binary.Size(WinCertificate{})))
+		err = binary.Read(reader, binary.LittleEndian, certificateContent)
 		if err != nil {
 			fmt.Println("Impossibile leggere il contenuto del certificato " + err.Error())
 			return
 		}
 
 		pkcs, err := pkcs7.Parse(certificateContent)
 		if err != nil {
-			fmt.Println("Errore: il certificato non è valido")
+			reasonString = err.Error()
+			fmt.Println("Errore: il certificato non è valido: " + reasonString)
+			fileAnalyzed.SecuritySection = append(fileAnalyzed.SecuritySection, SecurityHeader{Header: Certificate, Content: pkcs, IsSigned: false, ReasonFail: reasonString})
 			return
 		}
 
@@ -71,13 +73,14 @@ func readSecuritySection(virtualAddress uint32) {
 		isValid := true
 		err = pkcs.VerifyWithChain(certPool)
 		if err != nil {
-			fmt.Println("Il certificato non è valido")
+			reasonString = err.Error()
+			fmt.Println("Il certificato non è valido: " + err.Error())
 			isValid = false
 		}
 
 		offset = Certificate.Length + offset
 		offset = offset + 8 - 1
-		fileAnalyzed.SecuritySection = append(fileAnalyzed.SecuritySection, SecurityHeader{Header: Certificate, Content: pkcs, IsSigned: isValid})
+		fileAnalyzed.SecuritySection = append(fileAnalyzed.SecuritySection, SecurityHeader{Header: Certificate, Content: pkcs, IsSigned: isValid, ReasonFail: reasonString})
 	}
 
 }

heuristics/dotnet_heuristics.go

@@ -0,0 +1,31 @@
+package heuristics
+
+import "strings"
+
+func CalculatePointsStringDOTNET(extractedStrings []string) {
+
+	// Tutti gli import dei binari .NET
+	NetImports := map[string]int{
+		"Systems.diagnostic":      2,
+		"GetProcessesByName":      10,
+		"get_SpecialDirectories":  20,
+		"get_FileSystem":          2,
+		"SpecialDirectoriesProxy": 10,
+		"setShowInTaskBar":        20,
+		"AESEncryptFile":          10,
+		"AESDecryptFile":          10,
+		"AESEncryptBytes":         10,
+		"AESDecryptBytes":         10,
+	}
+
+	for i := 0; i < len(extractedStrings); i++ {
+		for stringToCompare, pointsToAdd := range NetImports {
+			if strings.Contains(extractedStrings[i], stringToCompare) {
+				InsertAnomalyString("La stringa "+extractedStrings[i]+" indica una funzione strettamente correlata ad un ransomware codificato in .NET.", pointsToAdd)
+			}
+		}
+	}
+
+	//AESEncryptFile, AESDecryptFile, AESEncryptBytes,AESDecryptBytes,CheckPassword,GenerateKey 20 per ognuno tranne gli ultimi due
+	// System.Security.Cryptography,AesCryptoServiceProvider
+}

heuristics/heuristics.go

@@ -18,24 +18,24 @@ func Execute(analyzed *formats.FileAnalyzed) {
 
 	if analyzed.Format == "PE" {
 
-		var isDotNet bool
 		if len(analyzed.PEInterface.Imports) == 1 {
 			if analyzed.PEInterface.Imports[0].APICalled == "_CorExeMain" {
-				isDotNet = true
 				InsertAnomalyOthers("Il programma è un file eseguibile .NET.", 0)
+				CalculatePointsStringDOTNET(analyzed.ExtractedStrings)
 			}
 		}
 
 		// Binario Tradizionale
 		// Euristica sulle intestazioni
 		CheckHeaders()
 		// Euristica sulle stringhe
-		CalculatePointsStringPE(analyzed.ExtractedStrings, isDotNet)
+		CalculatePointsStringPE(analyzed.ExtractedStrings)
 		// Euristica sugli imports
 		CalculatePointsImports(analyzed.PEInterface.Imports)
 		// Euristica sull'entropia
 		CalculatePointsEntropy(analyzed.PEInterface.Sections)
-
+		// Euristica sulle risorse
+		CalculatePointsResources(analyzed.PEInterface.Resource)
 		// Euristica sui binari signed/unsigned
 		CalculatePointsSecurity(analyzed.PEInterface.SecuritySection)
 	}

heuristics/pe_headers_heuristics.go

@@ -87,10 +87,6 @@ func CheckOptionalHeader32(header pe.PEOptionalHeaderT) {
 		InsertAnomalyFileFormat("ImageDataDirectory valore invalido.", 10)
 	}
 
-	if int(header.NumberOfRvaAndSizes) != len(FileAnalyzed.PEInterface.Sections) {
-		InsertAnomalyFileFormat("Il numero delle sezioni è diverso rispetto a quello dichiarato. Valore ottenuto: "+strconv.Itoa(int(header.NumberOfRvaAndSizes))+", numero di sezioni effettive: "+strconv.Itoa(len(FileAnalyzed.PEInterface.Sections)), 10)
-	}
-
 	if header.LoaderFlags != 0 {
 		InsertAnomalyFileFormat("Attenzione: LoaderFlags diverso da zero.", 10)
 	}
@@ -178,6 +174,10 @@ func CheckCOFFHeader(CoffHeader *pe.COFFHeaderT) {
 		InsertAnomalyFileFormat("Attenzione: il numero di sezioni non può essere minore di 1.", 10)
 	}
 
+	if int(CoffHeader.NumberOfSections) != len(FileAnalyzed.PEInterface.Sections) {
+		InsertAnomalyFileFormat("Il numero delle sezioni è diverso rispetto a quello dichiarato. Valore ottenuto: "+strconv.Itoa(int(CoffHeader.NumberOfSections))+", numero di sezioni effettive: "+strconv.Itoa(len(FileAnalyzed.PEInterface.Sections)), 10)
+	}
+
 	// Un programma di solito ha NOVE sezioni predefinite (.text, .bss, .rdata, .data, .rsrc, .edata, .idata, .pdata e .debug)
 	// Windows NT 5 o precedenti: valore non può essere maggiore di 96
 	// Windows NT 6: valore può raggiungere 65535
@@ -218,8 +218,17 @@ func CheckCOFFHeader(CoffHeader *pe.COFFHeaderT) {
 		InsertAnomalyFileFormat("SizeOfOptionalHeader è zero.", 10)
 	}
 
-	if CoffHeader.SizeOfOptionalHeader > uint16(binary.Size(pe.COFFHeaderT{})) {
-		InsertAnomalyFileFormat("La dimensione della SizeOfOptionalHeader è particolare. Valore ottenuto: "+strconv.Itoa(int(CoffHeader.SizeOfOptionalHeader))+".", 10)
+	sizePrevista32bit := 4 + uint16(binary.Size(pe.PEOptionalHeaderT{})) + uint16(binary.Size(pe.ImageDataDirectory{})*16)
+	sizePrevista64bit := 4 + uint16(binary.Size(pe.PEPOptionalHeaderT{})) + uint16(binary.Size(pe.ImageDataDirectory{})*16)
+
+	if FileAnalyzed.PEInterface.Is64bit {
+		if CoffHeader.SizeOfOptionalHeader > sizePrevista64bit {
+			InsertAnomalyFileFormat("La dimensione della SizeOfOptionalHeader è particolare. Valore ottenuto: "+strconv.Itoa(int(CoffHeader.SizeOfOptionalHeader))+".", 10)
+		}
+	} else {
+		if CoffHeader.SizeOfOptionalHeader > sizePrevista32bit {
+			InsertAnomalyFileFormat("La dimensione della SizeOfOptionalHeader è particolare. Valore ottenuto: "+strconv.Itoa(int(CoffHeader.SizeOfOptionalHeader))+".", 10)
+		}
 	}
 
 }

heuristics/resources_heuristics.go

@@ -18,6 +18,10 @@ func CalculatePointsResources(resources []pe.Resource) {
 		if resources[i].Size == 0 {
 			blank++
 		}
+
+		if resources[i].Entropy >= 6.6 {
+			InsertAnomalyOthers("Il binario contiene delle risorse offuscate", 20)
+		}
 	}
 
 	if binary > 0 {