1
#include <stdio.h>
2
#include <sys/types.h>
3
#include <stdlib.h>
4
#include <stdint.h>
5
#include <unistd.h>
6
#include <fcntl.h>
7
#include <string.h>
8
#include <math.h>
9
#include <limits.h>
10

11
#pragma pack(1)
12
#pragma pack(push)
13
typedef struct MAIN_BOOT_SECTOR {
14
  uint8_t jump_boot[3];
15
  char fs_name[8];
16
  uint8_t must_be_zero[53];
17
  uint64_t partition_offset;
18
  uint64_t volume_length;
19
  uint32_t fat_offset;
20
  uint32_t fat_length;
21
  uint32_t cluster_heap_offset;
22
  uint32_t cluster_count;
23
  uint32_t first_cluster_of_root_directory;
24
  uint32_t volume_serial_number;
25
  uint16_t fs_revision;
26
  uint16_t fs_flags;
27
  uint8_t bytes_per_sector_shift;
28
  uint8_t sectors_per_cluster_shift;
29
  uint8_t number_of_fats;
30
  uint8_t drive_select;
31
  uint8_t percent_in_use;
32
  uint8_t reserved[7];
33
  uint8_t bootcode[390];
34
  uint16_t boot_signature;
35
} main_boot_sector;
36
#pragma pack(pop)
37

38
#pragma pack(1)
39
#pragma pack(push)
40
typedef struct DIR_ENTRY {
41
  uint8_t entry_type;
42
  uint8_t bitmap_flags;
43
  uint8_t reserved[18];
44
  uint32_t first_cluster;
45
  uint64_t data_length;
46
} entry;
47
#pragma pack(pop)
48

49
#define BYTES_PER_CLUSTER (1 << mbs->bytes_per_sector_shift) * (1 << mbs->sectors_per_cluster_shift)
50

