Table of Contents for
Practical Malware Analysis

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Practical Malware Analysis by Andrew Honig Published by No Starch Press, 2012
  1. Cover
  2. Practical Malware Analysis: The Hands-On Guide to Dissecting Malicious Software
  3. Praise for Practical Malware Analysis
  4. Warning
  5. About the Authors
  6. About the Technical Reviewer
  7. About the Contributing Authors
  8. Foreword
  9. Acknowledgments
  10. Individual Thanks
  11. Introduction
  12. What Is Malware Analysis?
  13. Prerequisites
  14. Practical, Hands-On Learning
  15. What’s in the Book?
  16. 0. Malware Analysis Primer
  17. The Goals of Malware Analysis
  18. Malware Analysis Techniques
  19. Types of Malware
  20. General Rules for Malware Analysis
  21. I. Basic Analysis
  22. 1. Basic Static Techniques
  23. Antivirus Scanning: A Useful First Step
  24. Hashing: A Fingerprint for Malware
  25. Finding Strings
  26. Packed and Obfuscated Malware
  27. Portable Executable File Format
  28. Linked Libraries and Functions
  29. Static Analysis in Practice
  30. The PE File Headers and Sections
  31. Conclusion
  32. Labs
  33. 2. Malware Analysis in Virtual Machines
  34. The Structure of a Virtual Machine
  35. Creating Your Malware Analysis Machine
  36. Using Your Malware Analysis Machine
  37. The Risks of Using VMware for Malware Analysis
  38. Record/Replay: Running Your Computer in Reverse
  39. Conclusion
  40. 3. Basic Dynamic Analysis
  41. Sandboxes: The Quick-and-Dirty Approach
  42. Running Malware
  43. Monitoring with Process Monitor
  44. Viewing Processes with Process Explorer
  45. Comparing Registry Snapshots with Regshot
  46. Faking a Network
  47. Packet Sniffing with Wireshark
  48. Using INetSim
  49. Basic Dynamic Tools in Practice
  50. Conclusion
  51. Labs
  52. II. Advanced Static Analysis
  53. 4. A Crash Course in x86 Disassembly
  54. Levels of Abstraction
  55. Reverse-Engineering
  56. The x86 Architecture
  57. Conclusion
  58. 5. IDA Pro
  59. Loading an Executable
  60. The IDA Pro Interface
  61. Using Cross-References
  62. Analyzing Functions
  63. Using Graphing Options
  64. Enhancing Disassembly
  65. Extending IDA with Plug-ins
  66. Conclusion
  67. Labs
  68. 6. Recognizing C Code Constructs in Assembly
  69. Global vs. Local Variables
  70. Disassembling Arithmetic Operations
  71. Recognizing if Statements
  72. Recognizing Loops
  73. Understanding Function Call Conventions
  74. Analyzing switch Statements
  75. Disassembling Arrays
  76. Identifying Structs
  77. Analyzing Linked List Traversal
  78. Conclusion
  79. Labs
  80. 7. Analyzing Malicious Windows Programs
  81. The Windows API
  82. The Windows Registry
  83. Networking APIs
  84. Following Running Malware
  85. Kernel vs. User Mode
  86. The Native API
  87. Conclusion
  88. Labs
  89. III. Advanced Dynamic Analysis
  90. 8. Debugging
  91. Source-Level vs. Assembly-Level Debuggers
  92. Kernel vs. User-Mode Debugging
  93. Using a Debugger
  94. Exceptions
  95. Modifying Execution with a Debugger
  96. Modifying Program Execution in Practice
  97. Conclusion
  98. 9. OllyDbg
  99. Loading Malware
  100. The OllyDbg Interface
  101. Memory Map
  102. Viewing Threads and Stacks
  103. Executing Code
  104. Breakpoints
  105. Loading DLLs
  106. Tracing
  107. Exception Handling
  108. Patching
  109. Analyzing Shellcode
  110. Assistance Features
  111. Plug-ins
  112. Scriptable Debugging
  113. Conclusion
  114. Labs
  115. 10. Kernel Debugging with WinDbg
  116. Drivers and Kernel Code
  117. Setting Up Kernel Debugging
  118. Using WinDbg
  119. Microsoft Symbols
  120. Kernel Debugging in Practice
  121. Rootkits
  122. Loading Drivers
  123. Kernel Issues for Windows Vista, Windows 7, and x64 Versions
  124. Conclusion
  125. Labs
  126. IV. Malware Functionality
  127. 11. Malware Behavior
  128. Downloaders and Launchers
  129. Backdoors
  130. Credential Stealers
  131. Persistence Mechanisms
  132. Privilege Escalation
  133. Covering Its Tracks—User-Mode Rootkits
  134. Conclusion
  135. Labs
  136. 12. Covert Malware Launching
  137. Launchers
  138. Process Injection
  139. Process Replacement
  140. Hook Injection
  141. Detours
  142. APC Injection
  143. Conclusion
  144. Labs
  145. 13. Data Encoding
  146. The Goal of Analyzing Encoding Algorithms
  147. Simple Ciphers
  148. Common Cryptographic Algorithms
  149. Custom Encoding
  150. Decoding
  151. Conclusion
  152. Labs
  153. 14. Malware-Focused Network Signatures
  154. Network Countermeasures
  155. Safely Investigate an Attacker Online
  156. Content-Based Network Countermeasures
  157. Combining Dynamic and Static Analysis Techniques
  158. Understanding the Attacker’s Perspective
  159. Conclusion
  160. Labs
  161. V. Anti-Reverse-Engineering
  162. 15. Anti-Disassembly
  163. Understanding Anti-Disassembly
  164. Defeating Disassembly Algorithms
  165. Anti-Disassembly Techniques
  166. Obscuring Flow Control
  167. Thwarting Stack-Frame Analysis
  168. Conclusion
  169. Labs
  170. 16. Anti-Debugging
  171. Windows Debugger Detection
  172. Identifying Debugger Behavior
  173. Interfering with Debugger Functionality
  174. Debugger Vulnerabilities
  175. Conclusion
  176. Labs
  177. 17. Anti-Virtual Machine Techniques
  178. VMware Artifacts
  179. Vulnerable Instructions
  180. Tweaking Settings
  181. Escaping the Virtual Machine
  182. Conclusion
  183. Labs
  184. 18. Packers and Unpacking
  185. Packer Anatomy
  186. Identifying Packed Programs
  187. Unpacking Options
  188. Automated Unpacking
  189. Manual Unpacking
  190. Tips and Tricks for Common Packers
  191. Analyzing Without Fully Unpacking
  192. Packed DLLs
  193. Conclusion
  194. Labs
  195. VI. Special Topics
  196. 19. Shellcode Analysis
  197. Loading Shellcode for Analysis
  198. Position-Independent Code
  199. Identifying Execution Location
  200. Manual Symbol Resolution
  201. A Full Hello World Example
  202. Shellcode Encodings
  203. NOP Sleds
  204. Finding Shellcode
  205. Conclusion
  206. Labs
  207. 20. C++ Analysis
  208. Object-Oriented Programming
  209. Virtual vs. Nonvirtual Functions
  210. Creating and Destroying Objects
  211. Conclusion
  212. Labs
  213. 21. 64-Bit Malware
  214. Why 64-Bit Malware?
  215. Differences in x64 Architecture
  216. Windows 32-Bit on Windows 64-Bit
  217. 64-Bit Hints at Malware Functionality
  218. Conclusion
  219. Labs
  220. A. Important Windows Functions
  221. B. Tools for Malware Analysis
  222. C. Solutions to Labs
  223. Lab 1-1 Solutions
  224. Lab 1-2 Solutions
  225. Lab 1-3 Solutions
  226. Lab 1-4 Solutions
  227. Lab 3-1 Solutions
  228. Lab 3-2 Solutions
  229. Lab 3-3 Solutions
  230. Lab 3-4 Solutions
  231. Lab 5-1 Solutions
  232. Lab 6-1 Solutions
  233. Lab 6-2 Solutions
  234. Lab 6-3 Solutions
  235. Lab 6-4 Solutions
  236. Lab 7-1 Solutions
  237. Lab 7-2 Solutions
  238. Lab 7-3 Solutions
  239. Lab 9-1 Solutions
  240. Lab 9-2 Solutions
  241. Lab 9-3 Solutions
  242. Lab 10-1 Solutions
  243. Lab 10-2 Solutions
  244. Lab 10-3 Solutions
  245. Lab 11-1 Solutions
  246. Lab 11-2 Solutions
  247. Lab 11-3 Solutions
  248. Lab 12-1 Solutions
  249. Lab 12-2 Solutions
  250. Lab 12-3 Solutions
  251. Lab 12-4 Solutions
  252. Lab 13-1 Solutions
  253. Lab 13-2 Solutions
  254. Lab 13-3 Solutions
  255. Lab 14-1 Solutions
  256. Lab 14-2 Solutions
  257. Lab 14-3 Solutions
  258. Lab 15-1 Solutions
  259. Lab 15-2 Solutions
  260. Lab 15-3 Solutions
  261. Lab 16-1 Solutions
  262. Lab 16-2 Solutions
  263. Lab 16-3 Solutions
  264. Lab 17-1 Solutions
  265. Lab 17-2 Solutions
  266. Lab 17-3 Solutions
  267. Lab 18-1 Solutions
  268. Lab 18-2 Solutions
  269. Lab 18-3 Solutions
  270. Lab 18-4 Solutions
  271. Lab 18-5 Solutions
  272. Lab 19-1 Solutions
  273. Lab 19-2 Solutions
  274. Lab 19-3 Solutions
  275. Lab 20-1 Solutions
  276. Lab 20-2 Solutions
  277. Lab 20-3 Solutions
  278. Lab 21-1 Solutions
  279. Lab 21-2 Solutions
  280. Index
  281. Index
  282. Index
  283. Index
  284. Index
  285. Index
  286. Index
  287. Index
  288. Index
  289. Index
  290. Index
  291. Index
  292. Index
  293. Index
  294. Index
  295. Index
  296. Index
  297. Index
  298. Index
  299. Index
  300. Index
  301. Index
  302. Index
  303. Index
  304. Index
  305. Index
  306. Index
  307. Updates
  308. About the Authors
  309. Copyright

