WinHexView

Introduction

This article, a short one, is about a tool that I wrote some time ago and I called it WinHexView. When I work at home, sometimes I like or I have to check the content of binary files. Coming from a Linux world where the terminal is your best friend, I was disappointed because I had to search for such a tool. And there are some great options!

So, I took a look at WinAPI and I started coding in C++. I cannot say that I created the best tool for inspecting file's content but it does its job. I'm using it successfully at home and at work and I'm really glad that I created it.

Using the Code

For implementing the tool, I used WinAPI (it was, somehow, an obsession to use it even if maybe it's not the best choice) and C++ as the programming language. At the base of the application, I tried to decouple the object that invokes the operation from the one that knows how to perform it. Basically I wanted to have a class ContentFormat...

#pragma once
class ContentFormat
{
public:
	ContentFormat();
	virtual ~ContentFormat();
	void DefaultPrint();
	void AsciiPrint();
	void OneByteOctalDisplay();
	void CharacterDisplay();
	void DecimalDisplay();
	void Configure(byte * buffer, DWORD bufferSize);
	std::string GetFormattedOutput();

private:
	byte *gBuffer;
	DWORD gBufferSize;
	const byte gNoOfBytes = 8;
	const UINT32 gStartOffsetValue = 0x00000000;
	const byte gOffsetIncrement = 0x10;
	std::stringstream gContentStream;
};

...that has methods for different output formats like printing ASCII values, characters, decimal values, etc. and a class Command that calls one of those methods.

#pragma once

class Command
{
public:
	Command(std::shared_ptr<ContentFormat> obj);
	virtual ~Command();
	void SetExecuteMethod(void(ContentFormat::*method)());
	void Execute();
private:
	std::shared_ptr<ContentFormat>gObj;
	void(ContentFormat::*gMethod)();

};

Basically, I implemented a sort of Command Design Pattern.

For reading the files, I created a class FileReader as a layer over the needed WinAPI calls.

#pragma once
class FileManagementException :public std::exception
{
private:
	std::string g_msg;
public:
	FileManagementException(const std::string& msg) :g_msg(msg)
	{}

	FileManagementException() :g_msg("FileManagementException thrown!"){}
	const char *what() const
	{
		return g_msg.c_str();
	}
};
class FileReader
{
public:
	FileReader();
	virtual ~FileReader();
	void *LoadFileContent(DWORD *bufferSize) throw (std::exception);
	void SetInputFile(std::wstring filePath);
private:
	DWORD Read(HANDLE hFile, void *buffer, INT64 count)throw (std::exception);
	std::wstring gFilePath;
	HANDLE gFileHandle;
};

Points of Interest

As I probably mentioned, WinHexView is a command line tool for displaying a specified file's content in hexadecimal, decimal, octal format, etc. For me, it's all I needed for inspecting content of files in hex. I could write it in C# or CLI, but at that moment, I thought that it is more interesting to use C++ and WinAPI.

If someone wants to use it and finds some lines of codes that are considered a bad practice, or bugs, or has some ideas to improve this tool, please feel free to fill an issue on GitHub.

Also the repository contains a doc folder where I stored some markdown documents, a test report, release notes and also a document for review. Those are some of the basic documentations that I started to use in all my projects. If you find an issue, you can fill it or edit the review document.

History

• Created article
• Updated article
• Added link to repository
• Updated tags
• Posted as a tip