#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <stddef.h>

#include <windows.h>

#include <math.h> // log()

#include <conio.h> // getch()

char diskread_version[] = "3.4";

LPSTR error_message(DWORD error)

{

LPSTR lpMsgBuf;

FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&lpMsgBuf, 0, NULL);

lpMsgBuf[strcspn(lpMsgBuf, "\r\n")] = 0; // Trim newline

return (LPSTR)lpMsgBuf;

}

char *strncpy_n(char *dest, const char *src, size_t count)

{

char *ret = dest;

while (count--)

{

if (!(*dest = *src ))

{

return ret;

}

}

*dest = '\0';

return ret;

}

char *strlower_n(char *s)

{

char *p = (char *)calloc(sizeof(char), strlen(s) 1);

strncpy_n(p, s, strlen(s));

for (size_t i = 0; i < strlen(p); i )

{

p[i] = tolower(p[i]);

}

return p;

}

int hex_digits(LONG64 a)

{

long c;

if (a == 0)

{

return 1;

}

if (a < 0)

{

a = -a;

}

c = (int)(log((double)a) / log((double)16)); // base 16 logarithm

return c;

}

void help()

{

printf(

"DiskRead v%s - Read a disk or a file in raw mode.\n"

"\n"

"Usage:\n"

" diskread <drive | file> [-b <bytes per line>] [-e <export file>] [-h] [-o <offset>] [-s <read size>] [-u] [-x] [-y]\n"

"\n"

"Switches:\n"

" -b, --bytes <bytecount> Change the number of bytes per line displayed\n"

" -e, --export <file> Export to a file\n"

" -h, --hideoffset Hide the offset display\n"

" -o, --offset <offset> Set a custom starting offset for the file\n"

" -s, --size <read size> Read a specific amount of bytes from the file. 512 bytes are read by default\n"

" -u, --uppercase Display hexadecimal values in uppercase\n"

" -x, --hexadecimal Only display the hexadecimal representation\n"

" -y, --yes Do not prompt for confirmation when exporting to a device file\n"

"\n"

"Examples:\n"

" diskread \\\\.\\PhysicalDrive0 -s 512 -o 0 -e bootsect.bak\n"

" Reads the first 512 bytes from physical drive 0 and writes them to 'bootsect.bak' (a boot sector backup).\n"

"\n"

" diskread file.txt -s 40 -o 10 -h \n"

" Prints 40 bytes from file.txt, starting to read at the 10th byte without displaying the offset.\n"

"\n"

" diskread image.png -x -u -b 12 \n"

" Prints only 512 bytes of image.png in uppercase hexadecimal, displaying 12 bytes per line.\n"

"\n"

"Return code:\n"

" On success, the number of bytes read is returned, or a negative error value on failure.\n"

"\n"

"DiskRead is a versatile tool that can be used for hexadecimal dumping and backing up boot sectors.\n"

"\n"

"Note: Due to Windows limitations, both disk reading and disk offset are performed in chunks of 512 bytes.\n"

" Values will be rounded up to the nearest multiple of 512.\n"

"\n"

"Copyright (c) 2024 anic17 Software\n",

diskread_version);

}

void missing_param(char *s)

{

fprintf(stderr, "Error: Required parameter after '%s'. See 'diskread --help' for more information.\n", s);

exit(1);

}

int main(int argc, char *argv[])

{

if (argc < 2 || !strcmp(argv[1], "--help") || !strcmp(argv[1], "/?"))

{

help();

return 0;

}

BOOLEAN is_device = FALSE, loaded_device = FALSE;

DWORD bufsize = 512, last_err = 0;

DWORD bytes_read = 0, bytes_written = 0;

size_t bytes_per_line = 16, bytes_pl_temp = 0, substract_optimization = 0;

LPSTR device, export_file, outbuffer;

LONG strtol_ret = 0;

LONG64 strtoll_ret = 0;

LARGE_INTEGER offset = {0}, sector_number = {0};

HANDLE diskread = NULL, export_;

// Copy arguments to variables

PUCHAR buf; // Buffer used to read the disk

device = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LPSTR) * MAX_PATH); // Allocate memory for the device name

