laantungir/otp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 30 Wiki Activity

Version v0.2.58 - Completed refactoring to new OTP thumb drive detection approach

Browse Source
This commit is contained in:
Laan Tungir
2025-08-14 09:14:54 -04:00
parent 1f4a1fb90f
commit 992b9349b3
1 changed files with 20 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
otp.c
View File

@@ -746,9 +746,9 @@ char* find_pad_by_prefix(const char* prefix) {
}
int list_available_pads(void) {
DIR* dir = opendir(PADS_DIR);
DIR* dir = opendir(current_pads_dir);
if (!dir) {
printf("Error: Cannot open pads directory\n");
printf("Error: Cannot open pads directory %s\n", current_pads_dir);
return 0;
}
@@ -768,7 +768,7 @@ int list_available_pads(void) {
// Get pad file size
char full_path[300]; // Increased buffer size to accommodate longer paths
snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
snprintf(full_path, sizeof(full_path), "%s/%s", current_pads_dir, entry->d_name);
struct stat st;
if (stat(full_path, &st) == 0) {
// Get used bytes from state
@@ -2096,7 +2096,7 @@ int decrypt_ascii_file(const char* input_file, const char* output_file) {
int read_state_offset(const char* pad_chksum, uint64_t* offset) {
char state_filename[MAX_HASH_LENGTH + 20];
snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
FILE* state_file = fopen(state_filename, "rb");
if (!state_file) {
@@ -2116,7 +2116,7 @@ int read_state_offset(const char* pad_chksum, uint64_t* offset) {
int write_state_offset(const char* pad_chksum, uint64_t offset) {
char state_filename[MAX_HASH_LENGTH + 20];
snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
FILE* state_file = fopen(state_filename, "wb");
if (!state_file) {
@@ -2257,8 +2257,8 @@ int collect_keyboard_entropy(unsigned char* entropy_buffer, size_t max_size, siz
// Directory management functions
int ensure_pads_directory(void) {
struct stat st = {0};
if (stat(PADS_DIR, &st) == -1) {
if (mkdir(PADS_DIR, 0755) != 0) {
if (stat(current_pads_dir, &st) == -1) {
if (mkdir(current_pads_dir, 0755) != 0) {
return 1;
}
}
@@ -2356,192 +2356,6 @@ int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size) {
return 0; // No OTP drive found
}
// USB drive detection functions implementation
int scan_usb_drives_for_pads(struct USBPadInfo** usb_pads, int* usb_count) {
const char* mount_dirs[] = {"/media", "/run/media", "/mnt", NULL};
struct USBPadInfo* pads = malloc(100 * sizeof(struct USBPadInfo)); // Support up to 100 USB pads
int count = 0;
if (!pads) {
*usb_pads = NULL;
*usb_count = 0;
return 1;
}
for (int mount_idx = 0; mount_dirs[mount_idx] != NULL; mount_idx++) {
DIR* mount_dir = opendir(mount_dirs[mount_idx]);
if (!mount_dir) continue;
struct dirent* mount_entry;
while ((mount_entry = readdir(mount_dir)) != NULL && count < 100) {
if (mount_entry->d_name[0] == '.') continue;
char mount_path[1024];
snprintf(mount_path, sizeof(mount_path), "%s/%s", mount_dirs[mount_idx], mount_entry->d_name);
// For /run/media, we need to go one level deeper (skip username)
if (strcmp(mount_dirs[mount_idx], "/run/media") == 0) {
DIR* user_dir = opendir(mount_path);
if (!user_dir) continue;
struct dirent* user_entry;
while ((user_entry = readdir(user_dir)) != NULL && count < 100) {
if (user_entry->d_name[0] == '.') continue;
char user_mount_path[2048];
snprintf(user_mount_path, sizeof(user_mount_path), "%s/%s", mount_path, user_entry->d_name);
// Scan this mount point for pads
DIR* drive_dir = opendir(user_mount_path);
if (!drive_dir) continue;
struct dirent* drive_entry;
while ((drive_entry = readdir(drive_dir)) != NULL && count < 100) {
// Look for .pad files in root of drive
if (strstr(drive_entry->d_name, ".pad") && strlen(drive_entry->d_name) == 68) {
char pad_path[4096], state_path[4096];
snprintf(pad_path, sizeof(pad_path), "%s/%s", user_mount_path, drive_entry->d_name);
// Extract checksum from filename
strncpy(pads[count].chksum, drive_entry->d_name, 64);
pads[count].chksum[64] = '\0';
// Check if corresponding .state file exists
snprintf(state_path, sizeof(state_path), "%s/%s.state", user_mount_path, pads[count].chksum);
if (access(state_path, R_OK) == 0) {
// Valid pad found
strncpy(pads[count].pad_path, pad_path, sizeof(pads[count].pad_path) - 1);
strncpy(pads[count].state_path, state_path, sizeof(pads[count].state_path) - 1);
strncpy(pads[count].mount_point, user_mount_path, sizeof(pads[count].mount_point) - 1);
// Read state offset
FILE* state_file = fopen(state_path, "rb");
if (state_file) {
if (fread(&pads[count].state_offset, sizeof(uint64_t), 1, state_file) != 1) {
pads[count].state_offset = 0;
}
fclose(state_file);
} else {
pads[count].state_offset = 0;
}
count++;
}
}
}
closedir(drive_dir);
}
closedir(user_dir);
} else {
// Direct mount point (like /media/DRIVE_NAME or /mnt/DRIVE_NAME)
DIR* drive_dir = opendir(mount_path);
if (!drive_dir) continue;
struct dirent* drive_entry;
while ((drive_entry = readdir(drive_dir)) != NULL && count < 100) {
// Look for .pad files in root of drive
if (strstr(drive_entry->d_name, ".pad") && strlen(drive_entry->d_name) == 68) {
char pad_path[2048], state_path[2048];
snprintf(pad_path, sizeof(pad_path), "%s/%s", mount_path, drive_entry->d_name);
// Extract checksum from filename
strncpy(pads[count].chksum, drive_entry->d_name, 64);
pads[count].chksum[64] = '\0';
// Check if corresponding .state file exists
snprintf(state_path, sizeof(state_path), "%s/%s.state", mount_path, pads[count].chksum);
if (access(state_path, R_OK) == 0) {
// Valid pad found
strncpy(pads[count].pad_path, pad_path, sizeof(pads[count].pad_path) - 1);
strncpy(pads[count].state_path, state_path, sizeof(pads[count].state_path) - 1);
strncpy(pads[count].mount_point, mount_path, sizeof(pads[count].mount_point) - 1);
// Read state offset
FILE* state_file = fopen(state_path, "rb");
if (state_file) {
if (fread(&pads[count].state_offset, sizeof(uint64_t), 1, state_file) != 1) {
pads[count].state_offset = 0;
}
fclose(state_file);
} else {
pads[count].state_offset = 0;
}
count++;
}
}
}
closedir(drive_dir);
}
}
closedir(mount_dir);
}
*usb_pads = pads;
*usb_count = count;
return 0;
}
int resolve_state_conflicts(const char* chksum, struct USBPadInfo* usb_pads, int usb_count,
uint64_t local_offset, uint64_t* resolved_offset, char** authoritative_path) {
uint64_t max_offset = local_offset;
int conflicts_found = 0;
char local_path[512];
snprintf(local_path, sizeof(local_path), "%s/%s.state", PADS_DIR, chksum);
// Initially assume local is authoritative
*authoritative_path = strdup(local_path);
// Check all USB pads with same checksum
for (int i = 0; i < usb_count; i++) {
if (strcmp(usb_pads[i].chksum, chksum) == 0) {
if (usb_pads[i].state_offset != local_offset) {
conflicts_found = 1;
if (usb_pads[i].state_offset > max_offset) {
max_offset = usb_pads[i].state_offset;
free(*authoritative_path);
*authoritative_path = strdup(usb_pads[i].state_path);
}
}
}
}
if (conflicts_found) {
printf("Warning: State conflict detected for pad %s\n", chksum);
printf("Multiple state files found with different offsets. Using highest offset: %lu\n", max_offset);
// Update all state files to use the maximum offset
// Update local state file
FILE* local_state = fopen(local_path, "wb");
if (local_state) {
fwrite(&max_offset, sizeof(uint64_t), 1, local_state);
fclose(local_state);
}
// Update USB state files
for (int i = 0; i < usb_count; i++) {
if (strcmp(usb_pads[i].chksum, chksum) == 0) {
FILE* usb_state = fopen(usb_pads[i].state_path, "wb");
if (usb_state) {
fwrite(&max_offset, sizeof(uint64_t), 1, usb_state);
fclose(usb_state);
}
// Update the cached offset
usb_pads[i].state_offset = max_offset;
}
}
}
*resolved_offset = max_offset;
return conflicts_found ? 1 : 0;
}
void free_usb_pads(struct USBPadInfo* usb_pads, int count) {
(void)count; // Suppress unused parameter warning
if (usb_pads) {
free(usb_pads);
}
}
@@ -3095,59 +2909,42 @@ int handle_file_encrypt(void) {
int handle_pads_menu(void) {
printf("\n=== Pad Management ===\n");
printf("Scanning for USB drives...\n");
// Scan for USB pads first
struct USBPadInfo* usb_pads = NULL;
int usb_count = 0;
scan_usb_drives_for_pads(&usb_pads, &usb_count);
// Get list of local pads
DIR* dir = opendir(PADS_DIR);
// Get list of pads from current directory
DIR* dir = opendir(current_pads_dir);
if (!dir) {
printf("Error: Cannot open pads directory\n");
free_usb_pads(usb_pads, usb_count);
printf("Error: Cannot open pads directory %s\n", current_pads_dir);
return 1;
}
// Structure to store combined pad information
// Structure to store pad information
struct PadInfo {
char chksum[65];
char size_str[32];
char used_str[32];
double percentage;
char location[256]; // Store location info (local/USB)
int is_usb; // Flag to indicate USB pad
char location[256]; // Store location info
};
struct PadInfo pads[200]; // Support up to 200 total pads (local + USB)
struct PadInfo pads[100]; // Support up to 100 pads
int pad_count = 0;
// First, collect all local pad information
// Collect all pad information
struct dirent* entry;
while ((entry = readdir(dir)) != NULL && pad_count < 200) {
while ((entry = readdir(dir)) != NULL && pad_count < 100) {
if (strstr(entry->d_name, ".pad") && strlen(entry->d_name) == 68) {
strncpy(pads[pad_count].chksum, entry->d_name, 64);
pads[pad_count].chksum[64] = '\0';
// Get pad file size and usage info
char full_path[300];
snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
char full_path[512];
snprintf(full_path, sizeof(full_path), "%s/%s", current_pads_dir, entry->d_name);
struct stat st;
if (stat(full_path, &st) == 0) {
// Get used bytes from state (check for conflicts with USB)
// Get used bytes from state
uint64_t used_bytes;
read_state_offset(pads[pad_count].chksum, &used_bytes);
// Check for state conflicts with USB pads
uint64_t resolved_offset;
char* authoritative_path;
if (resolve_state_conflicts(pads[pad_count].chksum, usb_pads, usb_count,
used_bytes, &resolved_offset, &authoritative_path) == 1) {
used_bytes = resolved_offset;
}
free(authoritative_path);
// Format total size
if (st.st_size < 1024) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
@@ -3173,9 +2970,8 @@ int handle_pads_menu(void) {
// Calculate percentage
pads[pad_count].percentage = (double)used_bytes / st.st_size * 100.0;
// Set location info
strcpy(pads[pad_count].location, "pads");
pads[pad_count].is_usb = 0;
// Set location info using directory display
get_directory_display(full_path, pads[pad_count].location, sizeof(pads[pad_count].location));
pad_count++;
}
@@ -3183,59 +2979,6 @@ int handle_pads_menu(void) {
}
closedir(dir);
// Then, add USB pads (avoiding duplicates)
for (int i = 0; i < usb_count && pad_count < 200; i++) {
// Check if this USB pad is already in local pads
int is_duplicate = 0;
for (int j = 0; j < pad_count; j++) {
if (strcmp(pads[j].chksum, usb_pads[i].chksum) == 0) {
is_duplicate = 1;
break;
}
}
if (!is_duplicate) {
// Add USB pad
strcpy(pads[pad_count].chksum, usb_pads[i].chksum);
// Get pad file size
struct stat st;
if (stat(usb_pads[i].pad_path, &st) == 0) {
// Format total size
if (st.st_size < 1024) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
} else if (st.st_size < 1024 * 1024) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1024.0);
} else if (st.st_size < 1024 * 1024 * 1024) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1024.0 * 1024.0));
} else {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0));
}
// Format used size (already resolved)
uint64_t used_bytes = usb_pads[i].state_offset;
if (used_bytes < 1024) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes);
} else if (used_bytes < 1024 * 1024) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1024.0);
} else if (used_bytes < 1024 * 1024 * 1024) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1024.0 * 1024.0));
} else {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0));
}
// Calculate percentage
pads[pad_count].percentage = (double)used_bytes / st.st_size * 100.0;
// Set USB location info
get_directory_display(usb_pads[i].pad_path, pads[pad_count].location, sizeof(pads[pad_count].location));
pads[pad_count].is_usb = 1;
pad_count++;
}
}
}
if (pad_count == 0) {
printf("No pads found.\n");
printf("\nOptions:\n");