1 /* 2 * Copyright (C) 2009 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 // See imgdiff.cpp in this directory for a description of the patch file 18 // format. 19 20 #include <applypatch/imgpatch.h> 21 22 #include <errno.h> 23 #include <stdio.h> 24 #include <string.h> 25 #include <sys/cdefs.h> 26 #include <sys/stat.h> 27 #include <unistd.h> 28 29 #include <memory> 30 #include <string> 31 #include <vector> 32 33 #include <android-base/logging.h> 34 #include <android-base/memory.h> 35 #include <applypatch/applypatch.h> 36 #include <applypatch/imgdiff.h> 37 #include <openssl/sha.h> 38 #include <zlib.h> 39 40 #include "edify/expr.h" 41 42 static inline int64_t Read8(const void *address) { 43 return android::base::get_unaligned<int64_t>(address); 44 } 45 46 static inline int32_t Read4(const void *address) { 47 return android::base::get_unaligned<int32_t>(address); 48 } 49 50 // This function is a wrapper of ApplyBSDiffPatch(). It has a custom sink function to deflate the 51 // patched data and stream the deflated data to output. 52 static bool ApplyBSDiffPatchAndStreamOutput(const uint8_t* src_data, size_t src_len, 53 const Value& patch, size_t patch_offset, 54 const char* deflate_header, SinkFn sink, SHA_CTX* ctx) { 55 size_t expected_target_length = static_cast<size_t>(Read8(deflate_header + 32)); 56 int level = Read4(deflate_header + 40); 57 int method = Read4(deflate_header + 44); 58 int window_bits = Read4(deflate_header + 48); 59 int mem_level = Read4(deflate_header + 52); 60 int strategy = Read4(deflate_header + 56); 61 62 z_stream strm; 63 strm.zalloc = Z_NULL; 64 strm.zfree = Z_NULL; 65 strm.opaque = Z_NULL; 66 strm.avail_in = 0; 67 strm.next_in = nullptr; 68 int ret = deflateInit2(&strm, level, method, window_bits, mem_level, strategy); 69 if (ret != Z_OK) { 70 LOG(ERROR) << "Failed to init uncompressed data deflation: " << ret; 71 return false; 72 } 73 74 // Define a custom sink wrapper that feeds to bspatch. It deflates the available patch data on 75 // the fly and outputs the compressed data to the given sink. 76 size_t actual_target_length = 0; 77 size_t total_written = 0; 78 static constexpr size_t buffer_size = 32768; 79 auto compression_sink = [&strm, &actual_target_length, &expected_target_length, &total_written, 80 &ret, &ctx, &sink](const uint8_t* data, size_t len) -> size_t { 81 // The input patch length for an update never exceeds INT_MAX. 82 strm.avail_in = len; 83 strm.next_in = data; 84 do { 85 std::vector<uint8_t> buffer(buffer_size); 86 strm.avail_out = buffer_size; 87 strm.next_out = buffer.data(); 88 if (actual_target_length + len < expected_target_length) { 89 ret = deflate(&strm, Z_NO_FLUSH); 90 } else { 91 ret = deflate(&strm, Z_FINISH); 92 } 93 if (ret != Z_OK && ret != Z_STREAM_END) { 94 LOG(ERROR) << "Failed to deflate stream: " << ret; 95 // zero length indicates an error in the sink function of bspatch(). 96 return 0; 97 } 98 99 size_t have = buffer_size - strm.avail_out; 100 total_written += have; 101 if (sink(buffer.data(), have) != have) { 102 LOG(ERROR) << "Failed to write " << have << " compressed bytes to output."; 103 return 0; 104 } 105 if (ctx) SHA1_Update(ctx, buffer.data(), have); 106 } while ((strm.avail_in != 0 || strm.avail_out == 0) && ret != Z_STREAM_END); 107 108 actual_target_length += len; 109 return len; 110 }; 111 112 int bspatch_result = 113 ApplyBSDiffPatch(src_data, src_len, patch, patch_offset, compression_sink, nullptr); 114 deflateEnd(&strm); 115 116 if (bspatch_result != 0) { 117 return false; 118 } 119 120 if (ret != Z_STREAM_END) { 121 LOG(ERROR) << "ret is expected to be Z_STREAM_END, but it's " << ret; 122 return false; 123 } 124 125 if (expected_target_length != actual_target_length) { 126 LOG(ERROR) << "target length is expected to be " << expected_target_length << ", but it's " 127 << actual_target_length; 128 return false; 129 } 130 LOG(DEBUG) << "bspatch writes " << total_written << " bytes in total to streaming output."; 131 132 return true; 133 } 134 135 int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const unsigned char* patch_data, 136 size_t patch_size, SinkFn sink) { 137 Value patch(VAL_BLOB, std::string(reinterpret_cast<const char*>(patch_data), patch_size)); 138 return ApplyImagePatch(old_data, old_size, patch, sink, nullptr, nullptr); 139 } 140 141 int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const Value& patch, SinkFn sink, 142 SHA_CTX* ctx, const Value* bonus_data) { 143 if (patch.data.size() < 12) { 144 printf("patch too short to contain header\n"); 145 return -1; 146 } 147 148 // IMGDIFF2 uses CHUNK_NORMAL, CHUNK_DEFLATE, and CHUNK_RAW. (IMGDIFF1, which is no longer 149 // supported, used CHUNK_NORMAL and CHUNK_GZIP.) 150 const char* const patch_header = patch.data.data(); 151 if (memcmp(patch_header, "IMGDIFF2", 8) != 0) { 152 printf("corrupt patch file header (magic number)\n"); 153 return -1; 154 } 155 156 int num_chunks = Read4(patch_header + 8); 157 size_t pos = 12; 158 for (int i = 0; i < num_chunks; ++i) { 159 // each chunk's header record starts with 4 bytes. 160 if (pos + 4 > patch.data.size()) { 161 printf("failed to read chunk %d record\n", i); 162 return -1; 163 } 164 int type = Read4(patch_header + pos); 165 pos += 4; 166 167 if (type == CHUNK_NORMAL) { 168 const char* normal_header = patch_header + pos; 169 pos += 24; 170 if (pos > patch.data.size()) { 171 printf("failed to read chunk %d normal header data\n", i); 172 return -1; 173 } 174 175 size_t src_start = static_cast<size_t>(Read8(normal_header)); 176 size_t src_len = static_cast<size_t>(Read8(normal_header + 8)); 177 size_t patch_offset = static_cast<size_t>(Read8(normal_header + 16)); 178 179 if (src_start + src_len > old_size) { 180 printf("source data too short\n"); 181 return -1; 182 } 183 if (ApplyBSDiffPatch(old_data + src_start, src_len, patch, patch_offset, sink, ctx) != 0) { 184 printf("Failed to apply bsdiff patch.\n"); 185 return -1; 186 } 187 } else if (type == CHUNK_RAW) { 188 const char* raw_header = patch_header + pos; 189 pos += 4; 190 if (pos > patch.data.size()) { 191 printf("failed to read chunk %d raw header data\n", i); 192 return -1; 193 } 194 195 size_t data_len = static_cast<size_t>(Read4(raw_header)); 196 197 if (pos + data_len > patch.data.size()) { 198 printf("failed to read chunk %d raw data\n", i); 199 return -1; 200 } 201 if (ctx) { 202 SHA1_Update(ctx, patch_header + pos, data_len); 203 } 204 if (sink(reinterpret_cast<const unsigned char*>(patch_header + pos), data_len) != data_len) { 205 printf("failed to write chunk %d raw data\n", i); 206 return -1; 207 } 208 pos += data_len; 209 } else if (type == CHUNK_DEFLATE) { 210 // deflate chunks have an additional 60 bytes in their chunk header. 211 const char* deflate_header = patch_header + pos; 212 pos += 60; 213 if (pos > patch.data.size()) { 214 printf("failed to read chunk %d deflate header data\n", i); 215 return -1; 216 } 217 218 size_t src_start = static_cast<size_t>(Read8(deflate_header)); 219 size_t src_len = static_cast<size_t>(Read8(deflate_header + 8)); 220 size_t patch_offset = static_cast<size_t>(Read8(deflate_header + 16)); 221 size_t expanded_len = static_cast<size_t>(Read8(deflate_header + 24)); 222 223 if (src_start + src_len > old_size) { 224 printf("source data too short\n"); 225 return -1; 226 } 227 228 // Decompress the source data; the chunk header tells us exactly 229 // how big we expect it to be when decompressed. 230 231 // Note: expanded_len will include the bonus data size if 232 // the patch was constructed with bonus data. The 233 // deflation will come up 'bonus_size' bytes short; these 234 // must be appended from the bonus_data value. 235 size_t bonus_size = (i == 1 && bonus_data != NULL) ? bonus_data->data.size() : 0; 236 237 std::vector<unsigned char> expanded_source(expanded_len); 238 239 // inflate() doesn't like strm.next_out being a nullptr even with 240 // avail_out being zero (Z_STREAM_ERROR). 241 if (expanded_len != 0) { 242 z_stream strm; 243 strm.zalloc = Z_NULL; 244 strm.zfree = Z_NULL; 245 strm.opaque = Z_NULL; 246 strm.avail_in = src_len; 247 strm.next_in = old_data + src_start; 248 strm.avail_out = expanded_len; 249 strm.next_out = expanded_source.data(); 250 251 int ret = inflateInit2(&strm, -15); 252 if (ret != Z_OK) { 253 printf("failed to init source inflation: %d\n", ret); 254 return -1; 255 } 256 257 // Because we've provided enough room to accommodate the output 258 // data, we expect one call to inflate() to suffice. 259 ret = inflate(&strm, Z_SYNC_FLUSH); 260 if (ret != Z_STREAM_END) { 261 printf("source inflation returned %d\n", ret); 262 return -1; 263 } 264 // We should have filled the output buffer exactly, except 265 // for the bonus_size. 266 if (strm.avail_out != bonus_size) { 267 printf("source inflation short by %zu bytes\n", strm.avail_out - bonus_size); 268 return -1; 269 } 270 inflateEnd(&strm); 271 272 if (bonus_size) { 273 memcpy(expanded_source.data() + (expanded_len - bonus_size), &bonus_data->data[0], 274 bonus_size); 275 } 276 } 277 278 if (!ApplyBSDiffPatchAndStreamOutput(expanded_source.data(), expanded_len, patch, 279 patch_offset, deflate_header, sink, ctx)) { 280 LOG(ERROR) << "Fail to apply streaming bspatch."; 281 return -1; 282 } 283 284 } else { 285 printf("patch chunk %d is unknown type %d\n", i, type); 286 return -1; 287 } 288 } 289 290 return 0; 291 } 292
