Portable Executable - Historial de revisiones

Hariseldon: se elimino la plantilla errónea VT

2021-11-27T06:34:00Z

se elimino la plantilla errónea VT

Javiermartin jc: Texto reemplazado: «
» por «»

2019-07-06T20:49:55Z

Texto reemplazado: «<div align="justify">» por «»

Nerisleidis ciget.hol en 15:18 8 feb 2019

2019-02-08T15:18:23Z

Josefina en 15:03 26 dic 2018

2018-12-26T15:03:25Z

Adrianrp1988: remover error

2018-12-11T14:04:55Z

remover error

Adrianrp1988: Página creada con «{{Infobox file format | name = Portable Executable | icon = | extension = `.cpl`, `.exe`, `.dll`, `.ocx`, `.sys`, `.scr`, `.dr…»`

2018-12-11T14:04:10Z Página creada con «{{Infobox file format | name = Portable Executable | icon = | extension = <tt>.cpl</tt>, <tt>.exe</tt>, <tt>.dll</tt>, <tt>.ocx</tt>, <tt>.sys</tt>, <tt>.scr</tt>, <tt>.dr…» Página nueva {{Infobox file format | name = Portable Executable | icon = | extension = <tt>.cpl</tt>, <tt>.exe</tt>, <tt>.dll</tt>, <tt>.ocx</tt>, <tt>.sys</tt>, <tt>.scr</tt>, <tt>.drv</tt> | mime = | owner = [[Microsoft]] | genre = [[Archivo binario|Binario]], [[ejecutable]], [[código objeto]], [[bibliotecas compartidas]] | extendido_de = [[DOS MZ executable]],<br />[[COFF]] | containerfor = | containedby = | standard = [http://msdn.microsoft.com/library/windows/hardware/gg463125 Microsoft PE and COFF Specification (ver. 8)] | número_mágico = MZ }} El formato '''Portable Executable''' (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON,<ref>{{cita web|url=http://www.chiark.greenend.org.uk/~sgtatham/fonts/|título=mkwinfont|apellido=Tatham|nombre=Simon|fechaacceso=31 de octubre de 2012|idioma=inglés}}</ref> y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]]. El término «portable» refiere a la versatilidad del formato en numerosos ambientes de arquitecturas de software de sistema operativo.<ref name=MSOfficialDocAboutPE>{{cita web|url=http://support.microsoft.com/?id=121460|título=Formato Common Object File (Format COFF)|editor=[[Microsoft]]|obra=Microsoft Support|fecha=1º de noviembre de 2006|fechaacceso=5 de abril de 2013}}</ref> El formato PE es una estructura de datos que encapsula la información necesaria para el cargador de Windows para administrar el código ejecutable que le envuelve. Esto incluye las referencias hacia las bibliotecas de enlace dinámico para el enlazado, la importación y exportación de las tablas de la [[Application programming interface|API]], gestión de los datos de los recursos y los datos de almacenamiento local de subprocesos (datos de TLS). En sistemas operativos basados en [[Windows NT]], el formato PE es usado para [[EXE]], [[DLL]], [[.sys|SYS]] ([[controladores de dispositivo]]), y otros tipos de archivo. La especificación [[Extensible Firmware Interface]] (EFI) indica que PE es el formato estándar para ejecutables en entornos EFI. PE es una versión modificada de el formato [[COFF]] de Unix. Además, '''PE/COFF''' es un nombre alternativo en el desarrollo de Windows. En sistemas operativos Windows NT, actualmente PE soporta los [[Conjunto de instrucciones|conjuntos de instrucciones (ISA)]] de [[IA-32]], [[IA-64]], y [[x86-64]] (AMD/Intel64). Previo a [[Windows 2000]], Windows NT (y por tanto PE) soportaban los conjuntos de instrucciones [[MIPS]], [[DEC Alpha]] y [[PowerPC]]. Ya que PE es usado en [[Windows CE]], este continua soportando diversas variantes de las arquitecturas MIPS, [[Arquitectura ARM|ARM]] (incluyendo a Thumb), y [[SuperH]]. Los principales competidores de PE son [[Executable and Linkable Format|ELF]] (usado en [[Linux]] y muchos otros sistemas [[Unix-like|tipo Unix]]) y [[Mach-O]] (usado en [[Mac OS X]]). == Historia == Microsoft migró al formato PE con la introducción del sistema operativo [[Windows NT 3.1]]. Todas las versiones posteriores de Windows, incluyendo Windows 95, 98, y ME, soportan la estructura de archivo PE. El formato conservó un soporte limitado heredado para cerrar la brecha entre los sistemas basados en DOS y sistemas basados en NT. Por ejemplo, las cabeceras de PE/COFF todavía incluyen un programa ejecutable MS-DOS, que por defecto es un trozo que muestra el sencillo mensaje «This program cannot be run in DOS mode» (o similar).<ref name=MSOfficialDocAboutPE/> También PE sigue atendiendo a la cambiante plataforma Windows. Entre las extensiones se encuentra el formato PE .NET ([[#.NET, metadatos y el formato PE|véase más abajo]]), una versión para binarios de 64 bits llamada PE32+ (o a veces PE+), y una especificación para Windows CE. == Detalles técnicos == [[File:Diagram PE (es).png|right|thumb|145px|]] === Diseño === Un archivo PE consiste de una serie de cabeceras y secciones que indican al enlazador dinámico cómo asignar el archivo en memoria. Una imagen ejecutable consta de varias zonas diferentes, cada una de las cuales requieren diferente protección de memoria, por lo que el inicio de cada sección debe estar alineado a un límite de página. Por ejemplo, generalmente la sección <tt>.text</tt> (que contiene código de programa) es mapeado como «ejecutar/sólo lectura», y la sección <tt>.data</tt> (que contiene las variables globales) es mapeado como «no-ejecutar/lectura-escritura». Sin embargo, para evitar el desperdicio de espacio, las diferentes secciones no son alineadas en página en disco. Parte del trabajo del enlazador dinámico es mapear cada sección en memoria de manera individual y asignar los permisos correctos para las regiones resultantes, de acuerdo con las instrucciones que se encuentran en las cabeceras. === Tabla de secciones === La tabla de secciones se encuentra justo detrás de la cabecera PE. Esta es una tabla que contiene varias estructuras '''IMAGE_SECTION_HEADER'''. Estas estructuras contienen información sobre las secciones de los binarios para ser cargados en la memoria. El campo '''NumberOfSections''' de la estructura '''IMAGE_FILE_HEADER''' indica cuantas entradas hay en la tabla. El máximo soportado por Windows es de 96 secciones. Un prototipo de una tabla de secciones se ve de la siguiente manera: <source lang=C> typedef struct _IMAGE_SECTION_HEADER { BYTE Name[IMAGE_SIZEOF_SHORT_NAME]; union { DWORD PhysicalAddress; DWORD VirtualSize; } Misc; DWORD VirtualAddress; DWORD SizeOfRawData; DWORD PointerToRawData; DWORD PointerToRelocations; DWORD PointerToLinenumbers; WORD NumberOfRelocations; WORD NumberOfLinenumbers; DWORD Characteristics; } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; </source> Cada sección tiene un nombre de 8 caracteres; este nombre no es significativo, pero normalmente se puede encontrar lo siguiente: {| class="wikitable" style="text-align:center; width:65%;" |- ! Nombre !! Descripción |- | .text | El código (instrucciones) del programa |- | .bss | Las variables no inicializadas |- | .reloc | La tabla de relocalizaciones |- | .data | Las variables inicializadas |- | .rsrc | Los recursos del archivo (cursores, sonidos, menús...) |- | .rdata | Los datos de solo lectura |- | .idata | La tabla de importación |- | .upx | Firma de una compresión UPX, propio de software UPX |- |- | .aspack | Firma de un paquete ASPACK, propio de software ASPACK |- |- | .adata | Firma de un paquete ASPACK, propio de software ASPACK |- |} === Tabla IMPORT === Una sección a mencionar es la tabla de importación de direcciones (en inglés ''import address table'' o IAT), que se usa como una tabla de búsqueda cuando la aplicación llama una función en un módulo diferente. Esto puede darse en forma de importación por ordinal o importación por nombre. Debido a que un programa compilado no puede conocer la ubicación en memoria de las bibliotecas de las que depende directamente, cada vez que se hace una llamada a la API es necesario un salto indirecto. Como el enlazador dinámico carga los módulos y los une, este escribe la dirección actuales en las ranuras IAT, de manera que apuntan a las ubicaciones de memoria correspondientes de la biblioteca de funciones. Aunque esto agrega un salto adicional en el costo de una llamada intra-módulo que resulta en una reducción del rendimiento, ofrece una ventaja clave: se reduce al mínimo el número de páginas de memoria que necesitan ser cambiados [[copy-on-write]] por el cargador, ahorrando memoria y tiempo de I/O de disco. Si el compilador conoce de antemano que será una llamada inter-módulo (mediante el atributo <tt>dllimport</tt>) puede producir código más optimizado que simplemente se traduce en una llamada indirecta [[opcode]]. === Relocalizaciones === Los archivos PE no contienen [[código independiente de la posición]]. En su lugar son compilados a una ''dirección base'' preferida, y todas las direcciones emitidas por el compilador/enlazador se fijan previamente. Si un archivo PE no puede ser cargado en su dirección preferida (porque ya fue tomada por algo más), el sistema operativo lo reajustará. Esto implica recalcular cada dirección absoluta y modificar el código para utilizar los nuevos valores. El cargador lo realiza comparando las direcciones de carga actual y preferida, y calculando un valor [[Delta encoding|delta]]. Esto se añade a continuación a la dirección preferida para llegar a la nueva dirección de la localización de memoria. Las relocalizaciones base son almacenadas en una lista y añadidas, cuando sea necesario, a una posición de memoria existente. El código resultante ahora es privado al proceso y no es más compartido, por lo que muchos de los beneficios de ahorro de memoria de las DLLs se pierden en este escenario. También retrasa la carga del módulo de manera significativa. Por esta razón, el reajuste es evitado siempre que sea posible, y las DLL proporcionadas por Microsoft tienen direcciones base pre-calculadas de manera que no se superpongan. Por lo tanto, en el caso de no reajuste, PE ofrece la ventaja de un código muy eficiente, pero en presencia de reajuste, el éxito en el uso de memoria puede ser costoso. Esto contrasta con ELF, que utiliza código totalmente independiente de la posición y una tabla de desplazamiento global, que abandona tiempo en ejecución contra el uso de memoria en favor de estos últimos. == .NET, metadatos y el formato PE == {{VT|Metadatos .NET}} [[.NET Framework]] de Microsoft ha ampliado el formato PE con características que soportan el [[Common Language Runtime]] (CLR). Entre las características añadidas se encuentra las secciones de cabecera CLR y datos CLR. Al cargar un binario, el cargador del sistema operativo cede la ejecución a CLR mediante una referencia en la tabla IMPORT de PE/COFF. Entonces CLR carga las secciones CLR cabecera y datos. La sección de datos de {{abreviación|CLR|Common Language Runtime}} contiene dos segmentos importantes, código de metadatos y código de Intermediate Language (IL): * Los metadatos contienen información relevante para el ensamblado, incluyendo el manifiesto de ensamblado. Un manifiesto describe el ensamblado en detalle, incluyendo la identificación única (mediante un ''hash'', número de versión, etc.), datos en componentes exportados, información de tipo extensivo (soportado por el Common Type System (CTS)), referencias externas, y una lista de archivos dentro del ensamblado. El entorno CLR hace un uso amplio de los metadatos.<ref name=MSDN_MetadataAndPEStruct>{{cita web|url=http://msdn.microsoft.com/es-es/library/8dkk3ek4.aspx|título=Metadatos y la estructura del archivo PE|editor=[[Microsoft]]|obra=[[MSDN Library]]|fechaacceso=5 de abril de 2013}}</ref> * El código {{abreviación|IL|Intermediate Language}} es un código abstracto e independiente del lenguaje que satisface los requisitos del [[Common Intermediate Languge]] (CIL) del {{abreviación|CLR|Common Language Runtime}}. El término «''intermediate''» (en español «intermedio») se refiere a la naturaleza compatible entre lenguajes y entre plataformas del código {{abreviación|IL|Intermediate Language}}. Este ''lenguaje intermedio'', similar a [[Java bytecode]], permite a las plataformas y a los lenguajes soportar el {{abreviación|CLR|Common Language Runtime}} común. {{abreviación|IL|Intermediate Language}} soporta la [[programación orientada a objetos]] (polimorfismo, herencia, tipos abstractos, etc.), excepciones, eventos, y varias estructuras de datos. == Uso en otros sistemas operativos == El formato PE también es usado por [[ReactOS]], ya que este sistema operativo tiene la intención de ser compatible a nivel binario con Windows. El formato PE también ha sido utilizado históricamente por unos cuantos sistemas operativos, entre ellos [[SkyOS]] y [[BeOS]] R3. Sin embargo tanto SkyOS como BeOS se trasladaron al formato [[Executable and Linkable Format|ELF]]. Como la [[Proyecto Mono|plataforma de desarrollo Mono]] está diseñado para ser compatible a nivel binario con [[Microsoft .NET]], usa el mismo formato PE de la implementación de Microsoft. En sistemas operativos [[Unix-like|similares a Unix]] de [[x86|32 bits]], algunos binarios de Windows (en formato PE) pueden ser ejecutados con [[Wine]]. [[HX DOS Extender]] también usa el formato PE para los binarios nativos de 32 bit de DOS, además de que se puede, hasta cierto grado, ejecutar binarios de Windows existentes en DOS, así actuando como si fuera un [[Wine]] para DOS. Mac OS X 10.5 tiene la capacidad de cargar y analizar archivos PE, pero no es compatible a nivel binario con Windows.<ref name="chartier">{{cita web|apellido=Chartier |nombre=David |título=Uncovered: Evidence that Mac OS X could run Windows apps soon |obra=Ars Technica |url=http://arstechnica.com/journals/apple.ars/2007/11/30/uncovered-evidence-that-mac-os-x-could-run-windows-apps-soon |fecha=30 de noviembre de 2007 |fechaacceso=3 de diciembre de 2007 |cita=... Steven Edwards describes the discovery that Leopard apparently contains an undocumented loader for Portable Executables, a type of file used in 32-bit and 64-bit versions of Windows. More poking around revealed that Leopard's own loader tries to find Windows DLL files when attempting to load a Windows binary.}}</ref> == Referencias == {{listaref}} == Véase también == * [[Anexo:Comparación de formatos de archivos ejecutables]] * [[EXE]] == Enlaces externos == * [http://go.microsoft.com/fwlink/?LinkId=93292 Microsoft Portable Executable and Common Object File Format Specification] (en inglés). Microsoft Development Network. * [http://msdn.microsoft.com/en-us/library/ms809762 Peering Inside the PE: A Tour of the Win32 Portable Executable File Format] (en inglés). Microsoft Development Network. [[Categoría:Formatos de archivos informáticos]] [[Categoría:Formatos de archivos ejecutables]]

@@ Línea 5: / Línea 5: @@
 |concepto=El formato Portable Executable (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON, y otros usados en versiones de 32 bit y 64 bit del sistema operativo Microsoft Windows.
 }}
-<div align="justify">
 '''Portable Executable''' (PE). Es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]].

← Revisión anterior		Revisión del 15:03 26 dic 2018
Línea 1:		Línea 1:
		+	<div align="justify">
		+	{{Normalizar}}
		+
	El formato '''Portable Executable''' (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON,<ref>{{cita web\|url=http://www.chiark.greenend.org.uk/~sgtatham/fonts/\|título=mkwinfont\|apellido=Tatham\|nombre=Simon\|fechaacceso=31 de octubre de 2012\|idioma=inglés}}</ref> y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]]. El término «portable» refiere a la versatilidad del formato en numerosos ambientes de arquitecturas de software de sistema operativo.<ref name="MSOfficialDocAboutPE">{{cita web\|url=http://support.microsoft.com/?id=121460\|título=Formato Common Object File (Format COFF)\|editor=[[Microsoft]]\|obra=Microsoft Support\|fecha=1º de noviembre de 2006\|fechaacceso=5 de abril de 2013}}</ref> El formato PE es una estructura de datos que encapsula la información necesaria para el cargador de Windows para administrar el código ejecutable que le envuelve. Esto incluye las referencias hacia las bibliotecas de enlace dinámico para el enlazado, la importación y exportación de las tablas de la [[Application programming interface\|API]], gestión de los datos de los recursos y los datos de almacenamiento local de subprocesos (datos de TLS). En sistemas operativos basados en [[Windows NT]], el formato PE es usado para [[EXE]], [[DLL]], [[.sys\|SYS]] ([[controladores de dispositivo]]), y otros tipos de archivo. La especificación [[Extensible Firmware Interface]] (EFI) indica que PE es el formato estándar para ejecutables en entornos EFI.		El formato '''Portable Executable''' (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON,<ref>{{cita web\|url=http://www.chiark.greenend.org.uk/~sgtatham/fonts/\|título=mkwinfont\|apellido=Tatham\|nombre=Simon\|fechaacceso=31 de octubre de 2012\|idioma=inglés}}</ref> y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]]. El término «portable» refiere a la versatilidad del formato en numerosos ambientes de arquitecturas de software de sistema operativo.<ref name="MSOfficialDocAboutPE">{{cita web\|url=http://support.microsoft.com/?id=121460\|título=Formato Common Object File (Format COFF)\|editor=[[Microsoft]]\|obra=Microsoft Support\|fecha=1º de noviembre de 2006\|fechaacceso=5 de abril de 2013}}</ref> El formato PE es una estructura de datos que encapsula la información necesaria para el cargador de Windows para administrar el código ejecutable que le envuelve. Esto incluye las referencias hacia las bibliotecas de enlace dinámico para el enlazado, la importación y exportación de las tablas de la [[Application programming interface\|API]], gestión de los datos de los recursos y los datos de almacenamiento local de subprocesos (datos de TLS). En sistemas operativos basados en [[Windows NT]], el formato PE es usado para [[EXE]], [[DLL]], [[.sys\|SYS]] ([[controladores de dispositivo]]), y otros tipos de archivo. La especificación [[Extensible Firmware Interface]] (EFI) indica que PE es el formato estándar para ejecutables en entornos EFI.

@@ Línea 99: / Línea 99: @@
 == .NET, metadatos y el formato PE ==
-{{VT|Metadatos .NET}}
+Metadatos .NET
 [[.NET Framework]] de Microsoft ha ampliado el formato PE con características que soportan el [[Common Language Runtime]] (CLR). Entre las características añadidas se encuentra las secciones de cabecera CLR y datos CLR. Al cargar un binario, el cargador del sistema operativo cede la ejecución a CLR mediante una referencia en la tabla IMPORT de PE/COFF. Entonces CLR carga las secciones CLR cabecera y datos.

@@ Línea 1: / Línea 1: @@
 <div align="justify">
-El formato '''Portable Executable''' (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON,<ref>{{cita web|url=http://www.chiark.greenend.org.uk/~sgtatham/fonts/|título=mkwinfont|apellido=Tatham|nombre=Simon|fechaacceso=31 de octubre de 2012|idioma=inglés}}</ref> y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]]. El término «portable» refiere a la versatilidad del formato en numerosos ambientes de arquitecturas de software de sistema operativo.<ref name="MSOfficialDocAboutPE">{{cita web|url=http://support.microsoft.com/?id=121460|título=Formato Common Object File (Format COFF)|editor=[[Microsoft]]|obra=Microsoft Support|fecha=1º de noviembre de 2006|fechaacceso=5 de abril de 2013}}</ref> El formato PE es una estructura de datos que encapsula la información necesaria para el cargador de Windows para administrar el código ejecutable que le envuelve. Esto incluye las referencias hacia las bibliotecas de enlace dinámico para el enlazado, la importación y exportación de las tablas de la [[Application programming interface|API]], gestión de los datos de los recursos y los datos de almacenamiento local de subprocesos (datos de TLS). En sistemas operativos basados en [[Windows NT]], el formato PE es usado para [[EXE]], [[DLL]], [[.sys|SYS]] ([[controladores de dispositivo]]), y otros tipos de archivo. La especificación [[Extensible Firmware Interface]] (EFI) indica que PE es el formato estándar para ejecutables en entornos EFI.
+'''Portable Executable''' (PE). Es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]].
 PE es una versión modificada de el formato [[COFF]] de Unix. Además, '''PE/COFF''' es un nombre alternativo en el desarrollo de Windows.
@@ Línea 11: / Línea 19: @@
 == Historia ==
-Microsoft migró al formato PE con la introducción del sistema operativo [[Windows NT 3.1]]. Todas las versiones posteriores de Windows, incluyendo Windows 95, 98, y ME, soportan la estructura de archivo PE. El formato conservó un soporte limitado heredado para cerrar la brecha entre los sistemas basados en DOS y sistemas basados en NT. Por ejemplo, las cabeceras de PE/COFF todavía incluyen un programa ejecutable MS-DOS, que por defecto es un trozo que muestra el sencillo mensaje «This program cannot be run in DOS mode» (o similar).<ref name="MSOfficialDocAboutPE" /> También PE sigue atendiendo a la cambiante plataforma Windows. Entre las extensiones se encuentra el formato PE .NET ([[#.NET, metadatos y el formato PE|véase más abajo]]), una versión para binarios de 64 bits llamada PE32+ (o a veces PE+), y una especificación para Windows CE.
+Microsoft migró al formato PE con la introducción del sistema operativo [[Windows NT 3.1]]. Todas las versiones posteriores de Windows, incluyendo Windows 95, 98, y ME, soportan la estructura de archivo PE. El formato conservó un soporte limitado heredado para cerrar la brecha entre los sistemas basados en DOS y sistemas basados en NT. Por ejemplo, las cabeceras de PE/COFF todavía incluyen un programa ejecutable MS-DOS, que por defecto es un trozo que muestra el sencillo mensaje «This program cannot be run in DOS mode» (o similar). También PE sigue atendiendo a la cambiante plataforma Windows. Entre las extensiones se encuentra el formato PE .NET ([[#.NET, metadatos y el formato PE|véase más abajo]]), una versión para binarios de 64 bits llamada PE32+ (o a veces PE+), y una especificación para Windows CE.
 == Detalles técnicos ==
 [[File:Diagram PE (es).png|right|thumb|145px|<!-- Estructura interna de un archivo en formato PE. -->]]
-=== Diseño ===
 Un archivo PE consiste de una serie de cabeceras y secciones que indican al enlazador dinámico cómo asignar el archivo en memoria. Una imagen ejecutable consta de varias zonas diferentes, cada una de las cuales requieren diferente protección de memoria, por lo que el inicio de cada sección debe estar alineado a un límite de página. Por ejemplo, generalmente la sección <tt>.text</tt> (que contiene código de programa) es mapeado como «ejecutar/sólo lectura», y la sección <tt>.data</tt> (que contiene las variables globales) es mapeado como «no-ejecutar/lectura-escritura». Sin embargo, para evitar el desperdicio de espacio, las diferentes secciones no son alineadas en página en disco. Parte del trabajo del enlazador dinámico es mapear cada sección en memoria de manera individual y asignar los permisos correctos para las regiones resultantes, de acuerdo con las instrucciones que se encuentran en las cabeceras.
-=== Tabla de secciones ===
+''' Tabla de secciones '''.
 La tabla de secciones se encuentra justo detrás de la cabecera PE. Esta es una tabla que contiene varias estructuras '''IMAGE_SECTION_HEADER'''. Estas estructuras contienen información sobre las secciones de los binarios para ser cargados en la memoria.
@@ Línea 83: / Línea 92: @@
 |}
-=== Tabla IMPORT ===
+''' Tabla IMPORT '''.
 Una sección a mencionar es la tabla de importación de direcciones (en inglés ''import address table'' o IAT), que se usa como una tabla de búsqueda cuando la aplicación llama una función en un módulo diferente. Esto puede darse en forma de importación por ordinal o importación por nombre. Debido a que un programa compilado no puede conocer la ubicación en memoria de las bibliotecas de las que depende directamente, cada vez que se hace una llamada a la API es necesario un salto indirecto. Como el enlazador dinámico carga los módulos y los une, este escribe la dirección actuales en las ranuras IAT, de manera que apuntan a las ubicaciones de memoria correspondientes de la biblioteca de funciones. Aunque esto agrega un salto adicional en el costo de una llamada intra-módulo que resulta en una reducción del rendimiento, ofrece una ventaja clave: se reduce al mínimo el número de páginas de memoria que necesitan ser cambiados [[copy-on-write]] por el cargador, ahorrando memoria y tiempo de I/O de disco. Si el compilador conoce de antemano que será una llamada inter-módulo (mediante el atributo <tt>dllimport</tt>) puede producir código más optimizado que simplemente se traduce en una llamada indirecta [[opcode]].
-=== Relocalizaciones ===
+''' Relocalizaciones '''.
 Los archivos PE no contienen [[código independiente de la posición]]. En su lugar son compilados a una ''dirección base'' preferida, y todas las direcciones emitidas por el compilador/enlazador se fijan previamente. Si un archivo PE no puede ser cargado en su dirección preferida (porque ya fue tomada por algo más), el sistema operativo lo reajustará. Esto implica recalcular cada dirección absoluta y modificar el código para utilizar los nuevos valores. El cargador lo realiza comparando las direcciones de carga actual y preferida, y calculando un valor [[Delta encoding|delta]]. Esto se añade a continuación a la dirección preferida para llegar a la nueva dirección de la localización de memoria. Las relocalizaciones base son almacenadas en una lista y añadidas, cuando sea necesario, a una posición de memoria existente. El código resultante ahora es privado al proceso y no es más compartido, por lo que muchos de los beneficios de ahorro de memoria de las DLLs se pierden en este escenario. También retrasa la carga del módulo de manera significativa. Por esta razón, el reajuste es evitado siempre que sea posible, y las DLL proporcionadas por Microsoft tienen direcciones base pre-calculadas de manera que no se superpongan. Por lo tanto, en el caso de no reajuste, PE ofrece la ventaja de un código muy eficiente, pero en presencia de reajuste, el éxito en el uso de memoria puede ser costoso. Esto contrasta con ELF, que utiliza código totalmente independiente de la posición y una tabla de desplazamiento global, que abandona tiempo en ejecución contra el uso de memoria en favor de estos últimos.
@@ Línea 94: / Línea 103: @@
 La sección de datos de {{abreviación|CLR|Common Language Runtime}} contiene dos segmentos importantes, código de metadatos y código de Intermediate Language (IL):
-* Los metadatos contienen información relevante para el ensamblado, incluyendo el manifiesto de ensamblado. Un manifiesto describe el ensamblado en detalle, incluyendo la identificación única (mediante un ''hash'', número de versión, etc.), datos en componentes exportados, información de tipo extensivo (soportado por el Common Type System (CTS)), referencias externas, y una lista de archivos dentro del ensamblado. El entorno CLR hace un uso amplio de los metadatos.<ref name="MSDN_MetadataAndPEStruct">{{cita web|url=http://msdn.microsoft.com/es-es/library/8dkk3ek4.aspx|título=Metadatos y la estructura del archivo PE|editor=[[Microsoft]]|obra=[[MSDN Library]]|fechaacceso=5 de abril de 2013}}</ref>
+* Los metadatos contienen información relevante para el ensamblado, incluyendo el manifiesto de ensamblado. Un manifiesto describe el ensamblado en detalle, incluyendo la identificación única (mediante un ''hash'', número de versión, etc.), datos en componentes exportados, información de tipo extensivo (soportado por el Common Type System (CTS)), referencias externas, y una lista de archivos dentro del ensamblado. El entorno CLR hace un uso amplio de los metadatos.
 * El código {{abreviación|IL|Intermediate Language}} es un código abstracto e independiente del lenguaje que satisface los requisitos del [[Common Intermediate Languge]] (CIL) del {{abreviación|CLR|Common Language Runtime}}. El término «''intermediate''» (en español «intermedio») se refiere a la naturaleza compatible entre lenguajes y entre plataformas del código {{abreviación|IL|Intermediate Language}}. Este ''lenguaje intermedio'', similar a [[Java bytecode]], permite a las plataformas y a los lenguajes soportar el {{abreviación|CLR|Common Language Runtime}} común. {{abreviación|IL|Intermediate Language}} soporta la [[programación orientada a objetos]] (polimorfismo, herencia, tipos abstractos, etc.), excepciones, eventos, y varias estructuras de datos.
@@ Línea 104: / Línea 113: @@
 En sistemas operativos [[Unix-like|similares a Unix]] de [[x86|32 bits]], algunos binarios de Windows (en formato PE) pueden ser ejecutados con [[Wine]]. [[HX DOS Extender]] también usa el formato PE para los binarios nativos de 32 bit de DOS, además de que se puede, hasta cierto grado, ejecutar binarios de Windows existentes en DOS, así actuando como si fuera un [[Wine]] para DOS.
-Mac OS X 10.5 tiene la capacidad de cargar y analizar archivos PE, pero no es compatible a nivel binario con Windows.<ref name="chartier">{{cita web|apellido=Chartier |nombre=David |título=Uncovered: Evidence that Mac OS X could run Windows apps soon |obra=Ars Technica |url=http://arstechnica.com/journals/apple.ars/2007/11/30/uncovered-evidence-that-mac-os-x-could-run-windows-apps-soon |fecha=30 de noviembre de 2007 |fechaacceso=3 de diciembre de 2007 |cita=...&nbsp;Steven Edwards describes the discovery that Leopard apparently contains an undocumented loader for Portable Executables, a type of file used in 32-bit and 64-bit versions of Windows. More poking around revealed that Leopard's own loader tries to find Windows DLL files when attempting to load a Windows binary.}}</ref>
+Mac OS X 10.5 tiene la capacidad de cargar y analizar archivos PE, pero no es compatible a nivel binario con Windows.
 == Véase también ==
 * [[Anexo:Comparación de formatos de archivos ejecutables]]
 * [[EXE]]
-== Enlaces externos ==
+== Fuente==
-* [http://go.microsoft.com/fwlink/?LinkId=93292 Microsoft Portable Executable and Common Object File Format Specification] (en inglés). Microsoft Development Network.
+*Portable Executable[https://es.wikipedia.org/wiki/Portable_Executable]. Consultado 09/02/2019
-* [http://msdn.microsoft.com/en-us/library/ms809762 Peering Inside the PE: A Tour of the Win32 Portable Executable File Format] (en inglés). Microsoft Development Network.
+*Portable Executable File Format – A Reverse Engineer View[http://www.stonedcoder.org/~kd/lib/CBJ-2005-74.pdf]. Consultado 09/02/2019
+[[Categoría: Informática]]
-[[Categoría:Formatos de archivos informáticos]]
+[[Categoría:Programación]]

@@ Línea 1: / Línea 1: @@
-{{Infobox file format
+El formato '''Portable Executable''' (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON,<ref>{{cita web|url=http://www.chiark.greenend.org.uk/~sgtatham/fonts/|título=mkwinfont|apellido=Tatham|nombre=Simon|fechaacceso=31 de octubre de 2012|idioma=inglés}}</ref> y otros usados en versiones de 32 bit y 64 bit del sistema operativo [[Microsoft Windows]]. El término «portable» refiere a la versatilidad del formato en numerosos ambientes de arquitecturas de software de sistema operativo.<ref name="MSOfficialDocAboutPE">{{cita web|url=http://support.microsoft.com/?id=121460|título=Formato Common Object File (Format COFF)|editor=[[Microsoft]]|obra=Microsoft Support|fecha=1º de noviembre de 2006|fechaacceso=5 de abril de 2013}}</ref> El formato PE es una estructura de datos que encapsula la información necesaria para el cargador de Windows para administrar el código ejecutable que le envuelve. Esto incluye las referencias hacia las bibliotecas de enlace dinámico para el enlazado, la importación y exportación de las tablas de la [[Application programming interface|API]], gestión de los datos de los recursos y los datos de almacenamiento local de subprocesos (datos de TLS). En sistemas operativos basados en [[Windows NT]], el formato PE es usado para [[EXE]], [[DLL]], [[.sys|SYS]] ([[controladores de dispositivo]]), y otros tipos de archivo. La especificación [[Extensible Firmware Interface]] (EFI) indica que PE es el formato estándar para ejecutables en entornos EFI.
 PE es una versión modificada de el formato [[COFF]] de Unix. Además, '''PE/COFF''' es un nombre alternativo en el desarrollo de Windows.
@@ Línea 21: / Línea 8: @@
 == Historia ==
-Microsoft migró al formato PE con la introducción del sistema operativo [[Windows NT 3.1]]. Todas las versiones posteriores de Windows, incluyendo Windows 95, 98, y ME, soportan la estructura de archivo PE. El formato conservó un soporte limitado heredado para cerrar la brecha entre los sistemas basados en DOS y sistemas basados en NT. Por ejemplo, las cabeceras de PE/COFF todavía incluyen un programa ejecutable MS-DOS, que por defecto es un trozo que muestra el sencillo mensaje «This program cannot be run in DOS mode» (o similar).<ref name=MSOfficialDocAboutPE/> También PE sigue atendiendo a la cambiante plataforma Windows. Entre las extensiones se encuentra el formato PE .NET ([[#.NET, metadatos y el formato PE|véase más abajo]]), una versión para binarios de 64 bits llamada PE32+ (o a veces PE+), y una especificación para Windows CE.
+Microsoft migró al formato PE con la introducción del sistema operativo [[Windows NT 3.1]]. Todas las versiones posteriores de Windows, incluyendo Windows 95, 98, y ME, soportan la estructura de archivo PE. El formato conservó un soporte limitado heredado para cerrar la brecha entre los sistemas basados en DOS y sistemas basados en NT. Por ejemplo, las cabeceras de PE/COFF todavía incluyen un programa ejecutable MS-DOS, que por defecto es un trozo que muestra el sencillo mensaje «This program cannot be run in DOS mode» (o similar).<ref name="MSOfficialDocAboutPE" /> También PE sigue atendiendo a la cambiante plataforma Windows. Entre las extensiones se encuentra el formato PE .NET ([[#.NET, metadatos y el formato PE|véase más abajo]]), una versión para binarios de 64 bits llamada PE32+ (o a veces PE+), y una especificación para Windows CE.
 == Detalles técnicos ==
@@ Línea 35: / Línea 22: @@
 Un prototipo de una tabla de secciones se ve de la siguiente manera:
-<source lang=C>
+<source lang="C">
 typedef struct _IMAGE_SECTION_HEADER {
    BYTE  Name[IMAGE_SIZEOF_SHORT_NAME];
@@ Línea 104: / Línea 91: @@
 La sección de datos de {{abreviación|CLR|Common Language Runtime}} contiene dos segmentos importantes, código de metadatos y código de Intermediate Language (IL):
-* Los metadatos contienen información relevante para el ensamblado, incluyendo el manifiesto de ensamblado. Un manifiesto describe el ensamblado en detalle, incluyendo la identificación única (mediante un ''hash'', número de versión, etc.), datos en componentes exportados, información de tipo extensivo (soportado por el Common Type System (CTS)), referencias externas, y una lista de archivos dentro del ensamblado. El entorno CLR hace un uso amplio de los metadatos.<ref name=MSDN_MetadataAndPEStruct>{{cita web|url=http://msdn.microsoft.com/es-es/library/8dkk3ek4.aspx|título=Metadatos y la estructura del archivo PE|editor=[[Microsoft]]|obra=[[MSDN Library]]|fechaacceso=5 de abril de 2013}}</ref>
+* Los metadatos contienen información relevante para el ensamblado, incluyendo el manifiesto de ensamblado. Un manifiesto describe el ensamblado en detalle, incluyendo la identificación única (mediante un ''hash'', número de versión, etc.), datos en componentes exportados, información de tipo extensivo (soportado por el Common Type System (CTS)), referencias externas, y una lista de archivos dentro del ensamblado. El entorno CLR hace un uso amplio de los metadatos.<ref name="MSDN_MetadataAndPEStruct">{{cita web|url=http://msdn.microsoft.com/es-es/library/8dkk3ek4.aspx|título=Metadatos y la estructura del archivo PE|editor=[[Microsoft]]|obra=[[MSDN Library]]|fechaacceso=5 de abril de 2013}}</ref>
 * El código {{abreviación|IL|Intermediate Language}} es un código abstracto e independiente del lenguaje que satisface los requisitos del [[Common Intermediate Languge]] (CIL) del {{abreviación|CLR|Common Language Runtime}}. El término «''intermediate''» (en español «intermedio») se refiere a la naturaleza compatible entre lenguajes y entre plataformas del código {{abreviación|IL|Intermediate Language}}. Este ''lenguaje intermedio'', similar a [[Java bytecode]], permite a las plataformas y a los lenguajes soportar el {{abreviación|CLR|Common Language Runtime}} común. {{abreviación|IL|Intermediate Language}} soporta la [[programación orientada a objetos]] (polimorfismo, herencia, tipos abstractos, etc.), excepciones, eventos, y varias estructuras de datos.