Assemble assembes the given instructions and return a byte array with a boolean value indicating wether the operation is successful or not

GetRandomByte generates a random single byte

GetRandomRegister returns a random register name based on given size and architecture

CoinFlip implements a coin flip witch returns true/false

GenerateGarbageInstructions generates random garbage instruction(s) with the specified architecture and returns the assembled bytes

GetArchitecture returns the encoder architecture

GetRandomStackAddress returns a stack address assembly referance based on the encoder architecture Ex: [esp+10] (address range is 1 byte)

SGN ASM Label Definitions; ----------------------------- {R} = RANDOM GENERAL PURPOSE REGISTER {K} = RANDOM BYTE OF DATA {L} = RANDOM ASM LABEL {G}

GetRandomBytes generates a random byte slice with given size

GetSafeRandomRegister returns a random register among all (registers-excluded parameters) based on given size

GetStackPointer returns the stack pointer register string based on the encoder architecture

AddSchemaDecoder creates decoder stub for binaries that are ciphered with SchemaCipher function. The schema array that is used on the given payload, a

Encode function is the primary encode method for SGN all nessary options and parameters are contained inside the encodder struct

NewCipherSchema generates random schema for using int the SchemaCipher function. Generated schema contains random operands and keys.

NewDecoderAssembly creates a unobfuscated decoder stub to the given encoded payload with the given architecture and seed value

SchemaCipher encodes a part of the given binary starting from the given index. Encoding done without using any loop conditions based on the schema val

Encode function is the primary encode method for SGN

AddADFLDecoder creates decoder stub for binaries that are ciphered with CipherADFL function.

AddCallOver function adds a call instruction over the end of the given payload address of the payload will be pushed to the stack and execution will c

AddJmpOver function adds a jmp instruction over the end of the given payload execution will continiou after the end of payload

CalculateAverageGarbageInstructionSize calculate the avarage size of generated random garbage instructions

CipherADFL (Additive Feedback Loop) performs a additive feedback xor operation similar to LFSR (Linear-feedback shift register) IN REVERSE ORDER !! wi

checks if a byte array contains any element of another byte array

GenerateGarbageJump generates a JMP instruction over random bytes

GetRandomMatchingOperandType randomly selects a operand type for subject instruction

GetRandomOperandValue generates a instruction parameter value based on given operand type Only some operand types are considered because SGN only uses

GetRandomSafeAssembly return a safe garbage instruction assembly

GetRandomUnsafeMnemonic returns a random unsafe instruction based on the encoder architecture and operand number/type Currently SGN only supports inst

checks if s is ascii and printable, aka doesn't include tab, backspace, etc.

RandomLabel generates a random assembly label

RandomOperand generates a random operand string

AddCondJmpOver function adds a jmp instruction over the end of the given payload execution will continiou after the end of payload

GenerateIPToStack function generates instructions series that pushes the instruction pointer to stack

GetAssemblySize assembes the given instructions and returns the total instruction size if assembly fails return value is -1

GetBasePointer returns the base pointer register string based on the encoder architecture

GetRandomFunctionAssembly generates a function frame assembly with garbage instructions inside

GetRandomUnsafeAssembly return a safe garbage instruction assembly

GetSchemaTable returns the printable encoder schema table

NewEncoder for creating new encoder structures

SetArchitecture sets the encoder architecture

Initialize the register values