Como conseguir el mismo fichero de compilación byte a byte.

Hola,

Dudo que se pueda realizar de ninguna oficial (es decir, que no sea
tocar el archivo a mano), pero no es cosa exclusiva ni de C# ni del .NET
Framework. La cabecera del formato PE que utilizan los ejecutables incluye
un campo TimeStamp por lo que en principio ningún compilador puede producir
dos archivos exactos en dos compilaciones sucesivas. Como mínimo siempre
deben diferir en esos cuatro bytes.

Saludos,

Juan Carlos Paramá

"Elric" escribió en el mensaje de noticias
news:

Hola,
Mi empresa pasa homologaciones del software que realizamos, de tal manera
que el software que acabamos instalando tiene que ser identico byte a byte
con el que los homologadores generan a partir de nuestro codigo fuente
original.

Estoy haciendo pruebas en csharp tanto de ejecutables como de librerias
dll
y a cada compilacion hay varias secciones que cambian. Esto hace
impossible
la generación de un checksum del software que sea el mismo de compilación
en
compilación (en caso que no haya cambios de codigo, claro ;)).

Me he fijado y parece que algunos cambios viene dados por el GUID, por la
versión autoincremental y por la fecha. Pero hay otros que no entiendo a
que
se refieren.

En resumen: Hay alguna manera "official" de conseguir que los ficheros de
salida sean identicos de compilación en compilación?.

muchas gracias.

Gracias por responder tan pronto.

Si lo de la cabecera PE ya me habia encontrado cuando haciamos software en
Visual Studio o Delphi, pero solo era eso, el timestamp.
Ahora en .Net hay más cosas.
Supongo que tendre que hacer una aplicación a post-build que use expresiones
regulares para localizar ciertas partes, como los guids, etc.. y los cambie
por otros valores. Espero que despues siga funcionando ;).


Elric / Anaconda


"Juan Carlos Paramá" wrote:

Hola,

Dudo que se pueda realizar de ninguna oficial (es decir, que no sea
tocar el archivo a mano), pero no es cosa exclusiva ni de C# ni del .NET
Framework. La cabecera del formato PE que utilizan los ejecutables incluye
un campo TimeStamp por lo que en principio ningún compilador puede producir
dos archivos exactos en dos compilaciones sucesivas. Como mínimo siempre
deben diferir en esos cuatro bytes.

Saludos,

Juan Carlos Paramá

"Elric" escribió en el mensaje de noticias
news:
> Hola,
> Mi empresa pasa homologaciones del software que realizamos, de tal manera
> que el software que acabamos instalando tiene que ser identico byte a byte
> con el que los homologadores generan a partir de nuestro codigo fuente
> original.
>
> Estoy haciendo pruebas en csharp tanto de ejecutables como de librerias
> dll
> y a cada compilacion hay varias secciones que cambian. Esto hace
> impossible
> la generación de un checksum del software que sea el mismo de compilación
> en
> compilación (en caso que no haya cambios de codigo, claro ;)).
>
> Me he fijado y parece que algunos cambios viene dados por el GUID, por la
> versión autoincremental y por la fecha. Pero hay otros que no entiendo a
> que
> se refieren.
>
> En resumen: Hay alguna manera "official" de conseguir que los ficheros de
> salida sean identicos de compilación en compilación?.
>
> muchas gracias.

Hola,

dentro de cada proyecto .net existe un archivo AssemblyInfo.cs o
AssemblyInfo.vb

Modificando sus valores puedes tener algo parecido a lo que necesitas,
aunque nunca podran ser exactamente los mismos...

Con esto puedes controlar la version, la firma digital, cultura, copyright.

Ojala te sirva de algo,

Saludos,

Wbert

"Juan Carlos Paramá" wrote:

Hola,

Dudo que se pueda realizar de ninguna oficial (es decir, que no sea
tocar el archivo a mano), pero no es cosa exclusiva ni de C# ni del .NET
Framework. La cabecera del formato PE que utilizan los ejecutables incluye
un campo TimeStamp por lo que en principio ningún compilador puede producir
dos archivos exactos en dos compilaciones sucesivas. Como mínimo siempre
deben diferir en esos cuatro bytes.

Saludos,

Juan Carlos Paramá

"Elric" escribió en el mensaje de noticias
news:
> Hola,
> Mi empresa pasa homologaciones del software que realizamos, de tal manera
> que el software que acabamos instalando tiene que ser identico byte a byte
> con el que los homologadores generan a partir de nuestro codigo fuente
> original.
>
> Estoy haciendo pruebas en csharp tanto de ejecutables como de librerias
> dll
> y a cada compilacion hay varias secciones que cambian. Esto hace
> impossible
> la generación de un checksum del software que sea el mismo de compilación
> en
> compilación (en caso que no haya cambios de codigo, claro ;)).
>
> Me he fijado y parece que algunos cambios viene dados por el GUID, por la
> versión autoincremental y por la fecha. Pero hay otros que no entiendo a
> que
> se refieren.
>
> En resumen: Hay alguna manera "official" de conseguir que los ficheros de
> salida sean identicos de compilación en compilación?.
>
> muchas gracias.

