1 /*
2 **
3 ** Copyright 2016, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 **     http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17 
18 #include "read_apk.h"
19 
20 #include <errno.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26 
27 #include <memory>
28 
29 #include <android-base/file.h>
30 #include <android-base/logging.h>
31 #include <ziparchive/zip_archive.h>
32 #include "read_elf.h"
33 #include "utils.h"
34 
35 std::map<ApkInspector::ApkOffset, std::unique_ptr<EmbeddedElf>> ApkInspector::embedded_elf_cache_;
36 
37 EmbeddedElf* ApkInspector::FindElfInApkByOffset(const std::string& apk_path, uint64_t file_offset) {
38   // Already in cache?
39   ApkOffset ami(apk_path, file_offset);
40   auto it = embedded_elf_cache_.find(ami);
41   if (it != embedded_elf_cache_.end()) {
42     return it->second.get();
43   }
44   std::unique_ptr<EmbeddedElf> elf = FindElfInApkByOffsetWithoutCache(apk_path, file_offset);
45   EmbeddedElf* result = elf.get();
46   embedded_elf_cache_[ami] = std::move(elf);
47   return result;
48 }
49 
50 std::unique_ptr<EmbeddedElf> ApkInspector::FindElfInApkByOffsetWithoutCache(const std::string& apk_path,
51                                                                             uint64_t file_offset) {
52   // Crack open the apk(zip) file and take a look.
53   if (!IsValidApkPath(apk_path)) {
54     return nullptr;
55   }
56 
57   FileHelper fhelper = FileHelper::OpenReadOnly(apk_path);
58   if (!fhelper) {
59     return nullptr;
60   }
61 
62   ArchiveHelper ahelper(fhelper.fd(), apk_path);
63   if (!ahelper) {
64     return nullptr;
65   }
66   ZipArchiveHandle &handle = ahelper.archive_handle();
67 
68   // Iterate through the zip file. Look for a zip entry corresponding
69   // to an uncompressed blob whose range intersects with the mmap
70   // offset we're interested in.
71   void* iteration_cookie;
72   if (StartIteration(handle, &iteration_cookie, nullptr, nullptr) < 0) {
73     return nullptr;
74   }
75   ZipEntry zentry;
76   ZipString zname;
77   bool found = false;
78   int zrc;
79   while ((zrc = Next(iteration_cookie, &zentry, &zname)) == 0) {
80     if (zentry.method == kCompressStored &&
81         file_offset >= static_cast<uint64_t>(zentry.offset) &&
82         file_offset < static_cast<uint64_t>(zentry.offset + zentry.uncompressed_length)) {
83       // Found.
84       found = true;
85       break;
86     }
87   }
88   EndIteration(iteration_cookie);
89   if (!found) {
90     return nullptr;
91   }
92 
93   // We found something in the zip file at the right spot. Is it an ELF?
94   if (lseek(fhelper.fd(), zentry.offset, SEEK_SET) != zentry.offset) {
95     PLOG(ERROR) << "lseek() failed in " << apk_path << " offset " << zentry.offset;
96     return nullptr;
97   }
98   std::string entry_name;
99   entry_name.resize(zname.name_length,'\0');
100   memcpy(&entry_name[0], zname.name, zname.name_length);
101   ElfStatus result = IsValidElfFile(fhelper.fd());
102   if (result != ElfStatus::NO_ERROR) {
103     LOG(ERROR) << "problems reading ELF from " << apk_path << " entry '"
104                << entry_name << "': " << result;
105     return nullptr;
106   }
107 
108   // Elf found: add EmbeddedElf to vector, update cache.
109   return std::unique_ptr<EmbeddedElf>(new EmbeddedElf(apk_path, entry_name, zentry.offset,
110                                                       zentry.uncompressed_length));
111 }
112 
113 bool ApkInspector::FindOffsetInApkByName(const std::string& apk_path,
114                                          const std::string& elf_filename, uint64_t* offset,
115                                          uint32_t* uncompressed_length) {
116   if (!IsValidApkPath(apk_path)) {
117     return false;
118   }
119   FileHelper fhelper = FileHelper::OpenReadOnly(apk_path);
120   if (!fhelper) {
121     return false;
122   }
123   ArchiveHelper ahelper(fhelper.fd(), apk_path);
124   if (!ahelper) {
125     return false;
126   }
127   ZipArchiveHandle& handle = ahelper.archive_handle();
128   ZipEntry zentry;
129   int32_t rc = FindEntry(handle, ZipString(elf_filename.c_str()), &zentry);
130   if (rc != false) {
131     LOG(ERROR) << "failed to find " << elf_filename << " in " << apk_path
132         << ": " << ErrorCodeString(rc);
133     return false;
134   }
135   if (zentry.method != kCompressStored || zentry.compressed_length != zentry.uncompressed_length) {
136     LOG(ERROR) << "shared library " << elf_filename << " in " << apk_path << " is compressed";
137     return false;
138   }
139   *offset = zentry.offset;
140   *uncompressed_length = zentry.uncompressed_length;
141   return true;
142 }
143 
144 std::unique_ptr<EmbeddedElf> ApkInspector::FindElfInApkByName(const std::string& apk_path,
145                                                               const std::string& elf_filename) {
146   uint64_t offset;
147   uint32_t uncompressed_length;
148   if (!FindOffsetInApkByName(apk_path, elf_filename, &offset, &uncompressed_length)) {
149     return nullptr;
150   }
151   return std::unique_ptr<EmbeddedElf>(new EmbeddedElf(apk_path, elf_filename, offset,
152                                                       uncompressed_length));
153 }
154 
155 bool IsValidApkPath(const std::string& apk_path) {
156   static const char zip_preamble[] = {0x50, 0x4b, 0x03, 0x04 };
157   if (!IsRegularFile(apk_path)) {
158     return false;
159   }
160   std::string mode = std::string("rb") + CLOSE_ON_EXEC_MODE;
161   FILE* fp = fopen(apk_path.c_str(), mode.c_str());
162   if (fp == nullptr) {
163     return false;
164   }
165   char buf[4];
166   if (fread(buf, 4, 1, fp) != 1) {
167     fclose(fp);
168     return false;
169   }
170   fclose(fp);
171   return memcmp(buf, zip_preamble, 4) == 0;
172 }
173 
174 // Refer file in apk in compliance with http://developer.android.com/reference/java/net/JarURLConnection.html.
175 std::string GetUrlInApk(const std::string& apk_path, const std::string& elf_filename) {
176   return apk_path + "!/" + elf_filename;
177 }
178 
179 std::tuple<bool, std::string, std::string> SplitUrlInApk(const std::string& path) {
180   size_t pos = path.find("!/");
181   if (pos == std::string::npos) {
182     return std::make_tuple(false, "", "");
183   }
184   return std::make_tuple(true, path.substr(0, pos), path.substr(pos + 2));
185 }
186 
187 ElfStatus GetBuildIdFromApkFile(const std::string& apk_path, const std::string& elf_filename,
188                            BuildId* build_id) {
189   std::unique_ptr<EmbeddedElf> ee = ApkInspector::FindElfInApkByName(apk_path, elf_filename);
190   if (ee == nullptr) {
191     return ElfStatus::FILE_NOT_FOUND;
192   }
193   return GetBuildIdFromEmbeddedElfFile(apk_path, ee->entry_offset(), ee->entry_size(), build_id);
194 }
195 
196 ElfStatus ParseSymbolsFromApkFile(const std::string& apk_path, const std::string& elf_filename,
197                              const BuildId& expected_build_id,
198                              const std::function<void(const ElfFileSymbol&)>& callback) {
199   std::unique_ptr<EmbeddedElf> ee = ApkInspector::FindElfInApkByName(apk_path, elf_filename);
200   if (ee == nullptr) {
201     return ElfStatus::FILE_NOT_FOUND;
202   }
203   return ParseSymbolsFromEmbeddedElfFile(apk_path, ee->entry_offset(), ee->entry_size(),
204                                          expected_build_id, callback);
205 }
206