1 /* 2 * Copyright (c) 2017 Conrad Meyer <cem@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/endian.h> 32 33 #include <assert.h> 34 #include <err.h> 35 #include <errno.h> 36 #ifdef WITH_ICONV 37 #include <iconv.h> 38 #endif 39 #include <stdbool.h> 40 #include <stdint.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 45 #include "fstyp.h" 46 47 /* 48 * https://docs.microsoft.com/en-us/windows/win32/fileio/exfat-specification 49 */ 50 51 struct exfat_vbr { 52 char ev_jmp[3]; 53 char ev_fsname[8]; 54 char ev_zeros[53]; 55 uint64_t ev_part_offset; 56 uint64_t ev_vol_length; 57 uint32_t ev_fat_offset; 58 uint32_t ev_fat_length; 59 uint32_t ev_cluster_offset; 60 uint32_t ev_cluster_count; 61 uint32_t ev_rootdir_cluster; 62 uint32_t ev_vol_serial; 63 uint16_t ev_fs_revision; 64 uint16_t ev_vol_flags; 65 uint8_t ev_log_bytes_per_sect; 66 uint8_t ev_log_sect_per_clust; 67 uint8_t ev_num_fats; 68 uint8_t ev_drive_sel; 69 uint8_t ev_percent_used; 70 } __packed; 71 72 struct exfat_dirent { 73 uint8_t xde_type; 74 #define XDE_TYPE_INUSE_MASK 0x80 /* 1=in use */ 75 #define XDE_TYPE_INUSE_SHIFT 7 76 #define XDE_TYPE_CATEGORY_MASK 0x40 /* 0=primary */ 77 #define XDE_TYPE_CATEGORY_SHIFT 6 78 #define XDE_TYPE_IMPORTNC_MASK 0x20 /* 0=critical */ 79 #define XDE_TYPE_IMPORTNC_SHIFT 5 80 #define XDE_TYPE_CODE_MASK 0x1f 81 /* InUse=0, ..., TypeCode=0: EOD. */ 82 #define XDE_TYPE_EOD 0x00 83 #define XDE_TYPE_ALLOC_BITMAP (XDE_TYPE_INUSE_MASK | 0x01) 84 #define XDE_TYPE_UPCASE_TABLE (XDE_TYPE_INUSE_MASK | 0x02) 85 #define XDE_TYPE_VOL_LABEL (XDE_TYPE_INUSE_MASK | 0x03) 86 #define XDE_TYPE_FILE (XDE_TYPE_INUSE_MASK | 0x05) 87 #define XDE_TYPE_VOL_GUID (XDE_TYPE_INUSE_MASK | XDE_TYPE_IMPORTNC_MASK) 88 #define XDE_TYPE_STREAM_EXT (XDE_TYPE_INUSE_MASK | XDE_TYPE_CATEGORY_MASK) 89 #define XDE_TYPE_FILE_NAME (XDE_TYPE_INUSE_MASK | XDE_TYPE_CATEGORY_MASK | 0x01) 90 #define XDE_TYPE_VENDOR (XDE_TYPE_INUSE_MASK | XDE_TYPE_CATEGORY_MASK | XDE_TYPE_IMPORTNC_MASK) 91 #define XDE_TYPE_VENDOR_ALLOC (XDE_TYPE_INUSE_MASK | XDE_TYPE_CATEGORY_MASK | XDE_TYPE_IMPORTNC_MASK | 0x01) 92 union { 93 uint8_t xde_generic_[19]; 94 struct exde_primary { 95 /* 96 * Count of "secondary" dirents following this one. 97 * 98 * A single logical entity may be composed of a 99 * sequence of several dirents, starting with a primary 100 * one; the rest are secondary dirents. 101 */ 102 uint8_t xde_secondary_count_; 103 uint16_t xde_set_chksum_; 104 uint16_t xde_prim_flags_; 105 uint8_t xde_prim_generic_[14]; 106 } __packed xde_primary_; 107 struct exde_secondary { 108 uint8_t xde_sec_flags_; 109 uint8_t xde_sec_generic_[18]; 110 } __packed xde_secondary_; 111 } u; 112 uint32_t xde_first_cluster; 113 uint64_t xde_data_len; 114 } __packed; 115 #define xde_generic u.xde_generic_ 116 #define xde_secondary_count u.xde_primary_.xde_secondary_count 117 #define xde_set_chksum u.xde_primary_.xde_set_chksum_ 118 #define xde_prim_flags u.xde_primary_.xde_prim_flags_ 119 #define xde_sec_flags u.xde_secondary_.xde_sec_flags_ 120 _Static_assert(sizeof(struct exfat_dirent) == 32, "spec"); 121 122 struct exfat_de_label { 123 uint8_t xdel_type; /* XDE_TYPE_VOL_LABEL */ 124 uint8_t xdel_char_cnt; /* Length of UCS-2 label */ 125 uint16_t xdel_vol_lbl[11]; 126 uint8_t xdel_reserved[8]; 127 } __packed; 128 _Static_assert(sizeof(struct exfat_de_label) == 32, "spec"); 129 130 #define MAIN_BOOT_REGION_SECT 0 131 #define BACKUP_BOOT_REGION_SECT 12 132 133 #define SUBREGION_CHKSUM_SECT 11 134 135 #define FIRST_CLUSTER 2 136 #define BAD_BLOCK_SENTINEL 0xfffffff7u 137 #define END_CLUSTER_SENTINEL 0xffffffffu 138 139 static inline void * 140 read_sectn(FILE *fp, off_t sect, unsigned count, unsigned bytespersec) 141 { 142 return (read_buf(fp, sect * bytespersec, bytespersec * count)); 143 } 144 145 static inline void * 146 read_sect(FILE *fp, off_t sect, unsigned bytespersec) 147 { 148 return (read_sectn(fp, sect, 1, bytespersec)); 149 } 150 151 /* 152 * Compute the byte-by-byte multi-sector checksum of the given boot region 153 * (MAIN or BACKUP), for a given bytespersec (typically 512 or 4096). 154 * 155 * Endian-safe; result is host endian. 156 */ 157 static int 158 exfat_compute_boot_chksum(FILE *fp, unsigned region, unsigned bytespersec, 159 uint32_t *result) 160 { 161 unsigned char *sector; 162 unsigned n, sect; 163 uint32_t checksum; 164 165 checksum = 0; 166 for (sect = 0; sect < 11; sect++) { 167 sector = read_sect(fp, region + sect, bytespersec); 168 if (sector == NULL) 169 return (ENXIO); 170 for (n = 0; n < bytespersec; n++) { 171 if (sect == 0) { 172 switch (n) { 173 case 106: 174 case 107: 175 case 112: 176 continue; 177 } 178 } 179 checksum = ((checksum & 1) ? 0x80000000u : 0u) + 180 (checksum >> 1) + (uint32_t)sector[n]; 181 } 182 free(sector); 183 } 184 185 *result = checksum; 186 return (0); 187 } 188 189 #ifdef WITH_ICONV 190 static void 191 convert_label(const uint16_t *ucs2label /* LE */, unsigned ucs2len, char 192 *label_out, size_t label_sz) 193 { 194 const char *label; 195 char *label_out_orig; 196 iconv_t cd; 197 size_t srcleft, rc; 198 199 /* Currently hardcoded in fstyp.c as 256 or so. */ 200 assert(label_sz > 1); 201 202 if (ucs2len == 0) { 203 /* 204 * Kind of seems bogus, but the spec allows an empty label 205 * entry with the same meaning as no label. 206 */ 207 return; 208 } 209 210 if (ucs2len > 11) { 211 warnx("exfat: Bogus volume label length: %u", ucs2len); 212 return; 213 } 214 215 /* dstname="" means convert to the current locale. */ 216 cd = iconv_open("", EXFAT_ENC); 217 if (cd == (iconv_t)-1) { 218 warn("exfat: Could not open iconv"); 219 return; 220 } 221 222 label_out_orig = label_out; 223 224 /* Dummy up the byte pointer and byte length iconv's API wants. */ 225 label = (const void *)ucs2label; 226 srcleft = ucs2len * sizeof(*ucs2label); 227 228 rc = iconv(cd, __DECONST(char **, &label), &srcleft, &label_out, 229 &label_sz); 230 if (rc == (size_t)-1) { 231 warn("exfat: iconv()"); 232 *label_out_orig = '\0'; 233 } else { 234 /* NUL-terminate result (iconv advances label_out). */ 235 if (label_sz == 0) 236 label_out--; 237 *label_out = '\0'; 238 } 239 240 iconv_close(cd); 241 } 242 243 /* 244 * Using the FAT table, look up the next cluster in this chain. 245 */ 246 static uint32_t 247 exfat_fat_next(FILE *fp, const struct exfat_vbr *ev, unsigned BPS, 248 uint32_t cluster) 249 { 250 uint32_t fat_offset_sect, clsect, clsectoff; 251 uint32_t *fatsect, nextclust; 252 253 fat_offset_sect = le32toh(ev->ev_fat_offset); 254 clsect = fat_offset_sect + (cluster / (BPS / sizeof(cluster))); 255 clsectoff = (cluster % (BPS / sizeof(cluster))); 256 257 /* XXX This is pretty wasteful without a block cache for the FAT. */ 258 fatsect = read_sect(fp, clsect, BPS); 259 nextclust = le32toh(fatsect[clsectoff]); 260 free(fatsect); 261 262 return (nextclust); 263 } 264 265 static void 266 exfat_find_label(FILE *fp, const struct exfat_vbr *ev, unsigned BPS, 267 char *label_out, size_t label_sz) 268 { 269 uint32_t rootdir_cluster, sects_per_clust, cluster_offset_sect; 270 off_t rootdir_sect; 271 struct exfat_dirent *declust, *it; 272 273 cluster_offset_sect = le32toh(ev->ev_cluster_offset); 274 rootdir_cluster = le32toh(ev->ev_rootdir_cluster); 275 sects_per_clust = (1u << ev->ev_log_sect_per_clust); 276 277 if (rootdir_cluster < FIRST_CLUSTER) { 278 warnx("%s: invalid rootdir cluster %u < %d", __func__, 279 rootdir_cluster, FIRST_CLUSTER); 280 return; 281 } 282 283 284 for (; rootdir_cluster != END_CLUSTER_SENTINEL; 285 rootdir_cluster = exfat_fat_next(fp, ev, BPS, rootdir_cluster)) { 286 if (rootdir_cluster == BAD_BLOCK_SENTINEL) { 287 warnx("%s: Bogus bad block in root directory chain", 288 __func__); 289 return; 290 } 291 292 rootdir_sect = (rootdir_cluster - FIRST_CLUSTER) * 293 sects_per_clust + cluster_offset_sect; 294 declust = read_sectn(fp, rootdir_sect, sects_per_clust, BPS); 295 for (it = declust; 296 it < declust + (sects_per_clust * BPS / sizeof(*it)); it++) { 297 bool eod = false; 298 299 /* 300 * Simplistic directory traversal; doesn't do any 301 * validation of "MUST" requirements in spec. 302 */ 303 switch (it->xde_type) { 304 case XDE_TYPE_EOD: 305 eod = true; 306 break; 307 case XDE_TYPE_VOL_LABEL: { 308 struct exfat_de_label *lde = (void*)it; 309 convert_label(lde->xdel_vol_lbl, 310 lde->xdel_char_cnt, label_out, label_sz); 311 free(declust); 312 return; 313 } 314 } 315 316 if (eod) 317 break; 318 } 319 free(declust); 320 } 321 } 322 #endif /* WITH_ICONV */ 323 324 int 325 fstyp_exfat(FILE *fp, char *label, size_t size) 326 { 327 struct exfat_vbr *ev; 328 uint32_t *cksect; 329 unsigned bytespersec; 330 uint32_t chksum; 331 int error; 332 333 cksect = NULL; 334 ev = (struct exfat_vbr *)read_buf(fp, 0, 512); 335 if (ev == NULL || strncmp(ev->ev_fsname, "EXFAT ", 8) != 0) 336 goto fail; 337 338 if (ev->ev_log_bytes_per_sect < 9 || ev->ev_log_bytes_per_sect > 12) { 339 warnx("exfat: Invalid BytesPerSectorShift"); 340 goto done; 341 } 342 343 bytespersec = (1u << ev->ev_log_bytes_per_sect); 344 345 error = exfat_compute_boot_chksum(fp, MAIN_BOOT_REGION_SECT, 346 bytespersec, &chksum); 347 if (error != 0) 348 goto done; 349 350 cksect = read_sect(fp, MAIN_BOOT_REGION_SECT + SUBREGION_CHKSUM_SECT, 351 bytespersec); 352 353 /* 354 * Technically the entire sector should be full of repeating 4-byte 355 * checksum pattern, but we only verify the first. 356 */ 357 if (chksum != le32toh(cksect[0])) { 358 warnx("exfat: Found checksum 0x%08x != computed 0x%08x", 359 le32toh(cksect[0]), chksum); 360 goto done; 361 } 362 363 #ifdef WITH_ICONV 364 if (show_label) 365 exfat_find_label(fp, ev, bytespersec, label, size); 366 #endif 367 368 done: 369 free(cksect); 370 free(ev); 371 return (0); 372 373 fail: 374 free(ev); 375 return (1); 376 } 377