1 /*
2 * Copyright (C) 2015 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 #include <string>
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <errno.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <linux/fs.h>
26 #include <linux/fiemap.h>
27
28 #define LOG_TAG "secdiscard"
29 #include "cutils/log.h"
30
31 // Deliberately limit ourselves to wiping small files.
32 #define MAX_WIPE_LENGTH 4096
33 #define INIT_BUFFER_SIZE 2048
34
35 static void usage(char *progname);
36 static void destroy_key(const std::string &path);
37 static int file_device_range(const std::string &path, uint64_t range[2]);
38 static int open_block_device_for_path(const std::string &path);
39 static int read_file_as_string_atomically(const std::string &path, std::string &contents);
40 static int find_block_device_for_path(
41 const std::string &mounts,
42 const std::string &path,
43 std::string &block_device);
44
main(int argc,char ** argv)45 int main(int argc, char **argv) {
46 if (argc != 2 || argv[1][0] != '/') {
47 usage(argv[0]);
48 return -1;
49 }
50 SLOGD("Running: %s %s", argv[0], argv[1]);
51 std::string target(argv[1]);
52 destroy_key(target);
53 if (unlink(argv[1]) != 0 && errno != ENOENT) {
54 SLOGE("Unable to delete %s: %s",
55 argv[1], strerror(errno));
56 return -1;
57 }
58 return 0;
59 }
60
usage(char * progname)61 static void usage(char *progname) {
62 fprintf(stderr, "Usage: %s <absolute path>\n", progname);
63 }
64
65 // BLKSECDISCARD all content in "path", if it's small enough.
destroy_key(const std::string & path)66 static void destroy_key(const std::string &path) {
67 uint64_t range[2];
68 if (file_device_range(path, range) < 0) {
69 return;
70 }
71 int fs_fd = open_block_device_for_path(path);
72 if (fs_fd < 0) {
73 return;
74 }
75 if (ioctl(fs_fd, BLKSECDISCARD, range) != 0) {
76 SLOGE("Unable to BLKSECDISCARD %s: %s", path.c_str(), strerror(errno));
77 close(fs_fd);
78 return;
79 }
80 close(fs_fd);
81 SLOGD("Discarded %s", path.c_str());
82 }
83
84 // Find a short range that completely covers the file.
85 // If there isn't one, return -1, otherwise 0.
file_device_range(const std::string & path,uint64_t range[2])86 static int file_device_range(const std::string &path, uint64_t range[2])
87 {
88 int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
89 if (fd < 0) {
90 if (errno == ENOENT) {
91 SLOGD("Unable to open %s: %s", path.c_str(), strerror(errno));
92 } else {
93 SLOGE("Unable to open %s: %s", path.c_str(), strerror(errno));
94 }
95 return -1;
96 }
97 alignas(struct fiemap) char fiemap_buffer[offsetof(struct fiemap, fm_extents[1])];
98 memset(fiemap_buffer, 0, sizeof(fiemap_buffer));
99 struct fiemap *fiemap = (struct fiemap *)fiemap_buffer;
100 fiemap->fm_start = 0;
101 fiemap->fm_length = UINT64_MAX;
102 fiemap->fm_flags = 0;
103 fiemap->fm_extent_count = 1;
104 fiemap->fm_mapped_extents = 0;
105 if (ioctl(fd, FS_IOC_FIEMAP, fiemap) != 0) {
106 SLOGE("Unable to FIEMAP %s: %s", path.c_str(), strerror(errno));
107 close(fd);
108 return -1;
109 }
110 close(fd);
111 if (fiemap->fm_mapped_extents != 1) {
112 SLOGE("Expecting one extent, got %d in %s", fiemap->fm_mapped_extents, path.c_str());
113 return -1;
114 }
115 struct fiemap_extent *extent = &fiemap->fm_extents[0];
116 if (!(extent->fe_flags & FIEMAP_EXTENT_LAST)) {
117 SLOGE("First extent was not the last in %s", path.c_str());
118 return -1;
119 }
120 if (extent->fe_flags &
121 (FIEMAP_EXTENT_UNKNOWN | FIEMAP_EXTENT_DELALLOC | FIEMAP_EXTENT_NOT_ALIGNED)) {
122 SLOGE("Extent has unexpected flags %ulx: %s", extent->fe_flags, path.c_str());
123 return -1;
124 }
125 if (extent->fe_length > MAX_WIPE_LENGTH) {
126 SLOGE("Extent too big, %llu bytes in %s", extent->fe_length, path.c_str());
127 return -1;
128 }
129 range[0] = extent->fe_physical;
130 range[1] = extent->fe_length;
131 return 0;
132 }
133
134 // Given a file path, look for the corresponding
135 // block device in /proc/mounts and open it.
open_block_device_for_path(const std::string & path)136 static int open_block_device_for_path(const std::string &path)
137 {
138 std::string mountsfile("/proc/mounts");
139 std::string mounts;
140 if (read_file_as_string_atomically(mountsfile, mounts) < 0) {
141 return -1;
142 }
143 std::string block_device;
144 if (find_block_device_for_path(mounts, path, block_device) < 0) {
145 return -1;
146 }
147 SLOGD("For path %s block device is %s", path.c_str(), block_device.c_str());
148 int res = open(block_device.c_str(), O_RDWR | O_LARGEFILE | O_CLOEXEC);
149 if (res < 0) {
150 SLOGE("Failed to open device %s: %s", block_device.c_str(), strerror(errno));
151 return -1;
152 }
153 return res;
154 }
155
156 // Read a file into a buffer in a single gulp, for atomicity.
157 // Null-terminate the buffer.
158 // Retry until the buffer is big enough.
read_file_as_string_atomically(const std::string & path,std::string & contents)159 static int read_file_as_string_atomically(const std::string &path, std::string &contents)
160 {
161 ssize_t buffer_size = INIT_BUFFER_SIZE;
162 while (true) {
163 int fd = open(path.c_str(), O_RDONLY | O_CLOEXEC);
164 if (fd < 0) {
165 SLOGE("Failed to open %s: %s", path.c_str(), strerror(errno));
166 return -1;
167 }
168 contents.resize(buffer_size);
169 ssize_t read_size = read(fd, &contents[0], buffer_size);
170 if (read_size < 0) {
171 SLOGE("Failed to read from %s: %s", path.c_str(), strerror(errno));
172 close(fd);
173 return -1;
174 }
175 close(fd);
176 if (read_size < buffer_size) {
177 contents.resize(read_size);
178 return 0;
179 }
180 SLOGD("%s too big for buffer of size %zu", path.c_str(), buffer_size);
181 buffer_size <<= 1;
182 }
183 }
184
185 // Search a string representing the contents of /proc/mounts
186 // for the mount point of a particular file by prefix matching
187 // and return the corresponding block device.
find_block_device_for_path(const std::string & mounts,const std::string & path,std::string & block_device)188 static int find_block_device_for_path(
189 const std::string &mounts,
190 const std::string &path,
191 std::string &block_device)
192 {
193 auto line_begin = mounts.begin();
194 size_t best_prefix = 0;
195 std::string::const_iterator line_end;
196 while (line_begin != mounts.end()) {
197 line_end = std::find(line_begin, mounts.end(), '\n');
198 if (line_end == mounts.end()) {
199 break;
200 }
201 auto device_end = std::find(line_begin, line_end, ' ');
202 if (device_end == line_end) {
203 break;
204 }
205 auto mountpoint_begin = device_end + 1;
206 auto mountpoint_end = std::find(mountpoint_begin, line_end, ' ');
207 if (mountpoint_end == line_end) {
208 break;
209 }
210 if (std::find(line_begin, mountpoint_end, '\\') != mountpoint_end) {
211 // We don't correctly handle escape sequences, and we don't expect
212 // to encounter any, so fail if we do.
213 break;
214 }
215 size_t mountpoint_len = mountpoint_end - mountpoint_begin;
216 if (mountpoint_len > best_prefix &&
217 mountpoint_len < path.length() &&
218 path[mountpoint_len] == '/' &&
219 std::equal(mountpoint_begin, mountpoint_end, path.begin())) {
220 block_device = std::string(line_begin, device_end);
221 best_prefix = mountpoint_len;
222 }
223 line_begin = line_end + 1;
224 }
225 // All of the "break"s above are fatal parse errors.
226 if (line_begin != mounts.end()) {
227 auto bad_line = std::string(line_begin, line_end);
228 SLOGE("Unable to parse line in %s: %s", path.c_str(), bad_line.c_str());
229 return -1;
230 }
231 if (best_prefix == 0) {
232 SLOGE("No prefix found for path: %s", path.c_str());
233 return -1;
234 }
235 return 0;
236 }
237