export_file = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LPSTR) * MAX_PATH); // Allocate memory for the export file name

BOOLEAN show_offset = TRUE;

BOOLEAN export_mode = FALSE;

BOOLEAN use_caps = FALSE;

BOOLEAN only_hex = FALSE;

BOOLEAN confirm_write = FALSE;

for (int i = 1; i < argc; i )

{

if (!strcmp(argv[i], "-e") || !strcmp(argv[i], "--export"))

{

if (i 1 < argc)

{

if (export_mode)

{

fprintf(stderr, "Error: Already exporting to file '%s'.\n", export_file);

return 1;

}

strncpy_n(export_file, argv[i 1], MAX_PATH);

export_ = CreateFile(export_file, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); // Try to create a handle for creating a new file

if (export_ == INVALID_HANDLE_VALUE && (export_ = CreateFile(export_file, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) // If the handle cannot be created, for example in the case of a drive, try to open it

{

last_err = GetLastError();

fprintf(stderr, "Error: Cannot export to file '%s': %s (0x%lx)\n", export_file, error_message(last_err), last_err); // No option succeeded, throw an error message and leave

return -last_err;

}

export_mode = TRUE;

i ;

}

else

{

missing_param(argv[i]);

}

}

else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--hideoffset"))

{

show_offset = FALSE;

}

else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--uppercase"))

{

use_caps = TRUE;

}

else if (!strcmp(argv[i], "-x") || !strcmp(argv[i], "--hexadecimal"))

{

only_hex = TRUE;

}

else if (!strcmp(argv[i], "-y") || !strcmp(argv[i], "--yes"))

{

confirm_write = TRUE;

}

else if (!strcmp(argv[i], "-o") || !strcmp(argv[i], "--offset"))

{

if (i 1 < argc)

{

if ((strtoll_ret = _strtoui64(argv[i 1], NULL, 10)) >= 0)

{

offset.QuadPart = strtoll_ret; // Assuming compiler has 64-bit support

i ;

}

}

else

{

missing_param(argv[i]);

}

}

else if (!strcmp(argv[i], "-s") || !strcmp(argv[i], "--size"))

{

if (i 1 < argc)

{

if ((strtol_ret = strtol(argv[i 1], NULL, 10)) > 0)

{

bufsize = strtol_ret;

}

else

{

fprintf(stderr, "Warning: Invalid read count. Using default value (%lu).\n", bufsize);

}

i ;

}

else

{

missing_param(argv[i]);

}

}

else if (!strcmp(argv[i], "-b") || !strcmp(argv[i], "--bytesline"))

{

if (i 1 < argc)

{

if ((bytes_pl_temp = strtol(argv[i 1], NULL, 10)) > 0)

{

bytes_per_line = bytes_pl_temp;

}

else

{

fprintf(stderr, "Warning: Invalid number of bytes per line. Using default value (%u).\n", bytes_per_line);

}

i ;

}

else

{

missing_param(argv[i]);

}

}

else

{

if (!loaded_device)

{

strncpy_n(device, argv[i], MAX_PATH);

loaded_device = TRUE;

is_device = GetFileAttributes(device) & FILE_ATTRIBUTE_DEVICE;

}

else

{

fprintf(stderr, "Error: Already reading file '%s'\n", device);

return 1;

}

}

}

buf = (PUCHAR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PUCHAR) * bufsize); // Allocate memory for the buffer

char print_offset[32] = "\n[0xx] "; // Default offset size

if (use_caps)

{

strncpy_n(print_offset, "\n[0xX] ", 11);

}

if (!loaded_device)

{

fprintf(stderr, "Error: No file specified");

return 1;

}

outbuffer = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (5 * bytes_per_line 32) * sizeof(char)); // Allocate space for the output buffer to improve performance

if (is_device && bufsize % 512)

{

fprintf(stderr, "Warning: Disk must be read in chunks of 512 bytes. Adding %lu bytes for padding.\n", 512 - (bufsize % 512));

bufsize = (512 - (bufsize % 512)); // Add bytes for padding

}

