Most programmers have a love or hate relationship with programming in assembly language. For some of them, assembly programming is the ultimate programming language, the last step before interacting directly with the hardware. Other programmers prefer to rely on higher level languages. Pirogov shows, in this book, that a third way exists, where advanced Windows programming can be done in assembly language.

I would have never thought that Windows programming (using the Win32 application programming interface (API)) could be so elegant and easy in assembly. The book assumes that the reader is already familiar with IA32 assembly programming, and shows, in its more than 600 pages, how Windows-specific programming is done, with both Turbo Assembler (TASM), from Borland, and the Microsoft Macro Assembler (MASM).

The reader is introduced first to basic Windows graphical user interface (GUI) programming: creating a main window, adding buttons, mouse and keyboard processing, resource files, menus, and dialogs. These topics are detailed in the first ten chapters.

The next chapters go beyond GUI programming, illustrating how multitasking, timer management, and network programming are done. Code examples are abundant, and while, from a technical viewpoint, most of the code can be reduced to WIN32 API calls (namely, pushing values on the stack and calling functions provided by the kernel32.dll), these chapters are particularly interesting, since some of the presented concepts, like multitasking, are typically addressed in higher level languages (C/Java/Python), and are very rarely detailed from an assembly programming perspective. To summarize, this part of the book demonstrates many of the programming techniques presented in Petzold’s book [1], but implemented in assembly language.

The final part of the book covers advanced system programming for Windows, debugging, and reverse engineering techniques. The author first demonstrates how Windows services are developed and installed for a Windows machine. The next chapters address some more hacking-oriented techniques, like reverse engineering with a disassembler, patching executables in order to bypass “annoying” license information, and kernel level debugging with a popular debugger (SoftICE). Although these issues are highly interesting, not only for hackers, but also for security researchers facing reverse engineering of potential malware, the chapters related to these topics are rather short, and relatively shallow. I wish these topics had been addressed to the same extent as the topics in the first part. However, these chapters could serve as good complementary reading for a book like Kaspersky’s [2].

The multiple code examples make this book an excellent reference for applied, hands-on programming-oriented readers. Unfortunately, there is no CD or book-related Web site, where these code examples could be downloaded. Typographical errors in the code samples related to incomplete jump labels can be easily spotted by an intermediate or advanced programmer, but might be frustrating to a beginner.

I would recommend this book highly to an advanced or intermediate assembly programmer. Beginners and novices, however, might have a hard time digesting it.