On Fri, 24 Aug 2007 12:36:00 +0200, Elric
wrote:

Hola,
Mi empresa pasa homologaciones del software que realizamos, de tal manera
que el software que acabamos instalando tiene que ser identico byte a
byte
con el que los homologadores generan a partir de nuestro codigo fuente
original.

Estoy haciendo pruebas en csharp tanto de ejecutables como de librerias
dll
y a cada compilacion hay varias secciones que cambian. Esto hace
impossible
la generación de un checksum del software que sea el mismo de
compilación en
compilación (en caso que no haya cambios de codigo, claro ;)).

Me he fijado y parece que algunos cambios viene dados por el GUID, por la
versión autoincremental y por la fecha. Pero hay otros que no entiendo a
que
se refieren.

En resumen: Hay alguna manera "official" de conseguir que los ficheros de
salida sean identicos de compilación en compilación?.

muchas gracias.

Si son igual de rigurosos como los que yo a veces tengo que homologar...
No te van a aceptar que modifiques después de compilar a no ser que les
demuestres fehacientemente qué estás tocando de forma binaria... Y depende
de quién te toque, pues te pasará cualquier cosa o no te pasará
absolutamente nada.

Yo suelo convencerlos -lo que pasa es que no es para PC- diciendo que
marco el ejecutable con una firma... que toca el timestamp y varias
variables que yo mismo he creado en el script del linker.


En C# (vamos, en .NET) no lo he hecho nunca, pero existe una cosa que se
llama "linker script" que es una serie de macros e instrucciones que le
dicen al linker qué y dónde poner las cosas. Todos los programas lo
tienen, aunque no sea visible. En C++ nativo sí que está accesible, eso y
el startup para que lo modifiques y hagas cualquier cosa. Supongo que el
.NET tenga algo parecido, quizás sea el AssemblyInfo, pero seguro que
existe alguna forma de crear un script que le diga al liner el tamaño de
la pila, los diferentes segmentos y todo eso, y que diga que ponga como
stamps algunos números fijos en lugar de variables... ahora falta
encontrar eso.
Visita mi blog principal: http://rfog.blogsome.com
Y este sobre programación: http://geeks.ms/blogs/rfog
Libros, ciencia ficción y programación
La única forma de no darle a un árbol es apuntar a el.

Al final lo he podido reducir a solo el TimeStamp de la cabecera del PE y a
unos 16 bytes que varian no se porque en medio de los ficheros.
Es solucionable, porque se puede detectar, ya que los 18 bytes que vienen
despues son siempre los mismos, y puestos a 0 no pasa nada

Me da la impresión que tiene que ser algun tipo de GUID en binario, porque
por el contenido adyacente parece el final de la parte de datos.

Los passos para reducirlo asi, han sido los siguientes:
- Properties-Build-Advanced-Debug Info = none (Solo en el Release)
- En el Assembly.cs el [assembly: ComVisible(false)] a true, porque sino no
hace caso del GUID y auto-genera uno.

Solo con eso tambien quita un par de timestamps que estaban delante del GUID
y de lo del Debug Info.

Elric / Anaconda


"Wbert" wrote:

Hola,

dentro de cada proyecto .net existe un archivo AssemblyInfo.cs o
AssemblyInfo.vb

Modificando sus valores puedes tener algo parecido a lo que necesitas,
aunque nunca podran ser exactamente los mismos...

Con esto puedes controlar la version, la firma digital, cultura, copyright.

Ojala te sirva de algo,

Saludos,

Wbert

"Juan Carlos Paramá" wrote:

> Hola,
>
> Dudo que se pueda realizar de ninguna oficial (es decir, que no sea
> tocar el archivo a mano), pero no es cosa exclusiva ni de C# ni del .NET
> Framework. La cabecera del formato PE que utilizan los ejecutables incluye
> un campo TimeStamp por lo que en principio ningún compilador puede producir
> dos archivos exactos en dos compilaciones sucesivas. Como mínimo siempre
> deben diferir en esos cuatro bytes.
>
> Saludos,
>
> Juan Carlos Paramá
>
> "Elric" escribió en el mensaje de noticias
> news:
> > Hola,
> > Mi empresa pasa homologaciones del software que realizamos, de tal manera
> > que el software que acabamos instalando tiene que ser identico byte a byte
> > con el que los homologadores generan a partir de nuestro codigo fuente
> > original.
> >
> > Estoy haciendo pruebas en csharp tanto de ejecutables como de librerias
> > dll
> > y a cada compilacion hay varias secciones que cambian. Esto hace
> > impossible
> > la generación de un checksum del software que sea el mismo de compilación
> > en
> > compilación (en caso que no haya cambios de codigo, claro ;)).
> >
> > Me he fijado y parece que algunos cambios viene dados por el GUID, por la
> > versión autoincremental y por la fecha. Pero hay otros que no entiendo a
> > que
> > se refieren.
> >
> > En resumen: Hay alguna manera "official" de conseguir que los ficheros de
> > salida sean identicos de compilación en compilación?.
> >
> > muchas gracias.
>
>