Give PeImageReader the power to read certificate entries.

chrome/common/safe_browsing/pe_image_reader_win.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_COMMON_SAFE_BROWSING_PE_IMAGE_READER_WIN_H_
 #define CHROME_COMMON_SAFE_BROWSING_PE_IMAGE_READER_WIN_H_
 
 #include <windows.h>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace safe_browsing {
 
 // Parses headers and various data from a PE image. This parser is safe for use
 // on untrusted data.
 class PeImageReader {
  public:
   enum WordSize {
     WORD_SIZE_32,
     WORD_SIZE_64,
   };
 
+  // A callback invoked by EnumCertificates once for each attribute certificate
+  // entry in the image's attribute certificate table. |revision| and
+  // |certificate_type| identify the contents of |certificate_data| (which is of
+  // |certificate_data_size| bytes). |context| is the value provided by the
+  // caller to EnumCertificates(). Implementations must return true to continue
+  // the enumeration, or false to abort.
+  typedef bool (*EnumCertificatesCallback)(uint16_t revision,
+                                           uint16_t certificate_type,
+                                           const uint8_t* certificate_data,
+                                           size_t certificate_data_size,
+                                           void* context);
+
   PeImageReader();
   ~PeImageReader();
 
   // Returns false if the given data does not appear to be a valid PE image.
   bool Initialize(const uint8_t* image_data, size_t image_size);
 
   // Returns the machine word size for the image.
   WordSize GetWordSize();
 
   const IMAGE_DOS_HEADER* GetDosHeader();
   const IMAGE_FILE_HEADER* GetCoffFileHeader();
 
   // Returns a pointer to the optional header and its size.
   const uint8_t* GetOptionalHeaderData(size_t* optional_data_size);
   size_t GetNumberOfSections();
   const IMAGE_SECTION_HEADER* GetSectionHeaderAt(size_t index);
 
   // Returns a pointer to the image's export data (.edata) section and its size,
   // or NULL if the section is not present.
   const uint8_t* GetExportSection(size_t* section_size);
 
   size_t GetNumberOfDebugEntries();
   const IMAGE_DEBUG_DIRECTORY* GetDebugEntry(size_t index,
                                              const uint8_t** raw_data,
                                              size_t* raw_data_size);
 
+  // Invokes |callback| once per attribute certificate entry. |context| is a
+  // caller-specific value that is passed to |callback|. Returns true if all
+  // certificate entries are visited (even if there are no such entries) and
+  // |callback| returns true for each. Conversely, returns |false| if |callback|
+  // returns false or if the image is malformed in any way.
+  bool EnumCertificates(EnumCertificatesCallback callback,
+                        void* context);
+
  private:
   // Bits indicating what portions of the image have been validated.
   enum ValidationStages {
     VALID_DOS_HEADER = 1 << 0,
     VALID_PE_SIGNATURE = 1 << 1,
     VALID_COFF_FILE_HEADER = 1 << 2,
     VALID_OPTIONAL_HEADER = 1 << 3,
     VALID_SECTION_HEADERS = 1 << 4,
   };
 
@@ skipping 66 matching lines @@
   const uint8_t* image_data_;
   size_t image_size_;
   uint32_t validation_state_;
   scoped_ptr<OptionalHeader> optional_header_;
   DISALLOW_COPY_AND_ASSIGN(PeImageReader);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_COMMON_SAFE_BROWSING_PE_IMAGE_READER_WIN_H_