La idea es buena, aunque está aplicacion ya existe, aunque está en una lengua muy rara (rumano, ruso, o algo asi)

Realmente sería igual que hacerlo manual, aunque asi ahorras mucho tiempo.

Respecto a la programación, creo que no es complicado.

Aunque bueno, algunos Troyanos como bifrost tienen muchos offsets malignos, por lo tanto, habria que partirlo en muchas partes, y luego, modificarlo...teniendo cuidado de no romper el server final.

Un saludo

Mi pregunta es... ¿qué se supone que vas a editar una vez troceado? xD
En cuanto se modifique algo el ejecutable seguramente petará o dejará de hacer lo que tenía que hacer...xD

Salvando ese punto que creo que no comprendo correctamente, el proyecto suena bien.

Estaría bueno hacer todo eso en un solo programa.
Partir el archivo automaticamente en muchas partes iguales dependiendo el tamaño original preconfigurando todo para despues darle en "Start"
Normalmente los archivos se parten con el olly (me lo enseñó octalh), y despues se escanea parte por parte para ver cuales son detectados importando la base de datos de variados antivirus como me mostraron acá:



y luego injectar bites vacios como lo hace el topo:



Puedes hacer algo así como el SSS cuando le das la ip y te hace todo solo...

Divide -> Escanea -> {los detectados: Injecta -> Escanea nuevamente -> [si aún es detectado buelve a dividirse y se debuelve a escanear y asi sucesivamente hasta que ya no es detectado y luego...][si no es detectado continua con la proxima parte detectada]} -> une

PD: no te tienen confianza jajajaja obiamente si mad expuso esta propuesta es porque lo hará y no quedará  a medias.

se pueden reconocer las instrucciones y no partirlas, es decir si detectas un mov como ultimo byte del archivo agregar los bytes necesarios para escribir toda la instruccion en un archivo y no partirla.

Raro que funcione  si lo haces con algun programa que use por ejemplo strcpy() de c que busca el 0x00 para saber hasta donde copiar te petará.
Aunque esto no tiene mucho que ver con detectar las firmas yo diria

Las firmas no tienen porque caer en el inicio de una instrucción concreta, imaginemos que el mov equivale a 9876 pues puede que la firma esté a partir del 76 y por tanto es un mov pero no tienes forma de detectar que realmente lo es a no ser que busques la entrada de la función y interpretes todas las instrucciones que puedas encontrarte por el camino hasta la firma (muchisimo trabajo)

Deacuerdo, pero un archivo concreto tendrá esa serie de instrucciones en uno o varios offsets concretos. Siempre se modifica el contenido del offset (es la secuencia)... no hay problema en eso

Ahún así el asunto parece sencillo pero no lo es tanto.
Tal y como lo plantea Mad en el primer post, sigue siendo un proceso manual, te modifica el archivo, tienes que escanear las partes y debes ir ajustando el offset hasta dar con el, para esto existe el SignatureZero de Thor que tiene además un grafico del archivo y vas moviendo el rango con una barrita to xula y tal.

Yo estoy programando lo mismo pero totalmente automatico desde hace bastante, de momento ya detecto una o varias firmas aunque tiene varios errores y me falta darle soporte para kims. Está programado en C++ pero si quieres te lo paso por privado.

Si lo haces bien no importa si es el bifrost o el que te de la gana,  con el mio he pillado las de bifrost,optix, sub7 y netdevil.

Si decides hacerlo automático yo te aconsejo mi proceso que creo que poco se le puede hacer para que sea mas eficiente, en pseudocodigo:

hacer
   mientras haya partes detectadas
       Divides el archivo en X partes
       Escaneas las partes y eliges una detectada al azar
       Disminuyes el rango hasta el de la parte detectada
   fin mientras

   mientras haya partes detectadas
       Divides el archivo en 2 partes
       Escaneas las partes, las dos a la vez nunca serán detectadas
       Ajustas el rango a la parte detectada
   fin mientras

  Reestableces el rango a la ultima parte detectada que será la mas pequeña posible en divisiones

   mientras el "incremento" sea mayor que un byte
       Sobreescribes bytes desde el inicio del rango hasta el final de "incremento" bytes en "incremento" bytes
       Ajustas el final del rango a inicio del rango+incremento
       Disminuyes el "incremento"
   fin mientras

   En este punto tenemos el byte inicial de la firma pues repetimos el proceso anterior pero desde el final del rango dado por la division mas pequeña detectada hasta el inicio de la firma

Pero ahora se plantea otro problema y es que si tenemos dos firmas podemos haber detectado el inicio de una y el final de otra.
FFAAAAAAFF
Así que se sobreescribe el rango con X asi:
XFAAAAAAFF
FXAAAAAAFF
FFXAAAAAFF
....

Si alguna parte es detectada sabemos que había dos firmas.

Lo ultimo es ya, guardar esos offsets, modificarlos para que esa firma concreta ya no siga detectandola y repetir todo el proceso hasta que el archivo con las pequeñas modificaciones deje de ser detectado.