P

packed DLLs, Analyzing Without Fully Unpacking
packed executables, Examining PE Files with PEview, Identifying Packed Programs, Identifying Packed Programs, Automated Unpacking, Manual Unpacking
detecting, Examining PE Files with PEview
entropy calculation for, Identifying Packed Programs
identifying, Identifying Packed Programs
loading in OllyDbg, Automated Unpacking
repairing import table for, Manual Unpacking
packed files, Detailed Analysis, Detailed Analysis
indications of, Detailed Analysis
strings and, Detailed Analysis
packed malware, Finding Strings, Detecting Packers with PEiD
detecting with PEiD, Detecting Packers with PEiD
packers, Packers and Unpacking, Packer Anatomy, Loading the Executable, The Tail Jump, The Tail Jump, Repairing the Import Table Manually, Labs, Reviewing the Final Check
anatomy, Packer Anatomy
labs, Labs, Reviewing the Final Check
solutions, Reviewing the Final Check
resolving imports, Loading the Executable
tail jump, The Tail Jump
tips and tricks for common, Repairing the Import Table Manually
unpacking illustrated, The Tail Jump
packet listing, in Wireshark, Monitoring with Netcat
packet sniffing, with Wireshark, Monitoring with Netcat
packing algorithm, program to run in reverse, Automated Unpacking
padding characters, Base64 string and, Identifying and Decoding Base64
Parallels, The Structure of a Virtual Machine
parent classes in C++, Inheritance and Function Overriding, Recognizing a Vtable
child class functions from, Recognizing a Vtable
parent-child relationships, in classes, Inheritance and Function Overriding
parsing routines, Analyze the Parsing Routines, Analyze the Parsing Routines
analyzing, Analyze the Parsing Routines
IDA Pro graph of, Analyze the Parsing Routines
pass-the-hash attacks, GINA Interception
password check function, Detailed Analysis, Detailed Analysis
testing if disabled, Detailed Analysis
passwords, Monitoring with Netcat, Short Answers, Detailed Analysis
getting correct, Detailed Analysis
sniffing, Monitoring with Netcat
PatchByte function, Impossible Disassembly, Impossible Disassembly
PatchGuard, Kernel Issues for Windows Vista, Windows 7, and x64 Versions
patching, in OllyDbg, Patching
payload rule options, in Snort, Intrusion Detection with Snort
PCRE (Perl Compatible Regular Expression) notation, in Snort, Taking a Deeper Look, Identifying and Leveraging the Encoding Steps
pcre Snort rule keyword, Taking a Deeper Look
.pdata section, in PE file, The PE File Headers and Sections
.pdf documents, Analyzing Malicious Documents, Short Answers, Detailed Analysis
analyzing with Process Explorer, Analyzing Malicious Documents
objects created for, Detailed Analysis
PDF Dissector, Tools for Malware Analysis
PDF Tools, Tools for Malware Analysis
PE Explorer, Viewing the Resource Section with Resource Hacker, Entropy Calculation, Tools for Malware Analysis
unpacking plug-ins, Entropy Calculation
PE file format, Detecting Packers with PEiD (see Portable Executable (PE) file format)
PEB (Process Environment Block) structure, Windows Debugger Detection, Checking the BeingDebugged Flag, Detailed Analysis
documented, Checking the BeingDebugged Flag
PEBrowse Professional, Viewing the Resource Section with Resource Hacker
PECompact, Repairing the Import Table Manually
PeekNamedPipe function, Important Windows Functions, Detailed Analysis
PEiD, Detecting Packers with PEiD, Tools for Malware Analysis, Short Answers, Detailed Analysis, Detailed Analysis
detecting packers with, Detecting Packers with PEiD
KANAL output, Detailed Analysis
peripheral devices, connecting and disconnecting, Using Your Malware Analysis Machine
Perl Compatible Regular Expression (PCRE) notation, in Snort, Taking a Deeper Look, Identifying and Leveraging the Encoding Steps
persistence, The Windows Registry, Identifying Keyloggers in Strings Listings, Identifying Keyloggers in Strings Listings, SvcHost DLLs, Trojanized System Binaries, Detailed Analysis, Detailed Analysis
AppInit_DLLs for, Detailed Analysis
DLL load-order hijacking, Trojanized System Binaries
of registry, The Windows Registry
trojanized system binaries, SvcHost DLLs
Windows Registry for, Identifying Keyloggers in Strings Listings
Petite, PECompact
PEview, The PE File Headers and Sections, Tools for Malware Analysis, Short Answers, Short Answers, Detailed Analysis
examining PE files with, The PE File Headers and Sections
finding base address with, Short Answers
original and trojanized versions of cisvc.exe, Detailed Analysis
PhantOm plug-in, Checking the BeingDebugged Flag, The BeingDebugged Flag, The ProcessHeap Flag, Detailed Analysis
Phatbot, VMware detection, Using the Red Pill Anti-VM Technique
phishing, targeted, Indications of Malicious Activity
PIC (position-independent code), Shellcode Analysis
pipe symbol (|), in Snort, Intrusion Detection with Snort
plug-ins, Detecting Packers with PEiD, Using Named Constants, CLSIDs, IIDs, and the Use of COM Objects, Analyzing Shellcode, Checking the BeingDebugged Flag
for extending IDA Pro, Using Named Constants
in OllyDbg, Analyzing Shellcode, Checking the BeingDebugged Flag
PEiD, running of executables, Detecting Packers with PEiD
third-party, for Internet Explorer, CLSIDs, IIDs, and the Use of COM Objects
pointers, handles vs., File System Functions
Poison Ivy, Software Breakpoints, Software Breakpoints, Standard Back Trace, RATs
tracing, Standard Back Trace
use of VirtualAlloc function, Software Breakpoints
polling, User-Space Keyloggers
polymorphism, Virtual vs. Nonvirtual Functions
pop instruction, The Stack, Stack Layout, Finding the OEP Manually, Position-Independent Code
after call, Position-Independent Code
and tail jump, Finding the OEP Manually
pop-up ads, Recovering the Hidden File
popa instruction, Stack Layout, Trojanized System Binaries
popad instruction, Stack Layout
port 80, backdoor and, Downloaders and Launchers
Portable Executable (PE) file format, Detecting Packers with PEiD, PotentialKeylogger.exe: An Unpacked Executable, The PE File Headers and Sections, Examining PE Files with PEview, Viewing the Resource Section with Resource Hacker, IDA Pro, Rebasing, Launchers, Using TLS Callbacks, Inserting INT 3, PE Header Vulnerabilities, Loading the Executable, Repairing the Import Table Manually, Finding kernel32.dll in Memory, Short Answers, Short Answers, Detailed Analysis, Detailed Analysis, Detailed Analysis
.tls section, Using TLS Callbacks, Detailed Analysis
copying sections into memory, Detailed Analysis
examining file structure, Short Answers
header vulnerabilities, OllyDbg, Inserting INT 3
headers and sections, PotentialKeylogger.exe: An Unpacked Executable, Viewing the Resource Section with Resource Hacker
summary information, Viewing the Resource Section with Resource Hacker
IDA Pro support for, IDA Pro
indications in, Detailed Analysis
packed executables formatting of, Loading the Executable
parsing export data, Finding kernel32.dll in Memory
PEview for examining, The PE File Headers and Sections
rebasing and, Rebasing
Resource Hacker tool for viewing, Examining PE Files with PEview
resource section, Launchers, Short Answers
section headers, and OllyDbg crash, PE Header Vulnerabilities
ports, malware use of, Using ApateDNS
position-independent code (PIC), Shellcode Analysis
POST method, Hiding in Plain Sight
printf function, Push vs. Move, Differences in the x64 Calling Convention and Stack Usage, Differences in the x64 Calling Convention and Stack Usage, Detailed Analysis
call compiled for 32-bit processor, Differences in the x64 Calling Convention and Stack Usage
call compiled for 64-bit processor, Differences in the x64 Calling Convention and Stack Usage
IDA Pro problems recognizing, Detailed Analysis
privilege escalation, DLL Load-Order Hijacking, Privilege Escalation
SeDebugPrivilege, Privilege Escalation
privileged mode, Common Exceptions
ProcDump, WinUpack
Process activity filter, in procmon, Filtering in Procmon
process context, Exceptions: When Things Go Wrong
Process Environment Block (PEB) structure, Windows Debugger Detection, Checking the BeingDebugged Flag, Detailed Analysis
documented, Checking the BeingDebugged Flag
Process Explorer, Viewing Processes with Process Explorer, The Process Explorer Display, Using the Verify Option, Using the Verify Option, Basic Dynamic Tools in Practice, Tools for Malware Analysis, Detailed Analysis, Detailed Analysis
comparing strings, Using the Verify Option
Dependency Walker, Using the Verify Option
for finding DLL injection, Detailed Analysis
Verify option, The Process Explorer Display
viewing processes with, Viewing Processes with Process Explorer
Process Hacker, Tools for Malware Analysis
Process Monitor (procmon), Running Malware, Monitoring with Process Monitor, Monitoring with Process Monitor, Filtering in Procmon, Filtering in Procmon, Basic Dynamic Tools in Practice, Tools for Malware Analysis, Detailed Analysis, Detailed Analysis, X64 Code Path
boot logging options, Filtering in Procmon
display, Monitoring with Process Monitor
Filter dialog, Detailed Analysis
filtering in, Monitoring with Process Monitor
filters on toolbar, Filtering in Procmon
reviewing results, Basic Dynamic Tools in Practice
toggling event capture on and off, X64 Code Path
Process Name filter, in procmon, Filtering in Procmon
Process Properties window, Strings tab, Using the Verify Option
process replacement, The Process Explorer Display, DLL Injection
Process32First function, DLL Injection, APC Injection, Important Windows Functions
Process32Next function, DLL Injection, APC Injection, Important Windows Functions
processes, PotentialKeylogger.exe: An Unpacked Executable, The Process Explorer Display, Basic DLL Structure, Basic DLL Structure, Creating a Thread, Manual Unpacking, WinUpack, Analyzing the Functions of the Major Function Table, Detailed Analysis, Detailed Analysis, Detailed Analysis, Detailed Analysis, Short Answers, Detailed Analysis
creating, Basic DLL Structure, Detailed Analysis
dumping from memory, Manual Unpacking, WinUpack
dynamically resolving enumeration imports, Short Answers
EBX register of suspended newly created, Detailed Analysis
enumerating, Detailed Analysis
for following running malware, Basic DLL Structure
function to open and manipulate, PotentialKeylogger.exe: An Unpacked Executable
hidden, Analyzing the Functions of the Major Function Table
interprocess coordination with mutexes, Creating a Thread
Properties window for, The Process Explorer Display
resuming suspended, Detailed Analysis
starting and replacing, Detailed Analysis
ProcessHeap flag, in PEB structure, Checking the ProcessHeap Flag
procmon, Running Malware (see Process Monitor (procmon))
programs, Examining PE Files with PEview (see executables)
prologue, The Stack, Differences in the x64 Calling Convention and Stack Usage
64-bit code, Differences in the x64 Calling Convention and Stack Usage
in functions, The Stack
Properties window, in Process Explorer, The Process Explorer Display
protocols, attackers mimicking existing, Hiding in Plain Sight
psapi.dll, Summary, Short Answers
push instruction, The Stack, Stack Layout, Push vs. Move, Trojanized System Binaries, Understanding Anti-Disassembly, Finding the OEP Manually, WinUpack, Lab 18-3 Solutions
to start functions in disassembly, Finding the OEP Manually
vs. mov, Push vs. Move
with return instruction for tail jump, WinUpack
Pwdump, GINA Interception
PyCommand Python script, Bookmarks
PyCrypto cryptography library, Manual Programming of Decoding Functions, Modified Base64 Decoding, Decrypting AES
potential pitfalls, Decrypting AES
Python, Using IDC Scripts, Bookmarks, Self-Decoding, Tools for Malware Analysis, Detailed Analysis
IDAPython, Using IDC Scripts
program to decode Base64-encoded string, Self-Decoding
PyCommand script, Bookmarks
script for converting data to string, Detailed Analysis