1 //
2 // Copyright (C) 2010 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #ifndef UPDATE_ENGINE_PAYLOAD_GENERATOR_PAYLOAD_SIGNER_H_
18 #define UPDATE_ENGINE_PAYLOAD_GENERATOR_PAYLOAD_SIGNER_H_
19 
20 #include <string>
21 #include <vector>
22 
23 #include <base/macros.h>
24 #include <brillo/key_value_store.h>
25 #include <brillo/secure_blob.h>
26 
27 #include "update_engine/update_metadata.pb.h"
28 
29 // This class encapsulates methods used for payload signing.
30 // See update_metadata.proto for more info.
31 
32 namespace chromeos_update_engine {
33 
34 class PayloadSigner {
35  public:
36   // Returns true if the payload in |payload_path| is signed and its hash can be
37   // verified using the public key in |public_key_path| with the signature
38   // of a given version in the signature blob. Returns false otherwise.
39   static bool VerifySignedPayload(const std::string& payload_path,
40                                   const std::string& public_key_path);
41 
42   // Adds specified signature offset/length to given |manifest|.
43   static void AddSignatureToManifest(uint64_t signature_blob_offset,
44                                      uint64_t signature_blob_length,
45                                      DeltaArchiveManifest* manifest);
46 
47   // Given a raw |hash| and a private key in |private_key_path| calculates the
48   // raw signature in |out_signature|. Returns true on success, false otherwise.
49   static bool SignHash(const brillo::Blob& hash,
50                        const std::string& private_key_path,
51                        brillo::Blob* out_signature);
52 
53   // Sign |hash_data| blob with all private keys in |private_key_paths|, then
54   // convert the signatures to serialized protobuf.
55   static bool SignHashWithKeys(
56       const brillo::Blob& hash_data,
57       const std::vector<std::string>& private_key_paths,
58       std::string* out_serialized_signature);
59 
60   // Given an unsigned payload in |unsigned_payload_path|, private keys in
61   // |private_key_path|, metadata size in |metadata_size|, metadata signature
62   // size in |metadata_signature_size| and signatures offset in
63   // |signatures_offset|, calculates the payload signature blob into
64   // |out_serialized_signature|. Note that the payload must already have an
65   // updated manifest that includes the fake signature op and correct metadata
66   // signature size in header. Returns true on success, false otherwise.
67   static bool SignPayload(const std::string& unsigned_payload_path,
68                           const std::vector<std::string>& private_key_paths,
69                           const uint64_t metadata_size,
70                           const uint32_t metadata_signature_size,
71                           const uint64_t signatures_offset,
72                           std::string* out_serialized_signature);
73 
74   // Returns the length of out_serialized_signature that will result in a call
75   // to SignPayload with the given private keys. Returns true on success.
76   static bool SignatureBlobLength(
77       const std::vector<std::string>& private_key_paths, uint64_t* out_length);
78 
79   // Given an unsigned payload in |payload_path|,
80   // this method does two things:
81   // 1. It loads the payload into memory, and inserts placeholder signature
82   //    operations and placeholder metadata signature to make the header and
83   //    the manifest match what the final signed payload will look like based
84   //    on |signatures_sizes|, if needed.
85   // 2. It calculates the raw SHA256 hash of the payload and the metadata in
86   //    |payload_path| (except signatures) and returns the result in
87   //    |out_hash_data| and |out_metadata_hash| respectively.
88   //
89   // The changes to payload are not preserved or written to disk.
90   static bool HashPayloadForSigning(const std::string& payload_path,
91                                     const std::vector<size_t>& signature_sizes,
92                                     brillo::Blob* out_payload_hash_data,
93                                     brillo::Blob* out_metadata_hash);
94 
95   // Given an unsigned payload in |payload_path| (with no fake signature op)
96   // and the raw |payload_signatures| and |metadata_signatures| updates the
97   // payload to include the signature thus turning it into a signed payload. The
98   // new payload is stored in |signed_payload_path|. |payload_path| and
99   // |signed_payload_path| can point to the same file. Populates
100   // |out_metadata_size| with the size of the metadata after adding the
101   // signature operation in the manifest. Returns true on success, false
102   // otherwise.
103   static bool AddSignatureToPayload(
104       const std::string& payload_path,
105       const std::vector<size_t>& padded_signature_sizes,
106       const std::vector<brillo::Blob>& payload_signatures,
107       const std::vector<brillo::Blob>& metadata_signatures,
108       const std::string& signed_payload_path,
109       uint64_t* out_metadata_size);
110 
111   // Computes the SHA256 hash of the first metadata_size bytes of |metadata|
112   // and signs the hash with the given private_key_path and writes the signed
113   // hash in |out_signature|. Returns true if successful or false if there was
114   // any error in the computations.
115   static bool GetMetadataSignature(const void* const metadata,
116                                    size_t metadata_size,
117                                    const std::string& private_key_path,
118                                    std::string* out_signature);
119 
120   static bool ExtractPayloadProperties(const std::string& payload_path,
121                                        brillo::KeyValueStore* properties);
122 
123   // This function calculates the maximum size, in bytes, of a signature signed
124   // by private_key_path. For an RSA key, this returns the number of bytes
125   // needed to represent the modulus. For an EC key, this returns the maximum
126   // size of a DER-encoded ECDSA signature.
127   static bool GetMaximumSignatureSize(const std::string& private_key_path,
128                                       size_t* signature_size);
129 
130  private:
131   // This should never be constructed
132   DISALLOW_IMPLICIT_CONSTRUCTORS(PayloadSigner);
133 };
134 
135 }  // namespace chromeos_update_engine
136 
137 #endif  // UPDATE_ENGINE_PAYLOAD_GENERATOR_PAYLOAD_SIGNER_H_
138