if ((offset.QuadPart % 512) && is_device)

{

fprintf(stderr, "Warning: Disk offset must be a multiple of 512. Adding %lld bytes for padding.\n", 512 - (offset.QuadPart % 512));

offset.QuadPart = (512 - (offset.QuadPart % 512));

}

if (offset.QuadPart bufsize > 0xffffffff)

{

snprintf(print_offset, sizeof(print_offset), use_caps ? "\n[0x%%0%dllX] " : "\n[0x%%0%dllx] ", hex_digits(offset.QuadPart bufsize)); // Increase the offset width

}

diskread = CreateFile(device, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); // Open file/disk for reading

if (diskread == INVALID_HANDLE_VALUE || SetFilePointerEx(diskread, offset, NULL, FILE_BEGIN) == (signed)INVALID_SET_FILE_POINTER) // Check for errors & set file offset (if specified)

{

last_err = GetLastError();

fprintf(stderr, "Error: Cannot open the file '%s' to the desired position (%llu): %s (0x%lx)\n", device, offset.QuadPart, error_message(last_err), last_err);

return -last_err;

}

fprintf(stderr, "Trying to read %lu bytes from '%s'...", bufsize, device);

if (is_device)

{

sector_number.QuadPart = offset.QuadPart / 512; // Get the sector number

}

if (ReadFile(diskread, buf, bufsize, &bytes_read, NULL)) // Read the file

{

DWORD i = 0;

fprintf(stderr, " %lu bytes read.", bytes_read);

while (i < bytes_read)

{

memset(outbuffer, 0, (5 * bytes_per_line 20) * sizeof(char)); // Clear the output buffer

if (show_offset)

{

if (is_device)

{

if (!(i & 0x1ff)) // Fast way of doing i % 512

{

printf("\n[Sector %lld]", sector_number.QuadPart );

}

}

snprintf(outbuffer, (5 * bytes_per_line 20) * sizeof(char), print_offset, i offset.QuadPart); // Print the offset

}

else

{

putchar('\n');

}

substract_optimization = bytes_read - i;

for (size_t k = 0; k < (((substract_optimization < bytes_per_line)) ? substract_optimization : bytes_per_line); k )

{

snprintf(outbuffer strlen(outbuffer), (5 * bytes_per_line 20) * sizeof(char), use_caps ? "X " : "x ", buf[i k]); // Print the bytes

}

if (substract_optimization < bytes_per_line)

{

memset(outbuffer strlen(outbuffer), ' ', (bytes_per_line - substract_optimization) * 3); // Fill the print buffer with spaces in case the line is not completed

}

fputs(outbuffer, stdout); // Print the hexadecimal values

if (!only_hex)

{

for (size_t k = 0; k < (((substract_optimization < bytes_per_line)) ? substract_optimization : bytes_per_line); k )

{

putchar(buf[i k] > 0x1f ? buf[i k] : '.'); // Print the ASCII representation

}

}

i = bytes_per_line;

}

}

else

{

last_err = GetLastError();

fprintf(stderr, "\nFailed to read %lu bytes: %s (0x%lx)\n", bufsize, error_message(last_err), last_err);

return last_err;

}

if (export_mode)

{

if (GetFileAttributes(export_file) & FILE_ATTRIBUTE_DEVICE && !confirm_write)

{

fprintf(stderr, "\nWARNING: The write operation you are about to perform to a device file can cause serious data loss!\n"

" The creator is not responsible for any damages. Continue only if you know what you are doing.\n"

"Proceed with the write operation? (y/n)\n"

);

if (tolower(getche()) != 'y')

{

CloseHandle(diskread);

CloseHandle(export_);

return bytes_read;

}

}

if (WriteFile(export_, buf, bufsize, &bytes_written, NULL)) // If exporting, write and close the file

{

printf("\n%lu bytes of '%s' written successfully into '%s'.\n", bytes_written, device, export_file);

}

else

{

fprintf(stderr, "\nFailed to write the file %s: %s (0x%lx)\n", export_file, error_message(last_err), last_err);

}

}

CloseHandle(diskread);

CloseHandle(export_);

return bytes_read;

}