The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Contains:
- #340
- #537
- #539
- #747

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- microsoft#340
- microsoft#537
- microsoft#539
- microsoft#747
- microsoft#1100
- microsoft#1127
- microsoft#1142
- microsoft#1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>

The addition of an PE/COFF image validation build plugin that will
verify all pe images against requirements defined in the configuration
file.

This plugin only runs if a path to a config file is provided via the
command line (PE_VALIDATION_PATH) or preferably Platform hardcoded in
the PlatformBuild.py file, so that each platform can have their own
requirements.

Previously, ImageValidation was an "opt-in" plugin by setting a build
variable `PE_VALIDATION_PATH`, however with this pull request, Image
Validation will be on by default, with some default configuration that
can be changed with a custom configuration yaml file.

The default requirements are:
1. All efi binaries must not be both write and execute
2. All efi binaries must have an image base of 0x0
3. All dxe phase binaries must be 4k section aligned, with the one
exception of AARCH64 DXE_RUNTIME_DRIVERS, which must be 64k aligned.

compiled binaries that need to be opted out of, can do so by adding an
`IGNORE_LIST` in the configuration file

```json
{
  "IGNORE_LIST": ["Shell.efi", "etc"]
}
```

In previous iterations, the profile was determined by parsing the
makefile, looking for MODULE_TYPE. As each OS / tool chain may use a
different makefile type, this was not a reliable method. This updates
the plugin to read the INF for the compiled efi file to determine the
MODULE_TYPE and thus the profile.

The PE parsing functionality was modified to only parse the
headers of the image, rather than the entire image. This change is made
to improve performance and also the probability of failing to parse the
entire image. This comes after this commit
(erocarrera/pefile#365) in pefile resulted in
efi image parsing failures, breaking the build.

This commit also wraps the parsing of the image in a try-except block to
catch any exceptions that may be raised during parsing, to cleanly exit.

- Print directory paths considered invalid to aid debugging
- Build native OS file paths using os.path.join for walk dirs
- Clean up trailing whitespace throughout the file

Add gitignore style syntax for file exclusion

Contains:
- #340
- #537
- #539
- #747
- #1100
- #1127
- #1142
- #1140

Confirmed successful execution of the plugin on Windows with QemuQ35 and
Ubuntu with QemuSbsa

Validated on qemuq35 that the module type was successfully parsed.

Validated pipelines build on mu_tiano_platforms

- Local build with the plugin
- Tested invalid directory printing by adding an invalid arch
  to `TARGET_ARCH` (so the directory doesn't exist in build output).

Ensured existing syntax (filename only) continues to work. Ensured
gitignore style syntax now works.

Platforms that begin to fail this test will need to generate a
configuration yaml file, and set a stuart build variable,
`PE_VALIDATION_PATH` to it. It is suggested to do this in the Platform's
`PlatformBuild.py`.

**The Correct Integration** is to evaluate the binary and why it is not
meeting the requirements. The platform can elect to update the
compilation of the binary to meet the requirements, add or override
validation rules for certain MODULE_TYPEs, or simply add the binary to
the ignore list. Please review the Plugin's readme.md file for more
details on doing any of these things.

Co-authored-by: Michael Kubacki <michael.kubacki@microsoft.com>