51
int main(int argc, char *argv[]) {
52
  (void)argc;
53

54
  char *volume_name = argv[1];
55
  main_boot_sector *mbs = malloc(sizeof(main_boot_sector));
56

57
  int fd = open(volume_name, O_RDONLY);
58

59
  // just put tha whole thang in there
60
  read(fd, mbs, 512);
61

62
  //check JumpBoot
63
  printf("Checking JumpBoot\n");
64
  if(mbs->jump_boot[0] != 0xEB && mbs->jump_boot[1] != 0x76 && mbs->jump_boot[2] != 0x90 ){
65
    printf("Inconsistent file system: JumpBoot must be: '0xEB7690', value is '0x%x%x%x'.\n", mbs->jump_boot[0], mbs->jump_boot[1], mbs->jump_boot[2]);
66
    exit(EXIT_FAILURE);
67
  }
68
  printf("* JumpBoot OK w/ value: '0x%x%x%x'.\n", mbs->jump_boot[0], mbs->jump_boot[1], mbs->jump_boot[2]);
69
  // check name
70
  printf("Checking file system name\n");
71
  if(strcmp("EXFAT   ", mbs->fs_name) != 0){
72
    printf("Inconsistent file system: File System name must be : 'EXFAT   ', value is '%s'\n", mbs->fs_name);
73
    exit(EXIT_FAILURE);
74
  }
75
  printf(" * File System name OK w/ value: 'EXFAT   '.\n");
76

77

78
  // check must be zero
79
  printf("Checking must be zero area\n");
80
  for(int i = 0; i < 53; i++){
81
    if(mbs->must_be_zero[i] != 0){
82
      printf("Inconsistent file system: Must Be Zero section needs all zeros, non-zero at index: %d.\n", i);
83
      exit(EXIT_FAILURE);
84
    }
85
  }
86
  printf(" * Must be zero area OK, has only zeros.\n");
87
  // no need to check partition offset
88
  // check volume length
89

90

91

92
  printf("Checking volume length\n");
93
  if(mbs->volume_length > ULLONG_MAX || mbs->volume_length < ((1 << 20) / (1 << mbs->bytes_per_sector_shift))){
94
    printf("Inconsistent file system: Volume length out of range, length is %lu instead\n", mbs->volume_length);
95
    exit(EXIT_FAILURE);
96
  }
97
  printf(" * Volume length OK w/ value: '%lu'.\n", mbs->volume_length);
98

99
  // check fatOffset
100
  printf("Checking fatOffset \n");
101
  if((mbs->fat_offset < 24) || mbs->fat_offset > (mbs->cluster_heap_offset - (mbs->fat_length * mbs->number_of_fats))){
102
    printf("Inconsistent file system: fatOffset out of range, offset is %u instead\n", mbs->fat_offset);
103
    exit(EXIT_FAILURE);
104
  }
105
  printf(" * Fat Offset OK w/ value: '%u'\n", mbs->fat_offset);
106

107
  // check fatLength
108
  printf("Checking fatLength\n");
109
  unsigned int most = floor((mbs->cluster_heap_offset - mbs->fat_offset) / mbs->number_of_fats);
110
  unsigned int least = (mbs->cluster_count + 2) * (1 << 2) / (1 << mbs->bytes_per_sector_shift);
111
  if(mbs->fat_length > most || mbs->fat_length < least){
112
    printf("Inconsistent file system: fatLength our of range [%d, %d], instead %d\n",least, most, mbs->fat_length );
113
    exit(EXIT_FAILURE);
114
  }
115
  printf(" * Fat Length OK w/ value: '%d'.\n", mbs->fat_length);
116

117
  // check First Cluster of Root Directory
118
  printf("First Cluster of Root Directory\n");
119
  if(mbs->first_cluster_of_root_directory < 2 || mbs->first_cluster_of_root_directory > mbs->cluster_count + 1){
120
    printf("Inconsistent file system: First Cluster of Root Directory out of range [2, %d], instead is %d\n",mbs->cluster_count + 1, mbs->first_cluster_of_root_directory );
121
    exit(EXIT_FAILURE);
122
  }
123
  printf(" * First Cluster of Root Directory OK w/ value: '%d'.\n", mbs->first_cluster_of_root_directory);
124

125
  // check bootSignature
126
  printf("Checking bootSignature\n");
127
  if(mbs->boot_signature != 0xAA55){
128
    printf("Inconsistent file system: Boot signature is invalid, should be 0xAA55, instead: %x\n", mbs->boot_signature);
129
    exit(EXIT_FAILURE);
130
  }
131
  printf(" * Boot Signature OK w/ value '0x%x'.\n", mbs->boot_signature);
132

133
  printf("MBR appears to be consistent\n");
134

135
  /*
136
    * Find the cluster for the root directory using the FirstClusterOfRootDirectory cluster.
137
    * Scan through the DirectoryEntrys in the root directory until you find the entry with entry type 0x81 (indicating the Allocation Bitmap directory entry).
138
        * Each DirectoryEntry is 32 bytes in size, and the EntryType is always the first byte.
139
    * Find the first cluster of the Allocation Bitmap using the FirstCluster field from the Allocation Bitmap DirectoryEntry.
140
    * Read all bytes from the cluster. The number of bytes you should read from the cluster are DataLength bytes.
141
    * Count the number of set bits in each byte using the __builtin_popcount function (population count counts the number of set bits).
142
    * Check that the fraction of set bits out of all bits in the allocation bitmap matches PercentInUse in the MBR.
143
   */
144

145
  int allocation_bit_percent = 0;
146
  int alloc_count = 0;
147

148
  printf("Checking allocation bitmap\n");
149

150
  // cluster[n] = clusterHeapOffset + (n) * 2 ^(sectorsPerClusterShift)
151
  int root_address = mbs->cluster_heap_offset * (1 << mbs->bytes_per_sector_shift) + ((mbs->first_cluster_of_root_directory - 2) * BYTES_PER_CLUSTER);
152

153

154

155

156
  lseek(fd, root_address, SEEK_SET);
157
  uint32_t cluster_ind;
158
  uint64_t dat_len;
159
  // each entry is 32 bytes, first byte is type
160
  // find entry with type == 0x81 (indicating alloc bitmap entry)
161
  int x = 0;
162

163
  while(1){
164
    //printf("%d\n",x);
165
    entry *ent = malloc(sizeof(entry));
166
    read(fd, ent, 32);
167
    if(ent->entry_type == 0x81 && ent->data_length == 303){
168
      // is allocation bitmap entry
169
      // get first cluster field
170
      cluster_ind = ent->first_cluster;
171
      dat_len = ent->data_length;
172
      break;
173

174
    }
175

176
    free(ent);
177
    x++;
178
  }
179

180
  // have cluster index for bitmap
181
  int bit_address = mbs->cluster_heap_offset * (1 << mbs->bytes_per_sector_shift) +  ((cluster_ind - 2) * BYTES_PER_CLUSTER);
182

183
  lseek(fd, bit_address, SEEK_SET);
184
  // read in bitmap, then do pop-count
185
  unsigned char bitmap[dat_len];
186
  //printf("size: %lu\n", sizeof(bitmap));
187
  read(fd, bitmap, dat_len);
188
  int i = 0;
189
  while((uint64_t)i < dat_len){
190
    int set_bits = __builtin_popcount(bitmap[i]);
191
    alloc_count += set_bits;
192
    i++;
193
  }
194

195

196
  allocation_bit_percent = floor(((double)alloc_count / mbs->cluster_count) * 100);
197

198
  if(mbs->percent_in_use != allocation_bit_percent){
199
    printf("Inconsistent file system: Bitmap allocation doesn't match percent in use (%d%%), instead: %d/%u bits -> %d%%\n", mbs->percent_in_use, alloc_count, mbs->cluster_count, allocation_bit_percent);
200
    exit(EXIT_FAILURE);
201
  }
202

203
  printf(" * Allocation bitmap matches MBR percent in use.\n");
204

205
  printf("File System appears to be consistent\n");
206
  close(fd);
207
  exit(EXIT_SUCCESS);
208
}