1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | /* * File: EncoreBootImageReader.h * * Copyright (c) Freescale Semiconductor, Inc. All rights reserved. * See included license file for license details. */ #if !defined(_EncoreBootImageReader_h_) #define _EncoreBootImageReader_h_ #include "EncoreBootImage.h" namespace elftosb { /*! * \brief Reads a Piano/Encore boot image from an input stream. */ class EncoreBootImageReader { public: /*! * \brief Exception class used for error found while reading a boot image. */ class read_error : public std::runtime_error { public: //! \brief Constructor. read_error(const std::string & msg) : std::runtime_error(msg) {} }; //! \brief An array of section headers. typedef std::vector<EncoreBootImage::section_header_t> section_array_t; //! \brief An array of boot tags. typedef std::vector<EncoreBootImage::boot_command_t> boot_tag_array_t; public: //! \brief Default constructor. EncoreBootImageReader(std::istream & stream) : m_stream(stream) {} //! \brief Destructor. virtual ~EncoreBootImageReader() {} //! \name Decryption key //! These methods provide access to the Data Encryption Key (DEK). Normally //! the DEK is discovered using the readKeyDictionary() method. //@{ inline void setKey(const AESKey<128> & key) { m_dek = key; } inline const AESKey<128> & getKey() const { return m_dek; } //@} //! \name Readers //! This group of methods is responsible for reading and parsing different //! pieces and parts of the boot image file. //@{ //! \brief Reads the header from the image. void readImageHeader(); //! \brief Computes the actual SHA-1 digest of the image header. void computeHeaderDigest(sha1_digest_t & digest); //! \brief Reads the digest at the end of the image. void readImageDigest(); //! \brief Run a SHA-1 digest over the entire image. void computeImageDigest(sha1_digest_t & digest); //! \brief Read the plaintext section table entries. void readSectionTable(); //! \brief Reads the key dictionary, if the image is encrypted. bool readKeyDictionary(const AESKey<128> & kek); //! \brief void readBootTags(); //! \brief EncoreBootImage::Section * readSection(unsigned index); //@} //! \name Accessors //! Information retrieved with reader methods is accessible through //! these methods. //@{ //! \brief Returns whether the image is encrypted or not. //! \pre The header must have been read already. inline bool isEncrypted() const { return m_header.m_keyCount > 0; } //! \brief Returns a reference to the image's header. const EncoreBootImage::boot_image_header_t & getHeader() const { return m_header; } //! \brief Returns a reference to the SHA-1 digest read from the image. const sha1_digest_t & getDigest() const { return m_digest; } //! \brief Returns a reference to the STL container holding the section headers. inline const section_array_t & getSections() const { return m_sections; } //! \brief Returns a reference to the STL container holding the boot tags. inline const boot_tag_array_t & getBootTags() const { return m_bootTags; } //@} protected: std::istream & m_stream; //!< The input stream to read the image from. AESKey<128> m_dek; //!< DEK (data encryption key) read from the key dictionary. EncoreBootImage::boot_image_header_t m_header; //!< Header from the boot image. sha1_digest_t m_digest; //!< SHA-1 digest as read from the image. section_array_t m_sections; //!< The section table. boot_tag_array_t m_bootTags; //!< The array of boot tags read from the image. protected: //! \brief Calculates the 8-bit checksum on a boot command header. uint8_t calculateCommandChecksum(EncoreBootImage::boot_command_t & header); }; }; // namespace elftosb #endif // _EncoreBootImageReader_h_ |